Lisp Macros
in 20 minutes
(featuring ‘clojure)
phillip calçado
http://fragmental.tw
http://thoughtworks.com
--:-- *LISP Macros in 20 minutes* http://fragmental.tw (Presentation)--------------------------------------------------------

Clojure

Clojure
•homoiconic
•fairly functional
•runtime polymorphism
•jvm language
•software transactional memory
•agent-based asynchronous concurrency

Clojure
•homoiconic
•fairly functional
•runtime polymorphism
•jvm language
•software transactional memory
•agent-based asynchronous concurrency

Clojure
•homoiconic
•fairly functional
•runtime polymorphism
•jvm language
Code is Data
•software transactional memory
•agent-based asynchronous concurrency
Data is Code

Example:
LINQ Envy

C#
string[] names = { \"Burke\", \"Connor\", \"Frank\",
\"Everett\", \"Albert\", \"George\",
\"Harris\", \"David\" };
IEnumerable<string> query = from n in names
where n.Length == 5
orderby n
select n.ToUpper();
foreach (string item in query)
Console.WriteLine(item);
}

Java - Quaere
String[] names={\"Burke\", \"Connor\", \"Frank\",
\"Everett\", \"Albert\", \"George\",
\"Harris\", \"David\"};
Iterable<String> query=
from(\"n\").in(names).
where(eq(\"n.length()\",5).
select(\"n.toUpperCase()\");
for (String n: query) {
System.out.println(n);
}

Ruby - Quick Hack
names = [\"Burke\", \"Connor\", \"Frank\",
\"Everett\", \"Albert\", \"George\",
\"Harris\", \"David\"]
query = from :n => names do
where n.length => 5
orderby n
select n.upcase
end
query.each{|e| puts e }

Clojure
(def names '(\"Burke\", \"Connor\", \"Frank\",
\"Everett\", \"Albert\",
\"George\", \"Harris\",
\"David\"))
(def query
(from n in names
where (= (. n length) 5)
orderby n
select (. n toUpperCase)))
(doseq [n query] (println n))

Ruby Hack - Implementation
class Parameter def from(binding, &spec)
def method_missing(method, *args) var = binding.keys.first
method list = binding.values.last
end query = Query.new var
end query.instance_eval &spec
list.select do |a|
class Query a.send(query.condition[:method]) ==
attr_reader :condition, :criteria, :action query.condition[:value]
end.sort do |a,b|
def initialize(var) if(query.criteria)
singleton_class.send(:define_method, var) a.send(query.criteria) <=> b.send(query.criteria)
{ Parameter.new } else
end a <=> b
end
def singleton_class; class << self; self; end; end end.map do |a|
a.send(query.action)
def where(cond) end
@condition = {:method => cond.keys.first, :value => end
cond.values.last}
end
def orderby(criteria)
@criteria = criteria unless criteria.kind_of?
Parameter
end
def select(action)
@action = action
end
end
a <=> b
end
end.map do |a|
a.send(query.action)
end
end

Clojure - Implementation
(defmacro from [var _ coll _ condition _ ordering _ desired-map]
`(map (fn [~var] ~desired-map) (sort-by (fn[~var] ~ordering)
(filter (fn[~var] ~condition) ~coll))))

Code is Data
Data is Code
“ InfoQ: [...] many modern programming languages like Ruby are claiming big
influences from Lisp Have you seen those languages or do you have any ideas
about the current state of programming languages?
McCarthy: [...] I don't know enough for example about Ruby to know in what way
it's related to Lisp. Does it use, for example, list structures as data?
InfoQ: No.
McCarthy: So if you want to compute with sums and products, you have to parse
every time?
InfoQ: Yes.
McCarthy: So, in that respect Ruby still isn't up to where Lisp was in 1960.
Adapted From: http://www.infoq.com/interviews/mccarthy-elephant-2000*

Everything is
a (List)

(1 2 3 4 5)
(+ 1 2)
(+ (- 3 2) 10)

List
{
(1 2 3 4 5)
Number

List
{
(+ 1 2)
Function Number

List
{
(+ (- 3 2) 10)
{ List
Function Number

{
(defn- run-variant[variant]
(let [result
(wrap-and-run
List
(:impl variant) (:args variant))]
(struct-map variant-result
:args (:args variant)
:result (first result)
:exception (second result))))

Code is Data
Data is Code

Example:
Implementing
If

(defn they-are-the-same []
(println \"They are the same!\"))
(defn they-are-different []
(println \"They are different!\"))
(my-if (= 2 2)
(they-are-the-same)
(they-are-different))

First Try: Function
(defn my-if [condition succ fail]
(cond
condition succ
:else fail))
user>
;;;; (my-if (= 2 2) (they-are-the-
same) (they-are ...
They are the same!
They are different!

Second Try: Macro
(defmacro my-if [condition succ fail]
(cond
condition succ
:else fail))
user>
;;;; (my-if (= 2 2) (they-are-the-
same) (they-are ...
They are the same!

Why? Dump Function Arguments
(defn my-if [condition succ fail]
(println \"Parameters are: \" condition
succ fail))
user>
user>
;;;; (my-if (= 2 2) (they-are-the-
same) (they-are ...
They are the same!
They are different!
Parameters are: true nil nil

Why? Dump Macro Arguments
(defmacro my-if [condition succ fail]
(println \"Parameters are: \" condition
succ fail))
user>
user>
;;;; (My-if (= 2 2) (they-are-the-
same) (they-are ...
Parameters are: (= 2 2) (they-are-the-
same) (they-are-different)

Macro Expansion
(println (macroexpand-1 '(my-if (= 2 2)
(they-are-the-same)
(they-are-different)))
user>
user>
(they-are-the-same)

(my-if (= 2 2)
(they-are-the-same)
(they-are-different))
(defmacro my-if [condition succ fail]
(cond
condition succ
:else fail))
(they-are-the-same)

Revisiting
LINQ

Clojure - Implementation
(defmacro from [var _ coll _ condition _ ordering _ desired-map]
`(map (fn [~var] ~desired-map) (sort-by (fn[~var] ~ordering)
(filter (fn[~var] ~condition) ~coll))))

(def query
(from n in names
where (= (. n length) 5)
orderby n
select (. n toUpperCase)))
(defmacro from [var _ coll _ condition _ ordering _
desired-map]
`(map (fn [~var] ~desired-map) (sort-by (fn[~var]
~ordering)
(filter (fn[~var] ~condition) ~coll))))
(map (fn [n] (. n toUpperCase)) (sort-by (fn [n] n)
(filter (fn [n] (= (. n length) 5)) names)))

More?
http://www.pragprog.com/titles/shcloj/
programming-clojure
http://www.lisperati.com/casting.html
http://groups.google.com/group/clojure
http://www.gigamonkeys.com/book/
http://mitpress.mit.edu/sicp/
http://github.com/pcalcado/fato/tree/master