week1: tweaks
authorJim Pryor <profjim@jimpryor.net>
Thu, 16 Sep 2010 00:28:07 +0000 (20:28 -0400)
committerJim Pryor <profjim@jimpryor.net>
Thu, 16 Sep 2010 00:28:07 +0000 (20:28 -0400)
Signed-off-by: Jim Pryor <profjim@jimpryor.net>
week1.mdwn

index 686793c..b581db1 100644 (file)
@@ -449,47 +449,47 @@ Some more comparisons between Scheme and OCaml
 
 11.    Simple predefined values
 
-       Numbers in Scheme: 2, 3
-       In OCaml: 2, 3
+       Numbers in Scheme: `2`, `3`  
+       In OCaml: `2`, `3`
 
-       Booleans in Scheme: #t, #f
-       In OCaml: true, false
+       Booleans in Scheme: `#t`, `#f`  
+       In OCaml: `true`, `false`
 
-       The eighth letter in the Latin alphabet, in Scheme: #\h
-       In OCaml: 'h'
+       The eighth letter in the Latin alphabet, in Scheme: `#\h`  
+       In OCaml: `'h'`
 
 12.    Compound values
 
        These are values which are built up out of (zero or more) simple values.
 
-       Ordered pairs in Scheme: '(2 . 3)
-       In OCaml: (2, 3)
+       Ordered pairs in Scheme: `'(2 . 3)`  
+       In OCaml: `(2, 3)`
 
-       Lists in Scheme: '(2 3)
-       In OCaml: [2; 3]
+       Lists in Scheme: `'(2 3)`  
+       In OCaml: `[2; 3]`  
        We'll be explaining the difference between pairs and lists next week.
 
-       The empty list, in Scheme: '()
-       In OCaml: []
+       The empty list, in Scheme: `'()`  
+       In OCaml: `[]`
 
-       The string consisting just of the eighth letter of the Latin alphabet, in Scheme: "h"
-       In OCaml: "h"
+       The string consisting just of the eighth letter of the Latin alphabet, in Scheme: `"h"`  
+       In OCaml: `"h"`
 
-       A longer string, in Scheme: "horse"
-       In OCaml: "horse"
+       A longer string, in Scheme: `"horse"`  
+       In OCaml: `"horse"`
 
-       A shorter string, in Scheme: ""
-       In OCaml: ""
+       A shorter string, in Scheme: `""`  
+       In OCaml: `""`
 
 13.    Function application
 
-       Binary functions in OCaml: foo 2 3
+       Binary functions in OCaml: `foo 2 3`
        
-       Or: ( + ) 2 3
+       Or: `( + ) 2 3`
 
-       These are the same as: ((foo 2) 3). In other words, functions in OCaml are "curried". foo 2 returns a 2-fooer, which waits for an argument like 3 and then foos 2 to it. ( + ) 2 returns a 2-adder, which waits for an argument like 3 and then adds 2 to it.
+       These are the same as: `((foo 2) 3)`. In other words, functions in OCaml are "curried". `foo 2` returns a `2`-fooer, which waits for an argument like `3` and then foos `2` to it. `( + ) 2` returns a `2`-adder, which waits for an argument like `3` and then adds `2` to it.
 
-       In Scheme, on the other hand, there's a difference between ((foo 2) 3) and (foo 2 3). Scheme distinguishes between unary functions that return unary functions and binary functions. For our seminar purposes, it will be easiest if you confine yourself to unary functions in Scheme as much as possible.
+       In Scheme, on the other hand, there's a difference between `((foo 2) 3)` and `(foo 2 3)`. Scheme distinguishes between unary functions that return unary functions and binary functions. For our seminar purposes, it will be easiest if you confine yourself to unary functions in Scheme as much as possible.
 
        Additionally, as said above, Scheme is very sensitive to parentheses and whenever you want a function applied to any number of arguments, you need to wrap the function and its arguments in a parentheses.