+Kapulet writes the operator that concatenates or appends sequences as `&&`. Thus:
+
+ # Kapulet
+ [1, 2] && [3, 4, 5]
+
+evaluates to `[1, 2, 3, 4, 5]`. Haskell writes this operator as `++`. In Haskell, a `String` is just a List of `Char`, so `++` is also the operator we use to append strings:
+
+ -- Haskell
+ "over" ++ "due"
+
+evaluates to `"overdue"`. In OCaml, `string`s aren't implemented as `list`s, so their append operators are different: `^` for `string`s and `@` for `list`s:
+
+ (* OCaml *)
+ [1; 2] @ [3; 4; 5] ;;
+ "over" ^ "due" ;;
+
+evaluate to `[1; 2; 3; 4; 5]` and `"overdue"`. Note that OCaml separates its `list` items with semicolons not commas. If you write `[1, 2, 3]` in OCaml, it will think that's a one-element list whose first element is a triple, that is, what you'd write in Haskell as `[(1, 2, 3)]`.
+
+Here are some list functions in Kapulet:
+
+ length
+ (&&)
+ # the following were defined in homework
+ empty?
+ tail
+ drop
+ take
+ split
+ filter
+ partition
+ map
+ map2
+ # the following were defined in extra credit
+ unmap2
+ takewhile
+ dropwhile
+ reverse
+ # new functions
+ concat # converts [[10, 20], [30], [], [40, 50]]
+ # to [10, 20, 30, 40, 50] (only merging a single layer of []s)
+ (mem) # infix syntax, 2 mem [1, 2, 3] == 'true
+ nth # nth [10, 20, 30] 1 == 20, because the first element
+ # is at position 0; fails if index is out of bounds
+ all? p xs # all? odd? [1, 3, 5] == 'true
+ any? p xs # any? even? [1, 3, 5] == 'false
+
+
+
+Here are the corresponding functions in Haskell:
+
+ length
+ (++)
+ null
+ tail -- compare head, which fails on []
+ drop {- but these are curried functions, so you write `drop n xs`
+ not `drop (n, xs)` as in Kapulet -}
+ take
+ splitAt
+ filter
+ Data.List.partition
+ map
+ zipWith {- zip handles the special case where f is the function that forms ordered pairs
+ both zipWith and zip stop with the shortest list -}
+ unzip -- doesn't take an f argument, assumes (\(x, y) -> (x, y))
+ takeWhile
+ dropWhile
+ reverse
+ concat
+ elem -- not infix syntax, but often written as: 2 `elem` [1, 2, 3]
+ (!!) -- infix syntax: [10, 20, 30] !! 1 == 20; fails if index is out of bounds
+ all p xs
+ any p xs
+
+
+
+Here they are in OCaml:
+
+ length
+ (@) (* or List.append *)
+ (* no function corresponding to empty? *)
+ List.tl (* compare List.hd, which fails on [] *)
+ (* no function corresponding to drop or take *)
+ (* no function corresponding to split; OCaml uses List.split to mean something else *)
+ List.filter (* also List.find_all *)
+ List.partition
+ List.map
+ List.map2 (* compare List.combine, like Haskell's zip
+ both map2 and combine fail if the lists are different lengths *)
+ List.split (* like Haskell's unzip, doesn't take an f argument *)
+ (* no function corresponding to takewhile or dropwhile *)
+ List.rev
+ List.concat (* also List.flatten, which still only merges a single layer of []s *)
+ List.mem (* not infix syntax *)
+ List.nth (* List.nth [10; 20; 30] 1 = 20; fails if index is out of bounds *)
+ List.for_all p xs
+ List.exists p xs
+
+
+How does all this look in Scheme? Well, Scheme has a notion they call a (proper) `list`, and also a notion they call a `vector`. There are also what Scheme calls "improper" `list`s, with `(cons 1 'nonlist)` or `'(1 . nonlist)`, where `'nonlist` is any non-list (here it's a `symbol`) being a special case. Let's ignore the improper `list`s. Scheme's (proper) `list`s and `vector`s each has a claim to correspond to Kapulet's sequences, Haskell's Lists, and OCaml's `list`s. Each is also somewhat different. The dominant differences are:
+
+1. these structures in Scheme can contain heterogenously-typed elements, including further `list`s and `vector`s in some positions but not in others
+2. in the official Scheme standard, `list`s and `vector`s are both *mutable* containers, that is, one and the same persisting `list` structure can have different
+elements at different stages in a program's evaluation
+
+Many Scheme implementations also provide immutable versions of `list`s and `vector`s, more closely approximating the sequences/lists in Kapulet, Haskell, and OCaml. With some configurations, Racket even makes the immutable versions the defaults. But none of these are yet part of the official Scheme standard. Also, difference 1 is present in all Scheme implementations. This makes Scheme's `list`s and `vector`s in some ways more akin to *tuples* in the other languages (to "proper" tuples in Kapulet).
+
+There are also some differences in how `list`s are specified in Scheme versus the other languages. In Scheme, one writes the empty list like this:
+
+ (list)
+
+and lists with more elements like this:
+
+ (list 10)
+ (list 10 x)
+ (list 10 x 'alpha)
+ (list 10 x 'alpha (list 'beta 'gamma) 'delta 20)
+
+In the preceding, the `x` is a variable and is evaluated to be whatever value it's bound to in the context where the displayed expressions are being evaluated. If one has a list specification that contains no variables, no matter how deeply embedded, then a certain shorthand becomes available, using a `'` prefix, like this:
+
+ '() ; same as (list)
+ '(10) ; same as (list 10)
+ '(10 alpha) ; same as (list 10 'alpha)
+ '(10 alpha (beta gamma) 20) ; same as (list 10 'alpha (list 'beta 'gamma) 20)
+
+Scheme can also write <code>'<em>something</em></code> as <code>(quote <em>something</em>)</code>. (The `quote` is not a function being applied to some argument; this is a special syntax that only superficially *looks* like a function application.)
+
+
+Here are the `list` functions in Scheme corresponding to the functions listed in the other languages:
+
+ cons ; corresponds to Kapulet's ( & ), Haskell's ( : ), OCaml's `::`
+ length
+ append ; corresponds to Kapulet's ( && ), Haskell's ( ++ ), OCaml's ( @ )
+ ; can be applied to one or more arguments
+ null? ; corresponds to Kapulet's empty?, Haskell's null
+ car ; corresponds to Haskell's head
+ cdr ; corresponds to Kapulet's and Haskell's tail
+ (list-tail xs k) ; corresponds to Kapulet's drop (k, xs); fails if out-of-bounds
+ ; no official function corresponding to take or split or filter or partition
+ map ; corresponds to Kapulet's map and map2
+ ; can take one or more list arguments
+ ; no official function corresponding to unmap2 or takewhile or dropwhile
+ reverse
+ ; no official function corresponding to concat
+ member ; corresponds to Kapulet's (mem) and Haskell's elem
+ (list-ref xs k) ; corresponds to Kapulet's `nth xs k`
+ ; no official function corresponding to all or any
+
+All of the functions listed as missing from the official Scheme standard can be found in various add-on libraries, or you could define them yourself if you had to.
+
+
+
+
+
+<!--
+
+symbol=?
+
+characters: #\c #\xff #\space #\newline
+
+
+
+### Other functions
+
+Same in all: `succ`, `pred`, `fst`, `snd`.
+
+Same in Kapulet and Haskell (modulo the differences between multivalues and tuples), aren't predefined in OCaml: `id`, `const`, `flip`, `curry`, `uncurry`.
+
+Kapulet's `(comp)` is Haskell's `( . )`; isn't predefined in OCaml.
+
+Kapulet and Haskell both have `( $ )`; OCaml expresses as `( @@ )`. (OCaml also has `|>` to express the converse operation: `f x`, `f @@ x` and `x |> f` all mean the same.)
+
+Kapulet's `odd?` and `even?` are Haskell's `odd`, `even`; aren't predefined in OCaml.
+
+Kapulet's `swap` (defined in homework) is Haskell's `Data.Tuple.swap`.
+
+Kapulet's `dup` isn't predefined in Haskell but can be easily expressed as `\x -> (x, x)`.
+
+-->
+
+
+
+### More to come ...
+
+(This page is being worked on...)
+
+FIXME