From c85a4a315e5722e56bca71b3eaf8f9f59aee220e Mon Sep 17 00:00:00 2001 From: Jim Date: Sat, 7 Feb 2015 19:12:19 -0500 Subject: [PATCH] curried_flip etc --- rosetta1.mdwn | 22 +++++++++++++++++++++- topics/week1_kapulet_advanced.mdwn | 2 ++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/rosetta1.mdwn b/rosetta1.mdwn index fa189586..32e41023 100644 --- a/rosetta1.mdwn +++ b/rosetta1.mdwn @@ -157,6 +157,25 @@ Here the last displayed line will fail, because `add` expects as its argument a Kapulet essentially works like OCaml and Haskell; though for pedagogical reasons we started out by introducing uncurried definitions, rather than the *curried* definitions those other languages predominantly use. +Here are some interesting functions we can define in Kapulet. See [[below|rosetta1#curried-patterns]] for the pattern syntax used here. + + # Kapulet + let + curry match lambda f. lambda x y. f (x, y); + uncurry match lambda g. lambda (x, y). g x y ; + uncurried_flip match lambda f. lambda (y, x). f (x, y) + curried_flip match lambda g. lambda y x. g x y; + in ... + +The function `curry` takes as an argument a function `f` that expects its arguments *uncurried*, and returns instead a function `lambda x y. f (x, y)` a function that expects its arguments *curried* --- but then does with them whatever `f` does. Going in the other direction, the function `uncurry` takes a function `g` that expects its arguments *curried*, and returns instead a function that expects its arguments *uncurried* --- but then does with them whatever `g` does. + +The function `uncurried_flip` takes as an argument again an uncurried function `f`, and returns another function that also expects its arguments uncurried, but that expects them in the other order. `curried_flip` transforms a curried function `g` in the analogous way. These are both different from the function `swap` we defined in the [[course notes|topics/week1_kapulet_advanced#functions]] as: + + lambda (x, y) = (y, x) + +*That* function operates on a tuple and returns another tuple. The `..._flip` functions operate on functions, and transform them into other functions that expect their arguments in a different order. + + [[As we mentioned in the course notes|topics/week1_kapulet_advanced#sections]], in Kapulet, OCaml, and Haskell, there is a shorthand that enables you to write things like: @@ -444,7 +463,7 @@ Kapulet's `(comp)`, `odd?`, `even?`, and `swap` are Haskell's `( . )`, `odd`, `e 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_kapulet_intro#lightweight]] or "lightweight tuples" and Haskell's tuples): `id`, `const`, `flip`, `curry`, `uncurry`. None of these are predefined in OCaml. +These are the same in Kapulet and Haskell (modulo the differences between [[Kapulet's multivalues|topics/week1_kapulet_intro#lightweight]] or "lightweight tuples" and Haskell's tuples): `id`, `const`, `curry`, `uncurry`. Kapulet's `curried_flip` is Haskell's `flip`. None of these are predefined in OCaml. Kapulet and Haskell both have `( $ )`, which was explained [[in the course notes|topics/week1_kapulet_advanced#dollar]]. OCaml expresses this as `( @@ )`. (OCaml also uses `|>` to express the converse operation: `f x`, `f @@ x` and `x |> f` all mean the same.) @@ -605,6 +624,7 @@ This is similar to Scheme's `when` construction. Kapulet and Haskell have no ana ### Lambda expressions + In Kapulet you write λ expressions (sometimes called "anonymous functions") with a prefix of either λ or the spelled-out `lambda`. That's followed by one or more patterns, separated by spaces, then a period, then a single expression which makes up the body of the function. When there are multiple patterns, the function expressed is *curried*, thus: lambda (x, y) z. result diff --git a/topics/week1_kapulet_advanced.mdwn b/topics/week1_kapulet_advanced.mdwn index 2137d114..06a20438 100644 --- a/topics/week1_kapulet_advanced.mdwn +++ b/topics/week1_kapulet_advanced.mdwn @@ -173,6 +173,8 @@ We've already come across the `id` function, namely λ `x. x`. Other common functions are `fst`, which takes two arguments and returns the first of them; `snd`, which takes two arguments and returns the second of them; and `swap`, which takes two arguments and returns them both but with their positions swapped. A fourth function is `dup`, which takes one argument and returns it twice. These functions can be defined like this: + + let fst (x, y) = x; snd (x, y) = y; -- 2.11.0