{"id":398,"date":"2012-08-31T22:45:33","date_gmt":"2012-08-31T12:45:33","guid":{"rendered":"http:\/\/juliangamble.com\/blog\/?p=398"},"modified":"2013-12-27T10:41:33","modified_gmt":"2013-12-26T23:41:33","slug":"the-little-schemer-in-clojure-chapter-7-shadows","status":"publish","type":"post","link":"https:\/\/juliangamble.com\/blog\/2012\/08\/31\/the-little-schemer-in-clojure-chapter-7-shadows\/","title":{"rendered":"The Little Schemer in Clojure \u2013 Chapter 7 \u2013 Shadows"},"content":{"rendered":"

This is the seventh Chapter of a series of posts about porting\u00a0The Little Schemer<\/a>\u00a0to Clojure. You may wish to\u00a0read the intro<\/a>.<\/em><\/p>\n

So far we’ve covered\u00a0flat data structures<\/a>,\u00a0reading flat data structures<\/a>,\u00a0creating data structures<\/a>,\u00a0creating a numeric tower<\/a>, working with\u00a0multiple occurrences of a match in the list<\/a>, and changing our functions to work with nested lists<\/a>.<\/p>\n

In this chapter we’re driving towards our metacircular interpreter by starting to look at evaluating numerical values. So we’ll look at building an expression, breaking it down into operators and operands, and then handling it and returning a result. So let’s get started!<\/p>\n

First we’re going to test with a test function to see if the S-expression passed in is a valid numeric expression that we can evaluate. We’re going to call this function numbered<\/code>. But first we’ll expand Clojure’s definition of number?<\/code> – so it can return a null for an invalid expression as we expect<\/p>\n

\r\n;we need to define number_? to handle true\/false\r\n(def number_?\r\n  (fn [a]\r\n    (cond\r\n      (null? a) false\r\n      (number? a) true\r\n      true false)))\r\n\r\n(println (number_? 3))\r\n;\/\/=> true\r\n(println (number_? 'a))\r\n;\/\/=> false\r\n<\/pre>\n
So now let’s do numbered<\/code> to test for S-expressions that we can evaluate as a numeric expression.<\/p>\n
\r\n(def numbered?\r\n  (fn [aexp]\r\n    (cond\r\n      (atom? aexp) (number_? aexp)\r\n      (= (first (rest aexp)) '+)\r\n         (and\r\n           (numbered? (first aexp))\r\n           (numbered? (first (rest (rest aexp)))))\r\n      (= (first (rest aexp)) '*)\r\n         (and\r\n           (numbered? (first aexp))\r\n           (numbered? (first (rest (rest aexp)))))\r\n      (= (first (rest aexp)) 'exp)\r\n         (and\r\n           (numbered? (first aexp))\r\n           (numbered? (first (rest (rest aexp)))))\r\n      true false)))\r\n\r\n(println (numbered? '(a b c)))\r\n;\/\/=> false\r\n(println (numbered? '(3 + (4 * 5))))\r\n;\/\/=> true\r\n(println (numbered? '(3 a (4 * 5))))\r\n;\/\/=> false\r\n<\/pre>\n
Ok – so can we simplify numbered? Yes:<\/p>\n
\r\n(def numbered?\r\n  (fn [aexp]\r\n    (cond\r\n      (atom? aexp) (number_? aexp)\r\n      true (and\r\n             (numbered? (first aexp))\r\n             (numbered? (first (rest (rest aexp))))))))\r\n\r\n(println (numbered? '(a b c)))\r\n;\/\/=> false\r\n(println (numbered? '(3 + (4 * 5))))\r\n;\/\/=> true\r\n(println (numbered? '(3 a (4 * 5))))\r\n;\/\/=> true\r\n<\/pre>\n
Hmm – notice that the final expression became true in this version, but was false in the previous? That’s an assumption we’re making with this new version – that we know already this is an arithmetic expression. One might think this defeats the purpose of this function. I digress.<\/p>\n
Now we’ll look at the Eight Commandment<\/strong>. This states that you recur on all subparts that are of the same nature including<\/em>:
\n– On all sublists of a list
\n– On all the subexpressions of a representation of an arithmetic expression.
\nThe big idea is that we’re starting to make a distinction between code and data. We’re saying that data functions recur on data, and code functions recur on code.<\/p>\n
Now you’ll remember the infamous function eval<\/code> from many languages – especially LISP. We’ll start writing the first version of eval<\/code> for our metacircular interpreter starting with a basic version that just looks at arithmetic expressions. We’ll call it value<\/code>:<\/p>\n
\r\n(use 'clojure.math.numeric-tower)\r\n; note use of new primitive expt\r\n\r\n(def value\r\n  (fn [aexp]\r\n    (cond\r\n      (number_? aexp) aexp\r\n      (= (first (rest aexp)) '+) (+ (value (first aexp)) (value (first (rest (rest aexp)))))\r\n      (= (first (rest aexp)) '*) (* (value (first aexp)) (value (first (rest (rest aexp)))))\r\n      (= (first (rest aexp)) 'exp) (expt (value (first aexp)) (value (first (rest (rest aexp))))))))\r\n\r\n(println (value '(1 + 1)))\r\n;\/\/=> 2\r\n(println (value '(2 + 2)))\r\n;\/\/=> 4\r\n(println (value '(3 exp 3)))\r\n;\/\/=> 27\r\n(println (value '(4 b 4)))\r\n;\/\/=> nil\r\n<\/pre>\n
Now we’re going to take the function above and move from prefix to infix – just to illustrate how trivial the distinction is from an implementation point of view<\/p>\n
\r\n(def value\r\n  (fn [aexp]\r\n    (cond\r\n      (number_? aexp) aexp\r\n      (= (first  aexp) '+) (+ (value (rest aexp)) (value  (rest (rest aexp))))\r\n      (= (first (rest aexp)) '*) (* (value (first aexp)) (value (first (rest (rest aexp)))))\r\n      (= (first (rest aexp)) 'exp) (expt (value (first aexp)) (value (first (rest (rest aexp))))))))\r\n<\/pre>\n
Now in my view that was a little silly. The book included a non-working version of value just to illustrate a violation of the Eighth Commandment. Let’s get on with it.<\/p>\n
Now we’ll extract out helper functions to get the subexpressions and the operator<\/p>\n
\r\n(def first-sub-exp\r\n  (fn [aexp]\r\n    (first (rest aexp))))\r\n\r\n(def second-sub-exp\r\n  (fn [aexp]\r\n    (first (rest (rest aexp)))))\r\n\r\n(def operator\r\n  (fn [aexp]\r\n    (first aexp)))\r\n\r\n(def value\r\n  (fn [aexp]\r\n    (cond\r\n      (number_? aexp) aexp\r\n      (= (operator aexp) '+) (+ (value (first-sub-exp aexp)) (value  (second-sub-exp aexp)))\r\n      (= (operator aexp) '*) (* (value (first-sub-exp aexp)) (value (second-sub-exp aexp)))\r\n      (= (operator aexp) 'exp) (expt (value (first-sub-exp aexp)) (value (second-sub-exp aexp))))))\r\n\r\n(println (value '(+ 1 1)))\r\n;\/\/=> 2\r\n(println (value '(* 2 2)))\r\n;\/\/=> 4\r\n(println (value '(exp 3 3)))\r\n;\/\/=> 27\r\n(println (value '(b 4 4)))\r\n;\/\/=> nil\r\n<\/pre>\n
Cool – now – just to illustrate the power of abstraction by functions – we’ll switch back from prefix to infix functions.<\/p>\n
\r\n(def first-sub-exp\r\n  (fn [aexp]\r\n    (first  aexp)))\r\n\r\n(def operator\r\n  (fn [aexp]\r\n    (first (rest aexp))))\r\n\r\n(println (value '(1 + 1)))\r\n;\/\/=> 2\r\n(println (value '(2 * 2)))\r\n;\/\/=> 4\r\n(println (value '(3 exp 3)))\r\n;\/\/=> 27\r\n(println (value '(4 b 4)))\r\n<\/pre>\n
Time for another Commandment<\/strong> – The Ninth Commandment States Use helper functions to abstract from representations<\/em>. Part of this is the java concept of eclipse’s extract method. Part of it is the power this gives you to change the function across the whole application and have it impact many parts of the system – ie a wide-ranging refactor.<\/p>\n
Now we’re testing for null?<\/code>. Although we had to write our own helper method for this in Chapter 1 – now as part of implementing the metacircular interpreter – we’re re-implementing it in terms of other functions so keep our api minimal.<\/p>\n
\r\n;This is what we had\r\n(def null?\r\n  (fn [a]\r\n    (or\r\n      (nil? a)\r\n      (= () a))))\r\n\r\n;This is what they're proposing\r\n(def null?\r\n  (fn [s]\r\n    (and\r\n      (atom? s)\r\n      (= s '()))))\r\n\r\n<\/pre>\n
Now it turns out this fails the conversion from Scheme to Clojure. We get the big idea. We’ll just move on.<\/p>\n
Now we’re going to build our own numeric system out of parenthesis – again, just to make the implementation of our metacircular interpreter more pure and easier to implement. This is significant because we’re going to build up our own number representation out of parentheses – admittedly a strange exercise – but going to prove that we can do maths in a lisp implemented in itself.<\/p>\n
We’ll start with zero?<\/code>:<\/p>\n
\r\n(def zero_?\r\n  (fn [n]\r\n    (null? n)))\r\n\r\n(println (zero_? '()))\r\n;\/\/=>true\r\n(println (zero_? 0))\r\n;=>false\r\n<\/pre>\n
Ok – maybe that didn’t make sense – let’s give a few examples. So now zero is ()<\/code>, one is (())<\/code>, and two is (()())<\/code>.
\nLet’s do some operations on our new numeric representation – we’ll start with a new definition of add1<\/code>.<\/p>\n
\r\n(def add1\r\n  (fn [n]\r\n    (cons '() n)))\r\n\r\n(println (add1 '()))\r\n;\/\/=>(()) ie 1\r\n(println (add1 '(())))\r\n;\/\/=> (() ()) ie 2\r\n<\/pre>\n
Now let’s do sub1<\/code>:<\/p>\n
\r\n(def sub1\r\n  (fn [n]\r\n    (rest n)))\r\n\r\n(println (sub1 '(()())))\r\n;\/\/=>(()) ie 1\r\n(println (sub1 '(())))\r\n;\/\/=>() ie 0\r\n(println (sub1 '()))\r\n;\/\/=> () unfortunately with our implementation sub1 of zero returns zero\r\n<\/pre>\n
Now we’ll reimplement our plus<\/code> function:<\/p>\n
\r\n(def +_\r\n  (fn [n m]\r\n    (cond\r\n      (zero_? m) n\r\n      true (add1 (+_ n (sub1 m))))))\r\n\r\n(println (+_ '() '()))\r\n;\/\/=> ()\r\n;\/\/  zero plus zero is zero\r\n(println (+_ '(()) '(())))\r\n;\/\/=> (()()) ie 1 plus 1 is 2\r\n<\/pre>\n
Now we’ll test for valid numbers in our new scheme by rewriting our function number?<\/code>:<\/p>\n
\r\n(def number_?\r\n  (fn [n]\r\n    (cond\r\n      (null? n) true\r\n      true (and\r\n             (null? (first n))\r\n             (number_? (rest n))))))\r\n\r\n(println (number_? '() ))\r\n;\/\/=>true\r\n(println (number_? '(()) ))\r\n;\/\/=>true\r\n(println (number_? '((())) ))\r\n;\/\/=>false\r\n(println (number_? '(()()) ))\r\n;\/\/=>true\r\n<\/pre>\n
You can see it running here<\/a>.<\/p>\n
Conclusion:<\/strong>
\nWhy is this chapter called shadows? I haven’t figured that out. Perhaps it is a shadow of things to come.<\/p>\n
Here we’ve started on the journey of the metacircular interpreter by writing an evaluator for arithmetic expressions. The only primitive we added was expt<\/code>.<\/p>\n
In total our primitives so far are: atom?<\/code>, null?<\/code>, first<\/code>, rest<\/code>, cond<\/code>, fn<\/code>, def<\/code>, empty?<\/code>,=<\/code>, cons<\/code>, add1,<\/code>, sub1<\/code>, one?<\/code> and expt<\/code>. These are all the functions (and those in the chapters to come) that we\u2019ll need to implement to get our metacircular interpreter working.<\/p>\n","protected":false},"excerpt":{"rendered":"
This is the seventh Chapter of a series of posts about porting\u00a0The Little Schemer\u00a0to Clojure. You may wish to\u00a0read the intro. So far we’ve covered\u00a0flat data structures,\u00a0reading flat data structures,\u00a0creating data structures,\u00a0creating a numeric tower, working with\u00a0multiple occurrences of a … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"ngg_post_thumbnail":0,"footnotes":""},"categories":[3,12],"tags":[],"class_list":["post-398","post","type-post","status-publish","format-standard","hentry","category-clojure","category-thelittleschemer"],"_links":{"self":[{"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/posts\/398","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/comments?post=398"}],"version-history":[{"count":11,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/posts\/398\/revisions"}],"predecessor-version":[{"id":572,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/posts\/398\/revisions\/572"}],"wp:attachment":[{"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/media?parent=398"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/categories?post=398"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/juliangamble.com\/blog\/wp-json\/wp\/v2\/tags?post=398"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}