+
+<a id=tuples></a>
+### Tuples
+
+The course notes [[already mentioned|topics/week1#lightweight]] that Kapulet has a "lightweight" notion of tuples, called multivalues and written `(10, x)`, as well as a heavier notion written `Pair (10, x)`. The latter is what corresponds to the tuples in Haskell and OCaml. They don't have any explicit notation for Kapulet's "lightweight" tuples (though they exist behind the scenes in OCaml and explain some of its otherwise puzzling behavior). There are good reasons for introducing this additional complexity in Kapulet, but this is not the place to explain them.
+
+All of these languages have notions of zero-length tuples, as well as pairs, triples, and the like. (In Kapulet's case, there are both the 0-length multivalue `()` and heavier counterparts.)
+
+Probably the closest approximation to tuples in Scheme is its notion of `vector`s, though in the case of pairs, Scheme's `pair`s---which it identifies with short, possibly "improper" `list`s---are arguably also contenders. The fact that these Scheme structures permit elements of heterogenous type is not a problem, because that is also true for tuples in the other languages. However, Scheme's `vector`s and `pair`s are officially mutable, but tuples in the other languages are not. (As mentioned above, many Scheme implementations do also provide immutable versions of these structures.)
+
+<a id=void></a>
+What corresponds to the zero-length tuples in Kapulet, OCaml, and Haskell? Perhaps the zero-length `vector`. Or perhaps a different Scheme value, called *void*. Different Scheme implementations display this value in different ways. For example, Racket and Chicken may display it as `#<void>` or as `#<unspecified>` or may just display nothing. This is the value returned, for example, by a `case` or a `cond` construction if there is no `else` clause and none of the provided clauses successfully match. In many respects, this value more closely approximates in Scheme the behavior that `()` has in Kapulet, OCaml, and Haskell.
+
+
+
+
+<a id=chars></a>
+### Chars and Strings
+
+Scheme, OCaml, and Haskell all have values they call "characters", and sequences of such characters they call "strings". Haskell and OCaml write the first character of the word "false" like this:
+
+ 'f'
+
+whereas Scheme writes it like this:
+
+ #\f
+
+(Note the difference between the *character* `#\f` and the *boolean* `#f`.) Scheme gives special characters like `#\space` funny names.
+
+Sequences of characters are called "strings". All of these languages write the string "false" like this:
+
+ "false"
+
+This is not the same as the truth-value, nor is it the same as the atomic symbol `'false` (which Kapulet but not Scheme identifies with the truth-value). In Haskell, strings are strictly equivalent to Lists of `Char`s. In OCaml and Scheme, they are not equivalent to lists (nor to vectors) but merely isomorphic to them. In OCaml and Scheme, some strings are mutable, like Scheme's vectors.
+
+
+
+
+### Other functions
+
+These functions are roughly the same in Kapulet, OCaml, and Haskell: `succ`, `pred`, `fst`, `snd`. The official Scheme standard doesn't include any `succ` or `pred` functions, but Racket and Chicken both have `add1` and `sub1`. Depending on what Scheme values you take to correspond to tuples in the other languages, `fst` and `snd` may correspond to `car` and `cdr`. (These also correspond to `head` and `tail` when applied to lists.)
+
+Kapulet's `(comp)`, `odd?`, `even?`, and `swap` (defined in homework) are Haskell's `( . )`, `odd`, `even`, and `Data.Tuple.swap`. None of these are predefined in OCaml.
+
+Kapulet's `dup` isn't predefined in Haskell but can be easily expressed as `\x -> (x, x)`.
+
+These are the same in Kapulet and Haskell (modulo the differences between [[Kapulet's multivalues|topics/week1#lightweight]] or "lightweight tuples" and Haskell's tuples), aren't predefined in OCaml: `id`, `const`, `flip`, `curry`, `uncurry`. None of these are predefined in OCaml.
+
+Kapulet and Haskell both have `( $ )`, which was explained [[in the course notes|topics/week1_advanced_notes#dollar]]. OCaml expresses this as `( @@ )`. (OCaml also uses `|>` to express the converse operation: `f x`, `f @@ x` and `x |> f` all mean the same.)
+
+
+
+
+### Case, Cond, and If ... then ...