Martin Vlk [EMAIL PROTECTED] writes:
http://www-i2.informatik.rwth-aachen.de/Staff/Current/michaelw/sttt-ml-haskell.pdf
Interesting to see others' experiences, even if they are slightly
negative.
It contains descriptions of lots of real-world problems and how
They are only implementing
Hi folks,
have you read this paper:
http://www-i2.informatik.rwth-aachen.de/Staff/Current/michaelw/sttt-ml-haskell.pdf
It contains descriptions of lots of real-world problems and how easily they
are solved with Haskell (and ML, because the paper compares the two
languages).
Among other things
My 2-pence worth on static typing.
Static typing to me seems to be a simplified form of design by contract.
There are some things about a program that can be proved true for all
time. Types are an example of such a thing. We can use type systems to
make assertions about properties that must
On Tuesday 16 August 2005 21:56, Keean Schupke wrote:
You can even use existential types to create lists of things with a
common interface, where you do not know in advance what types you may
need:
data XWrap = XWrap (forall a . Show a = a)
type ListXWrap = [XWrap]
You probably
Keean Schupke wrote:
Other things we can do ... with dependant types we can ask the compiler
to prove the correctness of sorting algorithms. If we define an ordered
list tgo be one where each element must be larger than the preceding one:
data OrderedIntList = Cons (a::Int)
Benjamin Franksen wrote:
On Tuesday 16 August 2005 21:56, Keean Schupke wrote:
You can even use existential types to create lists of things with a
common interface, where you do not know in advance what types you may
need:
data XWrap = XWrap (forall a . Show a = a)
type ListXWrap =
On Tuesday 16 August 2005 22:29, Keean Schupke wrote:
Benjamin Franksen wrote:
On Tuesday 16 August 2005 21:56, Keean Schupke wrote:
You can even use existential types to create lists of things with a
common interface, where you do not know in advance what types you
may need:
data
Lennart Augustsson wrote:
Keean Schupke wrote:
quicksort :: IntList - OrderedIntList
By this we are asking the compiler to prove (by induction) that the
function provided can only result in
correctly ordered lists - irrespective of what arguments it is given
(ie proved true for any
Benjamin Franksen wrote:
as in
data XWrap = Show a = XWrap a
I always thought this was a pretty nice idea.
Wow, I hadn't thought of that... of course you still need to explicitly
give the
universal quantification if you need it. I guess the best option is to
make it
optional, as I
[Moved to the Haskell cafe]
It's Friday afternoon here so I thought I'd join in the fun.
On Thu, 2005-08-11 at 23:01 -0400, [EMAIL PROTECTED] wrote:
While you can't be certain that once your code typechecks, it's bug-free
(though that does often happen), you can be almost guaranteed that if
The previous comments make sense to me. The lots-of-unit-tests aspect of
static typing I find really useful, far exceeding any BDSM cost. If I'm
engaging in exploratory programming, the type inference combined with the
ability to write 'error armadillo' in stubs for values I can't be
bothered to
11 matches
Mail list logo
