From: Jim Date: Tue, 10 Feb 2015 22:10:00 +0000 (-0500) Subject: Merge branch 'master' into working X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=commitdiff_plain;h=26c8d6da76887c3756f2ce856b03f490945814c0;hp=-c Merge branch 'master' into working * master: fill in answers to 25 expand on Scheme heads #true in r7rs move Real World OCaml add stubs for week3 --- 26c8d6da76887c3756f2ce856b03f490945814c0 diff --combined rosetta1.mdwn index e3534511,eda1a9f8..1c42a133 --- a/rosetta1.mdwn +++ b/rosetta1.mdwn @@@ -2,7 -2,7 +2,7 @@@ ## Can you summarize the differences between your made-up language and Scheme, OCaml, and Haskell? ## -The made-up language we wet our toes in in week 1 is called Kapulet. (I'll tell you [the story behind its name](/randj.jpg) sometime.) The purpose of starting with this language is that it represents something of a center of gravity between Scheme, OCaml, and Haskell, and also lacks many of their idiosyncratic warts. One downside is that it's not yet implemented in a form that you can run on your computers. So for now, if you want to try out your code on a real mechanical evaluator, you'll need to use one of the other languages. +The made-up language we wet our toes in in week 1 is called Kapulet. (I'll tell you [the story behind its name](/images/randj.jpg) sometime.) The purpose of starting with this language is that it represents something of a center of gravity between Scheme, OCaml, and Haskell, and also lacks many of their idiosyncratic warts. One downside is that it's not yet implemented in a form that you can run on your computers. So for now, if you want to try out your code on a real mechanical evaluator, you'll need to use one of the other languages. Also, if you want to read code written outside this seminar, or have others read your code, for these reasons too you'll need to make the shift over to one of the established languages. @@@ -78,7 -78,7 +78,7 @@@ These relations are written in Haskell The values that are written `'true` and `'false` in Kapulet are written in Haskell as `True` and `False`, and in OCaml as just `true` and `false`. (It'd be more consistent with OCaml's other naming policies for them to have said True and False, but they didn't.) These are written `#t` and `#f` in Scheme, but in Scheme in many contexts any value that isn't `#f` will behave as though it were `#t`, even values you might think are more "false-like", like `0` and the empty list. Thus `(if 0 'zero 'nope)` will evaluate to `'zero`. - Some Scheme implementations, such as Racket, permit `#true` and `#false` as synonyms for `#t` and `#f`. + Some Scheme implementations, such as Racket, permit `#true` and `#false` as synonyms for `#t` and `#f`. (These aliases are also mandated in "version 7", r7rs, of the Scheme standard.) Scheme also recognizes the values `'true` and `'false`, but it treats `'false` as distinct from `#f`, and thus as a "truth-like" value, like all of its other values that aren't `#f`. Kapulet essentially took Scheme's `boolean` values and collapsed them into being a subtype of its `symbol` values. @@@ -110,7 -110,13 +110,13 @@@ Scheme has no infix operators. It ruthl (+ 3 2) - and the like. Moreover, in Scheme parentheses are never optional and never redundant. In contexts like this, the parentheses are necessary to express that the function is being applied; `+ 3 2` on its own is not a complete Scheme expression. And if the `+` were surrounded by its own parentheses, as in: + and the like. Here is an example where the function to be applied is the result of evaluating a more complex expression: + + ((if #t + *) 3 2) + + which will evaluate to `5`, not `6`. + + In Scheme the parentheses are never optional and never redundant. In expressions like `(+ 3 2)`, the parentheses are necessary to express that the function is being applied; `+ 3 2` on its own is not a complete Scheme expression. And if the `+` were surrounded by its own parentheses, as in: ((+) 3 2)