wrap-up
[lambda.git] / rosetta2.mdwn
1 The functional programming literature tends to use one of four languages: Scheme, OCaml, Standard ML (SML), or Haskell. With experience, you'll grow comfortable switching between these. At the beginning, though, it can be confusing.
2
3 The easiest translations are between OCaml and SML. These languages are both derived from a common ancestor, ML. For the most part, the differences between them are only superficial. [Here's a translation manual](http://www.mpi-sws.org/~rossberg/sml-vs-ocaml.html). [Here's another comparison](http://adam.chlipala.net/mlcomp/).
4
5 In some respects OCaml and SML are closer to Scheme than to Haskell: Scheme, OCaml and SML all default to call-by-value evaluation order, and all three have native syntax for mutation and other imperative idioms (though that's not central to their design). Haskell is different in both respects: the default evaluation order is call-by-name (strictly speaking, it's "call-by-need", which is a more efficient cousin), and the only way to have mutation or the like is through the use of monads.
6
7 On both sides, however, the non-default evaluation order can also be had by using special syntax. And in other respects, OCaml and SML are more like Haskell than they are like Scheme. For example, OCaml and SML and Haskell all permit you to declare types and those types are *statically checked*: that is, your program won't even start to be interpreted unless all the types are consistent. In Scheme, on the other hand, type-checking only happens when your program is running, and the language is generally much laxer about what it accepts as well-typed. (There's no problem having a list of mixed numbers and booleans, for example... and you don't need to wrap them in any sum type to do so.)
8
9 Additionally, the syntax of OCaml and SML is superficially much closer to Haskell's than to Scheme's.
10
11 # Comments, Whitespace, and Brackets #
12
13                 -- this is a single line comment in Haskell
14
15                 {- this
16                    is a multiline
17                    comment in Haskell -}
18
19                 (* this is a single or multiline
20                    comment in OCaml *)
21
22                 ; this is a single line comment in Scheme
23
24                 #| this is a
25                    multiline comment
26                    in Scheme |#
27
28                 #;(this is
29                     (another way to
30                       (comment out (a block) (of Scheme code))))
31
32 *       Haskell is sensitive to linespace and indentation: it matters how your code is lined up. OCaml and Scheme don't care about this, though they recommend following some conventions for readability.
33
34 *       In Haskell, a block of code can be bracketed with `{` and `}`, with different expressions separated by `;`. But usually one would use line-breaks and proper indentation instead. In OCaml, separating expressions with `;` has a different meaning, having to do with how side-effects are sequenced. Instead, one can bracket a block of code with `(` and `)` or with `begin` and `end`. In Scheme, of course, every parentheses is significant.
35
36
37 We've written some advice on how to do some OCaml-ish and Haskell-ish things in Scheme, and how to get Scheme-ish continuations in OCaml, [[on another page|/rosetta3]].
38
39
40
41 #Haskell and OCaml#
42
43 Here we will give some general advice about how to translate between OCaml and Haskell.
44
45 *   Our [[more entry-level page|/rosetta1]] comparing Scheme, OCaml, and Haskell (no discussion of types or records)
46 *   It may sometimes be useful to try [OCaml](http://try.ocamlpro.com/) or [Haskell](http://tryhaskell.org/) in your web browser
47 *   See our pages about [[learning OCaml]] and [[learning Haskell]]
48 *   Another page comparing Haskell and OCaml: [Haskell for OCaml Programmers](http://blog.ezyang.com/2010/10/ocaml-for-haskellers/)
49 *   Here's the other direction: [Introduction to OCaml for Haskellers](http://foswiki.cs.uu.nl/foswiki/pub/Stc/BeyondFunctionalProgrammingInHaskell:AnIntroductionToOCaml/ocaml.pdf), [another](http://blog.ezyang.com/2010/10/ocaml-for-haskellers/)
50 *   Haskell Wiki on [OCaml](https://wiki.haskell.org/OCaml)
51 *   [ML Dialects and Haskell](http://hyperpolyglot.org/ml); this discusses other ML-ish languages as well as OCaml and Haskell
52 *   Quora discussion of the [differences between Haskell and ML languages](http://www.quora.com/What-are-the-key-differences-between-Haskell-and-Standard-ML?browse)
53 *   [Another discussion](http://jxyzabc.blogspot.com/2009/03/haskell-vs-ocaml-or-ravings-of.html)
54
55
56 <!--
57 TODO
58 *       There are many Haskell tutorials and textbooks available. This is probably the most actively developed: [Haskell wikibook](http://en.wikibooks.org/wiki/Haskell)
59 *       [Yet Another Haskell Tutorial](http://www.cs.utah.edu/~hal/docs/daume02yaht.pdf) (much of this excellent book has supposedly been integrated into the Haskell wikibook)
60 *       All About Monads has supposedly also been integrated into the Haskell wikibook
61 *       (A not-so-)[Gentle Introduction to Haskell](http://web.archive.org/web/http://www.haskell.org/tutorial/) (archived)
62 *       [Learn You a Haskell for Great Good](http://learnyouahaskell.com/)
63 -->
64
65
66 ##Type expressions##
67
68 *       In Haskell, you say a value has a certain type with: `value :: type`. You express the operation of prepending a new `int` to a list of `int`s with `1 : other_numbers`. In OCaml it's the reverse: you say `value : type` and `1 :: other_numbers`.
69
70 *       In Haskell, type names and constructors both begin with capital letters, and type variables always appear after their constructors, in Curried form. And the primary term for declaring a new type is `data` (short for [[!wikipedia algebraic data type]]). So we have:
71
72                 data Either a b = Left a | Right b;
73                 data FooType a b = Foo_constructor1 a b | Foo_constructor2 a b;
74
75         In printed media, Haskell type variables are often written using Greek letters, like this:
76
77         <pre><code>type Either &alpha; &beta; = Left &alpha; | Right &beta;
78         </code></pre>
79
80         Some terminology: in this type declaration, `Either` is known as a *type-constructor*, since it takes some types <code>&alpha;</code> and <code>&beta;</code> as arguments and yields a new type. We call <code>Left &alpha;</code> one of the *variants* for the type <code>Either &alpha; &beta;</code>. `Left` and `Right` are known as *value constructors* or *data constructors* or just *constructors*. You can use `Left` in any context where you need a function, for example:
81
82                 map Left [1, 2]
83
84         In OCaml, value constructors are still capitalized, but type names are lowercase. Type variables take the form `'a` instead of `a`, and if there are multiple type variables, they're not Curried but instead have to be grouped in a tuple. The syntax for whether they appear first or second is also somewhat different. So we have instead:
85
86                 type ('a,'b) either = Left of 'a | Right of 'b;;
87                 type ('a,'b) foo_type = Foo_constructor1 of 'a * 'b | Foo_constructor2 of 'a * 'b;;
88
89         In OCaml, constructors aren't full-fledged functions, so you need to do this instead:
90
91                 List.map (fun x -> Left x) [1; 2]
92
93         Apart from these differences, there are many similarities between Haskell's and OCaml's use of constructors. For example, in both languages you can do:
94
95                 let Left x = Left 1 in x + 1
96
97 *       In addition to the `data` keyword, Haskell also sometimes uses `type` and `newtype` to declare types. `type` is used just to introduce synonyms. If you say:
98
99                 type Weight = Integer
100                 type Person = (Name, Address)    -- supposing types Name and Address to be declared elsewhere
101
102         then you can use a value of type `Integer` wherever a `Weight` is expected, and vice versa. <!-- `type` is allowed to be parameterized -->
103
104         `newtype` and `data` on the other hand, create genuinely new types. `newtype` is basically just an efficient version of `data` that you can use in special circumstances. `newtype` must always take one type argument and have one value constructor. For example:
105
106                 newtype PersonalData a = PD a
107
108         You could also say:
109
110                 data PersonalData2 a = PD2 a
111
112         And `data` also allows multiple type arguments, and multiple variants and value constructors. <!-- Subtle difference: whereas `PersonalData a` is isomorphic to `a`, `PersonalData2 a` has an additional value, namely `PD2 _|_`. In a strict language, this is an additional type an expression can have, but it would not be a value. -->
113
114         OCaml just uses the one keyword `type` for all of these purposes:
115
116                 type weight = int;;
117                 type person = name * address;;
118                 type 'a personal_data = PD of 'a;;
119
120 *       When a type only has a single variant, as with PersonalData, Haskell programmers will often use the same name for both the type and the value constructor, like this:
121
122                 data PersonalData3 a = PersonalData3 a
123
124         The interpreter can always tell from the context when you're using the type name and when you're using the value constructor.
125
126 *       The type constructors discussed above took simple types as arguments. In Haskell, types are also allowed to take *type constructors* as arguments:
127
128                 data BarType t = Bint (t Integer) | Bstring (t string)
129
130         One does this for example when defining monad transformers---the type constructor `ReaderT` takes some base monad's type constructor as an argument.
131
132         The way to do this this in OCaml is less straightforward. You have to use parameterized modules. See our [[Ramble on Monads and modules|/topics/week8_monads_and_modules]] for discussion.
133
134 *       So here's a summary of how some different type declarations look in Haskell:
135
136             data Pretty1 a b = Lovely a | Cute b ClothingModule.ButtonType
137             newtype Pretty2 a b = Pretty2 a b Int
138             type Pretty3 a b = (a, b)
139
140         and in OCaml:
141
142             type ('a,'b) pretty1 = Lovely of 'a | Cute of 'b * ClothingModule.ButtonType
143             type ('a,'b) pretty2 = Pretty2 of 'a * 'b * int
144             type ('a,'b) pretty3 = 'a * 'b
145
146         There's also:
147
148             -- Haskell
149             newtype Pretty4 a b = Pretty4 { unPretty a }
150
151             (* OCaml *)
152             type ('a,'b) pretty4 = Pretty4 of 'a
153             (* or *)
154             type ('a,'b) pretty4 = { pretty4: 'a }
155
156         We will discuss record types further below.
157
158 *       Haskell has a notion of *type-classes*. They look like this:
159
160                 class Eq a where
161                   (==)    :: a -> a -> Bool
162
163         This declares the type-class `Eq`; in order to belong to this class, a type `a` will have to supply its own implementation of the function `==`, with the type `a -> a -> Bool`. Here is how the `Integer` class signs up to join this type-class:
164
165                 instance Eq Integer where
166                   x == y  =  ... some definition for the Integer-specific version of that function here ...
167
168         Type expressions can be conditional on some of their parameters belonging to certain type-classes. For example:
169
170                 elem      :: (Eq a) => a -> [a] -> Bool
171
172         says that the function `elem` is only defined over types `a` that belong to the type-class `Eq`. For such types `a`, `elem` has the type `a -> [a] -> Bool`.
173
174         Similarly:
175
176                 instance (Eq a) => Eq (Tree a) where
177                   Leaf a         == Leaf b          =  a == b
178                   (Branch l1 r1) == (Branch l2 r2)  =  (l1==l2) && (r1==r2)
179                   _              == _               =  False
180
181         says that if `a` belongs to the typeclass `Eq`, then so too does `Tree a`, and in such cases here is the implementation of `==` for `Tree a`...
182
183         We also discuss type-classes briefly in our [[Ramble on Monads and modules|/topics/week8_monads_and_modules]] for discussion.
184
185
186 *       OCaml doesn't have type-classes. You can do something similar with OCaml modules that take are parameterized on other modules. See the page just linked for discussion.
187
188
189 *       Some specific differences in how certain types are expressed. This block in Haskell:
190
191                 Prelude> type Maybe a = Nothing | Just a
192                 Prelude> let x = [] :: [Int]
193                 Prelude> :t x
194                 x :: [Int]
195                 Prelude> let x = () :: ()
196                 Prelude> let x = (1, True) :: (Int, Bool)
197
198         corresponds to this block in OCaml:
199
200                 # type 'a option = None | Some of 'a;;
201                 type 'a option = None | Some of 'a
202                 # let (x : int list) = [];;
203                 val x : int list = []
204                 # let (x : unit) = ();;
205                 val x : unit = ()
206                 # let (x : int * bool) = (1, true);;
207                 val x : int * bool = (1, true)
208
209 *       Haskell has a plethora of numerical types, including the two types `Int` (integers limited to a machine-dependent range) and `Integer` (unbounded integers). The same arithmetic operators (`+` and so on) work for all of these. OCaml also has several different numerical types (though not as many). In OCaml, by default, one has to use a different numerical operator for each type:
210
211                 # 1 + 2;;
212                 - : int = 3
213                 # 1.0 + 2.0;;
214                 Error: This expression has type float but an expression was expected of type int
215                 # 1.0 +. 2.0;;
216                 - : float = 3.
217
218         However the comparison operators are polymorphic. You can equally say:
219
220                 # 1 = 2;;
221                 - : bool = false
222                 # 1.0 = 2.0;;
223                 - : bool = false
224                 # 2 > 1;;
225                 - : bool = true
226                 # 2.0 > 1.0;;
227                 - : bool = true
228
229         But you must still apply these operators to expressions of the same type:
230
231                 # 2.0 > 1;;
232                 Error: This expression has type int but an expression was expected of type float
233
234
235 *       We'll discuss differences between Haskell's and OCaml's record types below.
236
237
238 ##Lists, Tuples, Unit, Booleans##
239
240 *       As noted above, Haskell describes the type of a list of `Int`s as `[Int]`. OCaml describes it as `int list`. Haskell describes the type of a pair of `Int`s as `(Int, Int)`. OCaml describes it as `int * int`. Finally, Haskell uses `()` to express both the unit type and a value of that type. In OCaml, one uses `()` for the value and `unit` for the type.
241
242 *       Haskell describes the boolean type as `Bool` and its variants are `True` and `False`. OCaml describes the type as `bool` and its variants are `true` and `false`. This is an inconsistency in OCaml: other value constructors must always be capitalized.
243
244 *       As noted above, in Haskell one builds up a list by saying `1 : [2, 3]`. In OCaml one says `1 :: [2; 3]`. In Haskell, one can test whether a list is empty with either:
245
246                 lst == []
247                 null lst
248
249         In OCaml, there is no predefined `null` or `isempty` function. One can still test whether a list is empty using the comparison `lst = []`. Our [[Juli8 libraries|/juli8]] also provide `List.is_null`.
250
251 *       In Haskell, the expression `[1..5]` is the same as `[1,2,3,4,5]`, and the expression `[0..]` is a infinite lazily-evaluated stream of the natural numbers. In OCaml, there is no `[1..5]` shortcut, lists must be finite, and they are eagerly evaluated. It is possible to create lazy streams in OCaml, even infinite ones, but you have to use other techniques than the native list type.
252
253 *       Haskell has *list comprehensions*:
254
255                 [ x * x | x <- [1..10], odd x]
256
257         In OCaml, one has to write this out longhand:
258
259                 List.map (fun x -> x * x) (List.filter odd [1..10]);;
260
261 *       In Haskell, the expressions `"abc"` and `['a','b','c']` are equivalent. (Strings are just lists of `char`s.) In OCaml, these expressions have two different types.
262
263         Haskell uses the operator `++` for appending both strings and lists (since Haskell strings are just one kind of list). OCaml uses different operators:
264
265                 # "string1" ^ "string2";;
266                 - : string = "string1string2"
267                 # ['s';'t'] @ ['r';'i';'n';'g'];;
268                 - : char list = ['s'; 't'; 'r'; 'i'; 'n'; 'g']
269                 # (* note that Haskell uses the `@` symbol differently, for "as-patterns", discussed below *)
270                   (* equivalently, in OCaml you can say *)
271                   List.append ['s';'t'] ['r';'i';'n';'g'];;
272                 - : char list = ['s'; 't'; 'r'; 'i'; 'n'; 'g']
273
274
275 ##Let and Where##
276
277 *       Haskell permits both:
278
279                 foo x =
280                   let result1 = x * x
281                       result2 = x + 1
282                   in result1 + result2
283
284         and:
285
286                 foo x = result1 + result2
287                   where result1 = x * x
288                         result2 = x + 1
289
290         OCaml permits only:
291
292                 let foo x =
293                   let result1 = x * x
294                   in let result2 = x + 1
295                   in result1 + result2;;
296
297 ##Patterns##
298
299 *       In OCaml:
300
301                 # let (x, y) as both = (1, 2)
302                   in (both, x, y);;
303                 - : (int * int) * int * int = ((1, 2), 1, 2)
304
305
306         The same in Haskell:
307
308                 let both@(x,y) = (1, 2)
309                   in (both, x, y)
310
311 *       In OCaml:
312
313                 match list_expression with
314                   | y::_ when odd y -> result1
315                   | y::_ when y > 5 -> result2
316                   | y::_ as whole -> (whole, y)
317                   | [] -> result4
318
319         The same in Haskell:
320
321                 case list_expression of
322                   (y:_) | odd y -> result1
323                         | y > 5 -> result2
324                   whole@(y:_) -> (whole, y)
325                   [] -> result4
326
327
328 ##Records##
329
330 Haskell and OCaml both have `records`, which are essentially just tuples with a pretty interface. We introduced these in the wiki notes [here](/coroutines_and_aborts/).
331
332 The syntax for declaring and using these is a little bit different in the two languages.
333
334 *       In Haskell one says:
335
336                 -- declare a record type
337                 data Color = Col { red, green, blue :: Int }
338                 -- create a value of that type
339                 let c = Col { red = 0, green = 127, blue = 255 }
340
341         In OCaml one says instead:
342
343                 type color = { red : int; green : int; blue : int };;
344                 let c = { red = 0; green = 127; blue = 255 }
345
346         Notice that OCaml doesn't use any value constructor `Col`. The record syntax `{ red = ...; green = ...; blue = ... }` is by itself the constructor. The record labels `red`, `green`, and `blue` cannot be re-used for any other record type.
347
348 *       In Haskell, one may have multiple constructors for a single record type, and one may re-use record labels within that type, so long as the labels go with fields of the same type:
349
350                 data FooType = Constructor1 {f :: Int, g :: Float} | Constructor2 {f :: Int, h :: Bool}
351
352 *       In Haskell, one can extract a single field of a record like this:
353
354                 let c = Col { red = 0, green = 127, blue = 255 }
355                 in red c    -- evaluates to 0
356
357         In OCaml one says:
358
359                 let c = { red = 0; green = 127; blue = 255 }
360                 in c.red    (* evaluates to 0 *)
361
362 *       In both languages, there is a special syntax for creating a copy of an existing record, with some specified fields altered. In Haskell:
363
364                 let c2 = c { green = 50, blue = 50 }
365                 -- evaluates to Col { red = red c, green = 50, blue = 50 }
366
367         In OCaml:
368
369                 let c2 = { c with green = 50; blue = 50 }
370                 (* evaluates to { red = c.red; green = 50; blue = 50 }
371
372 *       One pattern matches on records in similar ways. In Haskell:
373
374                 let Col { red = r, green = g } = c
375                 in r
376
377         In OCaml:
378
379                 let { red = r; green = g; _ } = c
380                 in r
381
382         In Haskell:
383
384                 makegray c@(Col { red = r } ) = c { green = r, blue = r }
385
386         is equivalent to:
387
388                 makegray c = let Col { red = r } = c
389                              in { red = r, green = r, blue = r }
390
391         In OCaml it's:
392
393                 # let makegray ({ red = r; _ } as c) = { c with green=r; blue=r };;
394                 val makegray : color -> color = <fun>
395                 # makegray { red = 0; green = 127; blue = 255 };;
396                 - : color = {red = 0; green = 0; blue = 0}
397
398 *       Records just give your types a pretty interface; they're entirely dispensable. Instead of:
399
400                 type color = { red : int; green : int; blue : int };;
401                 let c = { red = 0; green = 127; blue = 255 };;
402                 let r = c.red;;
403
404         You could instead just use a more familiar data constructor:
405
406                 type color = Color of (int * int * int);;
407                 let c = Color (0, 127, 255);;
408         
409         and then extract the field you want using pattern-matching:
410
411                 let Color (r, _, _) = c;;
412                 (* or *)
413                 match c with Color (r, _, _) -> ...
414
415         (Or you could just use bare tuples, without the `Color` data constructor.)
416
417         The record syntax only exists because programmers sometimes find it more convenient to say:
418
419                 ... c.red ...
420
421         than to reach for those pattern-matching constructions.
422
423
424
425 ##Functions##
426
427 *       In Haskell functions are assumed to be recursive, and their types and applications to values matching different patterns are each declared on different lines. So we have:
428
429                 factorial    :: int -> int
430                 factorial 0  =  1
431                 factorial n  =  n * factorial (n-1)
432
433         In OCaml you must explicitly say when a function is recursive; and this would be written instead as:
434
435                 let rec factorial (n : int) : int =
436                   match n with
437                     | 0 -> 1
438                     | x -> x * factorial (x-1)
439
440         or:
441
442                 let rec factorial : int -> int =
443                   fun n -> match n with
444                     | 0 -> 1
445                     | x -> x * factorial (x-1)
446
447         or (though we recommend not using this last form):
448
449                 let rec factorial : int -> int =
450                   function
451                     | 0 -> 1
452                     | x -> x * factorial (x-1)
453
454 *       Another example, in Haskell:
455
456                 length         :: [a] -> Integer
457                 length []      =  0
458                 length (x:xs)  =  1 + length xs
459
460         In OCaml:
461
462                 let rec length : 'a list -> int =
463                   fun lst -> match lst with
464                     | [] -> 0
465                     | x::xs -> 1 + length xs
466
467 *       Another example, in Haskell:
468
469                 sign x | x >  0      = 1
470                        | x == 0      = 0
471                        | otherwise   = -1
472
473         In OCaml:
474
475                 let sign x = match x with
476                   | x' when x' > 0 -> 1
477                   | x' when x' = 0 -> 0
478                   | _ -> -1
479
480 *       In Haskell the equality comparison operator is `==`, and the non-equality operator is `/=`. In OCaml, `==` expresses "physical identity", which has no analogue in Haskell because Haskell has no mutable types. See our discussion of "Four grades of mutation involvement" in the [[Week9]] notes. In OCaml the operator corresponding to Haskell's `==` is just `=`, and the corresponding non-equality operator is `<>`.
481
482 *       In both Haskell and OCaml, one can use many infix operators as prefix functions by parenthesizing them. So for instance:
483
484                 (+) 1 2
485
486         will work in both languages. One notable exception is that in OCaml you can't do this with the list constructor `::`.
487
488                 # (::);;
489                 Error: Syntax error
490                 # (::) 1 [1; 2];;
491                 Error: Syntax error
492                 # (fun x xs -> x :: xs) 1 [1; 2];;
493                 - : int list = [1; 1; 2]
494
495         Another tricky issue is that whereas you can equally well write `(+)` or `( + )` in OCaml, writing `(*)` for the multiplication operator doesn't parse properly because of how OCaml processes comments. For that specific operation, you must write it with the extra spaces, as `( * )`.
496
497 *       Haskell also permits two further shortcuts here that OCaml has no analogue for. In Haskell, in addition to writing:
498
499                 (>) 2 1
500
501         you can also write either of:
502
503                 (2 >) 1
504                 (> 1) 2
505
506         In OCaml one has to write these out longhand:
507
508                 (fun y -> 2 > y) 1;;
509                 (fun x -> x > 1) 2;;
510
511         Also, in Haskell, there's a special syntax for using what are ordinarily prefix functions as infix operators:
512
513                 Prelude> elem 1 [1, 2]
514                 True
515                 Prelude> 1 `elem` [1, 2]
516                 True
517
518         In OCaml one can't do that. There's only:
519
520                 # List.mem 1 [1; 2];;
521                 - : bool = true
522
523 *       As mentioned before, data constructors like `Just` in Haskell can also be used as functions, for example they can be passed as arguments to higher order functions. This is not so in OCaml; you have to use `fun x -> Some x`. [[Juli8|/juli8]] provides a few such functions (`Option.some`, `List.cons`, `Monad.LTree.leaf`).
524
525 *       In Haskell one writes anonymous functions like this:
526
527                 \x -> x + 1
528
529         In OCaml it's:
530
531                 fun x -> x + 1
532
533 *       Haskell uses the period `.` as a composition operator:
534
535                 g . f
536                 -- same as
537                 \x -> g (f x)
538
539         The [[Juli8 libraries|/juli8]] provide `%` as a counterpart of this in OCaml. Otherwise in OCaml, one has to write it out longhand:
540
541                 fun x -> g (f x)
542
543 *       In Haskell, expressions like this:
544
545                 g $ f x y
546
547         are equivalent to:
548
549                 g (f x y)
550
551         (Think of the period in our notation for the untyped lambda calculus.) Note that this operator associates to the right: `g $ f x $ h y` is `g (f x (h y))` not `g (f x) (h y)`.
552
553         For complex reasons, OCaml can't make operators beginning with `$` be right-associative, so they express this instead as:
554
555                 g @@ f x y
556
557         OCaml also has the equivalent form:
558
559                 f x y |> g
560
561 *       The names of standard functions, and the order in which they take their arguments, may differ. In Haskell:
562
563                 Prelude> :t foldr
564                 foldr :: (a -> b -> b) -> b -> [a] -> b
565
566         In OCaml:
567
568                 # List.fold_right;;
569                 - : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b = <fun>
570
571 *       Some functions are predefined in Haskell but not in OCaml. Here are OCaml definitions for some common ones. (These are all predefined in [[Juli8|/juli8]], except that there `id` is `ident`.)
572
573                 let id x = x;;
574                 let const x _ = x;;
575                 let flip f x y = f y x;;
576                 let curry (f : ('a, 'b) -> 'c) = fun x y -> f (x, y);;
577                 let uncurry (f : 'a -> 'b -> 'c) = fun (x, y) -> f x y;;
578
579         `fst` and `snd` (defined only on pairs) are provided in both languages. Haskell has `head` and `tail` for lists; these will raise an exception if applied to `[]`. In OCaml the corresponding functions are `List.hd` and `List.tl`. ([[Juli8|/juli8]] renames them to `List.head` and `List.tail`, and also provides a few variations.) Many other Haskell list functions like `length` are available in OCaml as `List.length`, but OCaml's standard libraries are leaner that Haskell's.
580
581 *       The `until` function in Haskell is used like this:
582
583                 until (\l -> length l == 4) (1 : ) []
584                 -- evaluates to [1,1,1,1]
585
586                 until (\x -> x == 10) succ 0
587                 -- evaluates to 10
588
589         This can be defined in OCaml as:
590
591                 let rec until test f z =
592                   if test z then z else until test f (f z)
593
594         Using [[Juli8|/juli8]], this can also be expressed as `iter_while (non test) f z`.
595
596
597 ##Lazy or Eager##
598
599 *       As we've mentioned several times, Haskell's evaluation is by default *lazy* or "call-by-need" (that's an efficient version of "call-by-name" that avoids computing the same results again and again). In some places Haskell will force evaluation to be *eager* or "strict". This is done in several different ways; the symbols `!` and `seq` are signs that it's being used.
600
601 *       Like Scheme and most other languages, OCaml is by default eager. Laziness can be achieved either by using thunks:
602
603                 # let eval_later1 () = 2 / 2;;
604                 val eval_later1 : unit -> int = <fun>
605                 # let eval_later2 () = 2 / 0;;
606                 val eval_later2 : unit -> int = <fun>
607                 # eval_later1 ();;
608                 - : int = 1
609                 # eval_later2 ();;
610                 Exception: Division_by_zero.
611
612         or by using the special forms `lazy` and `Lazy.force`:
613
614                 # let eval_later3 = lazy (2 / 2);;
615                 val eval_later3 : int lazy_t = <lazy>
616                 # Lazy.force eval_later3;;
617                 - : int = 1
618                 # eval_later3;;
619                 - : int lazy_t = lazy 1
620
621         Notice in the last line the value is reported as being `lazy 1` instead of `<lazy>`. Since the value has once been forced, it won't ever need to be recomputed. The thunks are less efficient in this respect. Even though OCaml will now remember what `eval_later3` should be forced to, `eval_later3` is still type-distinct from a plain `int`.
622
623
624 ##Monads##
625
626 Haskell has more built-in support for monads, but one can define the monads one needs in OCaml. (Or use the [[Monad libraries from Juli8|/topics/week9_using_the_monad_library]].)
627
628 *       In our seminar, we've been calling one monadic operation `mid`; in Haskell the same operation is called `return`. We've been calling another monadic operation `mbind`, sometimes used in prefix form, like this:
629
630                 mbind xx k
631
632         We've also used the infix form:
633
634                 xx >>= k
635
636         In Haskell, one uses the infix operator `>>=` to express bind instead:
637
638                 xx >>= k
639
640 *       Haskell also uses the operator `>>`, where `xx >> yy` means the same as `xx >>= \_ -> yy`. Juli8 provides this too.
641
642 *       In Haskell, one can generally just use plain `return` and `>>=` and the interpreter will infer what monad you must be talking about from the surrounding type constraints. In OCaml, you generally need to be specific about which monad you're using. So in these notes, when mutiple monads are on the table, we've defined operations as `reader_mid` and `reader_bind`, and so on. Or, using the Juli8 libraries, you will say things like this:
643
644             Monad.List.(... >>= ...)
645
646         or like this:
647
648             module R = Monad.Reader(struct type env = ... end)
649             R.(... >>= ...)
650
651 *       Haskell has a special syntax for working conveniently with monads. It looks like this. Assume `xx` `yy` and `zz` are values of some monadic type `M a`; then `x` `y` and `w` will be variables of type `a`:
652
653                 do
654                   x <- xx
655                   y <- yy
656                   zz
657                   let w = foo x y
658                   return w
659
660         This is equivalent in meaning to the following:
661
662                 xx >>= \ x ->
663                 yy >>= \ y ->
664                 zz >>= \ _ ->
665                 let w = foo x y
666                 in return w
667
668         which can be translated straightforwardly into OCaml.
669
670         For more details, see:
671
672         *       [Haskell wikibook on do-notation](http://en.wikibooks.org/wiki/Haskell/do_Notation)
673         *       [Yet Another Haskell Tutorial on do-notation](http://en.wikibooks.org/wiki/Haskell/YAHT/Monads#Do_Notation)
674         *       [Do-notation considered harmful](http://www.haskell.org/haskellwiki/Do_notation_considered_harmful)
675
676 *       If you like the Haskell do-notation, there's [a library](http://www.cas.mcmaster.ca/~carette/pa_monad/) you can compile and install to let you use something similar in OCaml.
677
678 *       In order to do any printing, Haskell has to use a special `IO` monad. So programs will look like this:
679
680                 main :: IO ()
681                 main = do
682                   let s = "hello world"
683                   putStrLn s
684         
685                 main :: IO String
686                 main = do
687                   let s = "hello world"
688                   putStrLn s
689                   return s
690         
691                 main :: IO String
692                 main = let s = "hello world"
693                        in putStrLn s >> return s
694
695         OCaml permits you to mix side-effects with regular code, so you can just print, without needing to bring in any monad:
696
697                 let main =
698                   let s = "hello world"
699                   in let () = print_endline s
700                   in s;;
701
702         or:
703
704                 let main =
705                   let s = "hello world"
706                   in print_endline s ; s;;
707