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

Recommended

Recommended

More Related Content

What's hot

What's hot (14)

Similar to Internal DSLs

Similar to Internal DSLs (20)

More from zefhemel

More from zefhemel (11)

Recently uploaded

Recently uploaded (20)

Internal DSLs