X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=translating_between_OCaml_Scheme_and_Haskell.mdwn;h=b893896283a27cc5f027b3a1bd72561957835727;hp=4a4287a1e776a13524b7db78d2ef9de43fb83b00;hb=8e24378981bd4095fe580475cf6a530e168965b1;hpb=a7d3954c76604eea8d2c392c5eb2f9d11891460a

diff --git a/translating_between_OCaml_Scheme_and_Haskell.mdwn b/translating_between_OCaml_Scheme_and_Haskell.mdwn
index 4a4287a1..b8938962 100644
--- a/translating_between_OCaml_Scheme_and_Haskell.mdwn
+++ b/translating_between_OCaml_Scheme_and_Haskell.mdwn
@@ -140,9 +140,9 @@ There are some more hints about Scheme [here](/assignment8/) and [here](/week1/)
 We will however try to give some general advice about how to translate between OCaml and Haskell.
 
 *	Again, it may sometimes be useful to [try Haskell in your web browser](http://tryhaskell.org/)
-*	There are many Haskell tutorials and textbooks available. This is probably the most actively developed: [Haskell Wikibook](http://en.wikibooks.org/wiki/Haskell)
-*	[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)
-*	All About Monads has supposedly also been integrated into the Haskell Wikibook
+*	There are many Haskell tutorials and textbooks available. This is probably the most actively developed: [Haskell wikibook](http://en.wikibooks.org/wiki/Haskell)
+*	[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)
+*	All About Monads has supposedly also been integrated into the Haskell wikibook
 *	(A not-so-)[Gentle Introduction to Haskell](http://web.archive.org/web/http://www.haskell.org/tutorial/) (archived)
 *	[Learn You a Haskell for Great Good](http://learnyouahaskell.com/)
 
@@ -183,15 +183,17 @@ We will however try to give some general advice about how to translate between O
 		type Weight = Integer
 		type Person = (Name, Address)    -- supposing types Name and Address to be declared elsewhere
 
-	then you can use a value of type `Integer` wherever a `Weight` is expected, and vice versa. `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:
+	then you can use a value of type `Integer` wherever a `Weight` is expected, and vice versa. <!-- `type` is allowed to be parameterized -->
+
+	`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:
 
 		newtype PersonalData a = PD a
 
 	You could also say:
 
-		data PersonalData a = PD a
+		data PersonalData2 a = PD2 a
 
-	And `data` also allows multiple type arguments, and multiple variants and value constructors.
+	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. -->
 
 	OCaml just uses the one keyword `type` for all of these purposes:
 
@@ -201,7 +203,7 @@ We will however try to give some general advice about how to translate between O
 
 *	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:
 
-		data PersonalData a = PersonalData a
+		data PersonalData3 a = PersonalData3 a
 
 	The interpreter can always tell from the context when you're using the type name and when you're using the value constructor.
 
@@ -670,6 +672,11 @@ Haskell has more built-in support for monads, but one can define the monads one
 
 	which can be translated straightforwardly into OCaml.
 
+	For more details, see:
+
+	*	[Haskell wikibook on do-notation](http://en.wikibooks.org/wiki/Haskell/do_Notation)
+	*	[Do-notation considered harmful](http://www.haskell.org/haskellwiki/Do_notation_considered_harmful)
+
 *	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.
 
 *	In order to do any printing, Haskell has to use a special `IO` monad. So programs will look like this: