Internal DSLs

internal DSLs
Zef Hemel

Tuesday, May 18, 2010

Internal DSLs are particular ways of
using a host language to give the host
language the feel of a particular
language.

Martin Fowler


Internal DSLs are particular ways of
abusing a host language to give the host
language the feel of a particular
language.

Martin Fowler


fluent interfaces

flexible syntax

method missing

reflection

macros


ﬂuent interfaces


Order o = new Order();
Product p1 = new Product(1,Product.find(“Billy”));
o.addProduct(p1);
Product p2 = new Product(2,Product.find(”Janso"));
o.addProduct(p2);
Product p3 = new Product(4,Product.find(“Traby"));
o.addProduct(p3);
o.setPriorityRush(true);
customer.addOrder(o);

http://www.st.ewi.tudelft.nl/~bouwers/main/slides/2008jspring.pdf


customer.newOrder()
.with(1, "Billy")
.with(2, "Janso")
.with(4, "Traby")
.priorityRush()
.done();


public class Customer {
...
public OrderBuilder newOrder() {
return new OrderBuilder(this);
}
}


public class OrderBuilder {
// ...

public OrderBuilder(Customer customer) {
this.customer = customer;
this.order = new Order();
}

public OrderBuilder with(int id, String name) {
order.addProduct(new Product(id, name));
return this;
}

public OrderBuilder priorityRush() {
order.setPriorityRush(true);
return this;
}

public void done() {
customer.addOrder(this.order);
}
}


ﬂexible syntax


header("Add entry")
form {
table {
row {
col { text("Your name:") }
col { newEntry.name = input(newEntry.name) }
}
row {
col { text("Your message:") }
col { newEntry.text = inputText(newEntry.text) }
}
}
button("Post") {
newEntry.save()
goto(Home())
}
}


in Scala


case class Home() extends Page {
def ui {
header("Welcome to my guestbook!")
section {
header("All entries")
list {
for (e <- cache("entries", Entry.all)) {
listitem {
form {
text(e.name)
text(": ")
text(e.text)
button("Delete") {
e.delete()
goto(Home())
}
}
}
}
}
}
}
}


case class Home() extends Page {
def ui {
header("Welcome to my guestbook!")
section {
entries
}
}

def entries {
list {
for (e <- cache("entries", Entry.all)) {
listitem {
form {
text(e.name)
text(": ")
text(e.text)
button("Delete") {
e.delete()
goto(Home())
}
}
}
}
}
}
}


object DefaultStyle extends Style {
block("headerblock") >> header {
fontsize = 30 pt;
width = 100 percent;
bgcolor = "#eeeeee";
}
section >> header {
color = "#0c0ccc";
}
body {
fontfamily = "Helvetica, Arial, Verdana, sans-serif"
}
}


block("headerblock").>>(header {
fontsize = 30 pt;
})
section.>>(header {
color = "#0c0ccc";
})
body {
}
}


block("headerblock").>>(header(() => {
fontsize = 30 pt;
}))
section.>>(header(() => {
color = "#0c0ccc";
}))
body(() => {
})
}


a >> b == a.>>(b)


section {
...
}


section(() => {
...
})


section(() => {
...
})

def section(content : => Unit) {
write("<div class='section'>")
content
write("</div>")
}


create_table :posts do |t|
t.string :name
t.string :title
t.text :content
end


create_table(:posts,do |t|
t.string(:name)
t.string(:title)
t.text (:content)
end)


class Post < ActiveRecord::Base
validates_presence_of :name, :title
validates_length_of :title, :minimum => 5
end


validates_presence_of(:name, :title)
validates_length_of(:title, :minimum => 5)
end


method missing


scala



def width_=(w: UnitInt) {
...
}


width_=(100 percent);


width_=(100.percent);


width_=(100.percent());


implicit def int2UnitInt(i: Int) =
new UnitIntWrapper(i)


width_=(int2UnitInt(100).percent());


class UnitIntWrapper(i: Int) {
...

def percent = new PercentUnitInt(i)

class PercentUnitInt(i: Int) extends UnitInt {
override def toString = i + "%"
}
}


Person.find_by_name('Zef')


class Person
def self.find(key, value)
puts "You want results from #{key} with a value of #{value}"
end
end

Person.find('name', 'Zef')


class Person
def self.find(key, value)
puts "You want results from #{key} with a value of #{value}"
end

def self.method_missing(id, *args)
if id.id2name =~ /find_by_(.+)/
return self.find(Regexp.last_match(1), args[0])
else
raise NoMethodError
end
end
end

Person.find_by_name('Zef')


reﬂection


public class Person {
@Persistent
public String name;
@Persistent
public int age;
}


void persist(Object obj) {
Class cls = obj.getClass();
Field[] fields = cls.getFields();
for(Field f : fields) {
Persistent anno = f.getAnnotation(Persistent.class);
if(anno != null) {
System.out.println(f.getName());
}
}
}


macros


int one() {
printf("One!");
return 1;
}

int two() {
printf("Two!");
return 2;
}

...

int c = choice(n == 1, one(), two());


int choice(BOOL c, int ifTrue, int ifFalse) {
return c ? ifTrue : ifFalse;
}


#define CHOICE(c,ifTrue,ifFalse)
(c) ? (ifTrue) : (ifFalse)



int c = CHOICE(n == 1, one(), two());



int c = CHOICE(n == 1, one(), two());

int c = (n == 1) ? (one()) : (two());


clojure (a Lisp)


homoiconic
code is data
data is code


(+ 1 2 3)


(+ 1 2 3) =6


'(+ 1 2 3)


(first '(+ 1 2 3))


(first '(+ 1 2 3)) =+


(cons '+ (reverse (rest '(+ 1 2 3))))


(cons '+ (reverse (rest '(+ 1 2 3))))

= (+ 3 2 1)


(eval
(cons '+ (reverse (rest '(+ 1 2 3)))))


(eval
(cons '+ (reverse (rest '(+ 1 2 3)))))

=6


(if (= n 10)
(print "It was ten!”)
nil)


(when (= n 10)
(print "It was ten!”))


(defn when [c ifTrue]
(if c
ifTrue
nil))


(defmacro when [c ifTrue]
(list 'if c ifTrue 'nil))


(defmacro when [c ifTrue]
`(if ~c
~ifTrue
nil))


(when (= n 10)
(print "It was ten!”))

(if (= n 10)
(print "It was ten!”)
nil)


(loop for i in *random*
counting (evenp i) into evens
counting (oddp i) into odds
summing i into total
maximizing i into max
minimizing i into min
finally (return (list min max total evens odds)))


(defent User
[:username :string {:unique true}]
[:openid :string]
[:email :email]
[:points :int])

http://github.com/zefhemel/adia


(defwebfn show [u User]
[:h1 "Posted items"]
[:ul
(for [i (query Item
:where {:author (:_id u)}
:order-by {:date -1})]
[:li (:title i)])])


advantages


easy to develop

builds on existing platform

existing community


disadvantages


<h1>Hello, Rails!</h1>
<%= link_to "My Blog", post_path %>

http://zef.me/2308/when-rails-fails


<h1>Hello, Rails!</h1>
<%= link_to "My Blog", post_path %>

post_url failed to generate from
{:controller=>"posts", :action=>"show"} – you may have ambiguous
routes, or you may need to supply additional parameters for this
route. content_url has the following required parameters:
["posts", :id] – are they all satisﬁed?

http://zef.me/2308/when-rails-fails


<%= link_to 'Destroy', post, :confrm => 'Are you sure?', :method => :delete %>


validates_presence_of :nam
end


no static checking

late discovery of errors


non-domain speciﬁc error messages


errors hard to trace back to origin


Table t = table("table").as("t");
Table t1 = table("table1").as("t1");
Field tId = t.field("id");
Field t1Id = t1.field("id");
Field t1Time = t1.field("time");

Sql sql = select(tId).from(t).join(inner(t1, tId.eq(t1Id)))
.where(and(tId.eq("'a'"), t1Time.between("'1900'", "'2000'")))
.groupBy(tId).having(tId.gt("1"))
.orderBy(asc(tId));

http://www.jequel.de


limited freedom in syntax


+ -
quick development lack of static checking

built on existing errors hard to trace
platform back to origin

existing community bad error messages

limited freedom in
syntax


?

Internal DSLs

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (14)

Similaire à Internal DSLs

Similaire à Internal DSLs (20)

Plus de zefhemel

Plus de zefhemel (11)

Dernier

Dernier (20)

Internal DSLs