Lisp Macros in 20 Minutes (Featuring Clojure)

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

•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

C#

string[] names = { quot;Burkequot;, quot;Connorquot;, quot;Frankquot;,
quot;Everettquot;, quot;Albertquot;, quot;Georgequot;,
quot;Harrisquot;, quot;Davidquot; };

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={quot;Burkequot;, quot;Connorquot;, quot;Frankquot;,
quot;Harrisquot;, quot;Davidquot;};
Iterable<String> query=
from(quot;nquot;).in(names).
where(eq(quot;n.length()quot;,5).
select(quot;n.toUpperCase()quot;);

for (String n: query) {
System.out.println(n);
}

Ruby - Quick Hack

names = [quot;Burkequot;, quot;Connorquot;, quot;Frankquot;,
quot;Harrisquot;, quot;Davidquot;]

query = from :n => names do
where n.length => 5
orderby n
select n.upcase
end

query.each{|e| puts e }

Clojure

(def names '(quot;Burkequot;, quot;Connorquot;, quot;Frankquot;,
quot;Everettquot;, quot;Albertquot;,
quot;Georgequot;, quot;Harrisquot;,
quot;Davidquot;))

(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*

(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))))

(defn they-are-the-same []
(println quot;They are the same!quot;))

(defn they-are-different []
(println quot;They are different!quot;))

(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>
same) (they-are ...
They are the same!

Why? Dump Function Arguments

(defn my-if [condition succ fail]
(println quot;Parameters are: quot; condition
succ fail))

user>
user>
same) (they-are ...
They are the same!
They are different!
Parameters are: true nil nil

Why? Dump Macro Arguments

(println quot;Parameters are: quot; 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))

(cond
condition succ
:else fail))

(they-are-the-same)

(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

Lisp Macros in 20 Minutes (Featuring Clojure)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Lisp Macros in 20 Minutes (Featuring Clojure)

Similaire à Lisp Macros in 20 Minutes (Featuring Clojure) (20)

Plus de Phil Calçado

Plus de Phil Calçado (20)

Dernier

Dernier (20)

Lisp Macros in 20 Minutes (Featuring Clojure)

Notes de l'éditeur