We have all learned functional programming in Haskell, but there are more functional languages like Lisp, Scheme, ML, and Clean.http://www.cs.uu.nl/wiki/pub/Stc/BeyondFunctionalProgrammingInHaskell:AnIntroductionToOCaml/ocaml.pdf
Why should we even bother to look further than Haskell?
- You want your programs to run faster.
- Monads drive you mad (what are they anyway? warm fuzzy things?).
- You need objects.
- You sometimes need a more powerful module system.
(+.) : float -> float? map factorial [1..100] |> take 3 - lazy only performs factorial 3 times while both strict and imperative have the same problem of 100 factorials. explicitness is always better in terms of obvious correctnessSo each type should always have its own distinct functions for everything and 8.0 + 4.0 is less correct than 8 + 4? Laughable, get back to your ungeneric C toilet-scrubbing.
language's defaults matterFor the purposes of your current argument only.
8.0 + 4.0 is less correct than 8 + 4?No, 8. /. 3. is different to 8 / 3. Floats and integers are intrinsically different.
a + b makes it really hard to understand what is actually going on. Is it... could it possibly be... addition?.. I once spent two and a half hours figuring out what + meant in a particular hard-to-absorb context, so I definitely hear your pain there.I understand that OCaml does not have generics.No. OCaml makes the curious choice of disallowing implicit type conversions and not having any operators overloaded by type, even between scalar numeric types.
Yes, seeing things like a + b makes it really hard to understand what is actually going on. Is it... could it possibly be... addition?It depends. If it's Javascript it's more likely to coerce one or both arguments to string and perform concatenation than it is to perform arithmetic. (If it's C++ god only knows what it's going to do.)
> 1 + 2;;
val it : int = 3 // duh
> 1. + 2.;;
val it : float = 3.0 // cool
> "a" + "b";;
val it : string = "ab" // hang on a sec
> let f a b = a + b;;
val f : a:int -> b:int -> int // hey wait I thought + was generic? at least you can't call this on strings.
> 1. + 2;;
1. + 2;;
-----^
.../stdin(14,6): error FS0001: The type 'int' does not match the type 'float' // aw dangPrelude> import Data.Bits
Prelude Data.Bits> shiftL 33 4
528
Prelude Data.Bits> shiftL 33.3 4
<interactive>:5:1:
No instance for (Bits a0) arising from a use of `shiftL'
The type variable `a0' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there are several potential instances:
instance Bits Int -- Defined in `Data.Bits'
instance Bits Integer -- Defined in `Data.Bits'
instance Bits GHC.Types.Word -- Defined in `Data.Bits'
In the expression: shiftL 33.3 4
In an equation for `it': it = shiftL 33.3 4
<interactive>:5:8:
No instance for (Fractional a0) arising from the literal `33.3'
The type variable `a0' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there are several potential instances:
instance Fractional Double -- Defined in `GHC.Float'
instance Fractional Float -- Defined in `GHC.Float'
instance Integral a => Fractional (GHC.Real.Ratio a)
-- Defined in `GHC.Real'
In the first argument of `shiftL', namely `33.3'
In the expression: shiftL 33.3 4
In an equation for `it': it = shiftL 33.3 4length foo. By your assumption I don't care bout the actual type of foo, but now I want to add something to it. Oh shit! Suddenly I need to know if it's a list so I can prepend to it, or a hash so I need a key to go with the value, or a mutable array so I should be smashing my eyes open with a hammer, or maybe I can just use + on it and hope for the best, eh?It's hardly curious.It's curious to the uninitiated and rare, so generally curious. Do you think I was trying to say it was somehow bad or wrong?
Let's take length.I don't know what point >>94 was really trying to make here. Your bleating is really strange in the face of
( > ) which is typed 'a -> 'a -> bool. But do let us take length:# let len x = x#length;;
val len : < length : 'a; .. > -> 'a = <fun>Error: This expression has type 'a list but an expression was expected of type < length : 'a; .. >(>) isBy your assumption I don't care bout the actual type of foo
foo, you probably need to know its type - but you shouldn't have to use some shitty ungeneric function just to find the damn length of it. The programmer has been spared a bit of free time and a modicum of frustration, thank God!In the real world you can trust sensible programmers
a person who thinks that SML functors are part of the Haskell LanguageNo. I was talking about The OCaml Language. Apparently I should have been more explicit. No wonder you are so stressed. My apologies. Google-fu was in reference to the observation that your knowledge on SML functors appeared to derive from a 5-minute google session on the search term "SML overloading".
generic zippersAm I missing something? Why does a zipper need to be generic, and not just parameterised?
I need everything to be an object. Tastes foul.This isn't an error, but: no shit, that's why we don't do it. Which is exactly what I've been saying.
The implementation of > is the problem hereThat's not a hole in the type system it's just an oracular function, and no worse than
read_line. OCaml is full of this stuff... I/O, Gc, FFI. You want holes in the type system? Start looking into Obj.magic, ( > ) and friends aren't going to do it for you. Module.operation foo in OCaml. We would more likely mistake the operands for basic types than anything else.