+any type `α`, as long as your function is of type `α -> α` and you have a base element of type `α`.
+
+18. Translate these encodings of booleans and Church numbers into OCaml or Haskell, implementing versions of `sysf_bool`, `sysf_true`, `sysf_false`, `sysf_nat`, `sysf_zero`, `sysf_iszero` (this is what we'd earlier write as `zero?`, but you can't use `?`s in function names in OCaml or Haskell), `sysf_succ`, and `sysf_pred`. We include the `sysf_` prefixes so as not to collide with any similarly-named native functions or values in these languages. Keep in mind the capitalization rules. In OCaml, types are written `sysf_bool`, and in Haskell, they are capitalized `Sysf_bool`. In both languages, variant/constructor tags (like `None` or `Some`) are capitalized, and function names start lowercase. But for this problem, you shouldn't need to use any variant/constructor tags. To get you started, here is how to define `sysf_bool` and `sysf_true` in OCaml:
+
+ type ('a) sysf_bool = 'a -> 'a -> 'a
+ let sysf_true : ('a) sysf_bool = fun y n -> y
+
+ And here in Haskell:
+
+ type Sysf_bool a = a -> a -> a -- this is a case where Haskell does use `type` instead of `data`
+ -- Now, to my mind the natural thing to write here would be:
+ let sysf_true :: Sysf_bool a = \y n -> y
+ -- But for complicated reasons, that won't work, and you need to do this instead:
+ let { sysf_true :: Sysf_bool a; sysf_true = \y n -> y }
+ -- Or this:
+ let sysf_true = (\y n -> y) :: Sysf_bool a
+
+ Note that in both OCaml and the Haskell code, `sysf_true` can be applied to further arguments directly:
+
+ sysf_true 10 20
+
+ You don't do anything like System F's `true [int] 10 20`. The OCaml and Haskell interpreters figure out what type `sysf_true` needs to be specialized to (in this case, to `int`), and do that automatically.
+
+ It's especially useful for you to implement a version of a System F encoding `pred`, starting with one of the (untyped) versions available in the lambda library accessible from the main wiki page. [WHERE] The point of the exercise is to do these things on your own, so avoid using the built-in OCaml or Haskell booleans and integers.
+