Developing a Language

Developing
a
Language
@evanphx github.com/evanphx

Evan Phoenix Feb 5th, 2011

Tuesday, February 8, 2011

LA.RB
Los Angeles Ruby Brigade

Tuesday Night. Every Week.
http://rb.la


DINNER


Which came ﬁrst?


Language > Idea


Language < Idea


Language = Idea


The programmer, like the poet,
works only slightly removed
from pure thought-stuff.

- Fred Brooks


If ideas are a
manifestation of
language


Can better
language lead to
better ideas?


better
!=
newer


To craft a language from
scratch is to take 95% from the
past and call it groundbreaking.

- Evan Phoenix


Peek back


RLK


RLK
Implement with ease


RLK
KPeg


RLK
KPeg
A new parsing library


Prattle < RLK


URLs

In the Building

git://192.168.2.88/prattle
In the Cloud

github.com/evanphx/prattle.git

github.com/evanphx/kpeg.git


Dude.
Really?


Prattle


self
true
false
nil


+module Prattle
+ module AST
+ class Self < AST::Node
+ Prattle::Parser.register self
+
+ def self.rule_name
+ "self"
+ end
+
+ def initialize
+ # Nothing.
+ end
+
+ def self.grammar(g)
+ g.self = g.str("self") { Self.new }
+ end
+ end
+ end
+end


Self

def self.grammar(g)
g.self = g.str("self") {
Self.new
}
end

047b522


True

def self.grammar(g)
g.true = g.str("true") {
True.new
}
end

04ad51b


False

def self.grammar(g)
g.false = g.str("false") {
False.new
}
end

04ad51b


Nil

def self.grammar(g)
g.nil = g.str("nil") {
Nil.new
}
end

7609e64


Number

0
10
42
10323


Number

def self.grammar(g)
g.number =
g.reg(/0|([1-9][0-9]*)/) {
|i|
Number.new(i.to_i)
}
end

a06d98c


Root

def self.grammar(g)
g.root = g.any(:true, :false,
:self, :nil,
:number)
end

dfd78cb


root = self
| true
| false
| nil
| number


REPL


REPL
Instant Gratiﬁcation


$ rbx bin/repl.rb
> 42
#<Prattle::AST::Number:0x9c
@value=42>
> true
#<Prattle::AST::True:0x9d>


Self
def bytecode(g)
g.push :self
end

4e4c1c9


True
def bytecode(g)
g.push :true
end

4e4c1c9


False
def bytecode(g)
g.push :false
end

4e4c1c9


Nil
def bytecode(g)
g.push :nil
end

4e4c1c9


Number
def bytecode(g)
g.push @value
end

4e4c1c9


String

def self.grammar(g)
not_quote = g.many(
g.any(escapes, /[^']/)) {
|*a| a.join
}
g.string = g.seq("'",
g.t(not_quote), "'") {
|str| String.new(str)
}
end


String

char = escapes
| [^’]
not_quote = char*
string = “‘“ not_quote “‘“


$ rbx bin/repl.rb
> 42
=> 42
> true
=> 42
> ‘hello’
=> “hello”


BORING


Unary Send

3 class


Unary Send

3.class
Ruby


Unary Send

g.seq(:number, “ “,
:method_name) { |v,_,n|
UnarySend.new(v,n)
}


Unary Send

us = number “ “ method_name


Unary Send

true class


Unary Send

g.seq(:atom, “ “,
UnarySend.new(v,n)
}


Unary Send

us = atom “ “ method_name


Unary Send

3 class class


Unary Send

g.any(
g.seq(:unary_send, “ “,
UnarySend.new(v,n)
},
g.seq(:atom, “ “,
UnarySend.new(v,n)
}
)


Unary Send

us = us “ “ method_name
| atom “ “ method_name


Unary Send

def bytecode(g)
@receiver.bytecode(g)
g.send @method_name.to_sym, 0
end


$ rbx bin/repl.rb
> 3 class
=> Fixnum
> 3 class class
=> Class
> ‘hello’ class
=> String


Keyword Send

‘hello’ index: ‘o’


Keyword Send

“hello”.index(“o”)
Ruby


Keyword Send

g.keyword_send =
g.seq(:atom, ‘ ‘,
:method_name, “:”,
“ “, :atom)


Keyword Send

ks = atom “ “ method_name
“: ” :atom


Keyword Send

‘hello’ at: 0
put: ‘j’


Keyword Send

“hello”[0] = “j”
Ruby


Keyword Send

g.pairs =
g.seq(:method_name, “:”,
“ “, :atom)


Keyword Send

g.keyword_send =
g.seq(
:atom, ‘ ‘,
g.many([:pair, ‘ ‘]),
:pair
)


Keyword Send

ks = atom (pair ‘ ‘)+
pair


Keyword Send

def bytecode(g)
@receiver.bytecode(g)
@arguments.each do |a|
a.bytecode(a)
end
g.send @method_name.to_sym,
@arguments.size
end


$ rbx bin/repl.rb
> ‘hello’ index: ‘o’

NoMethodError:
Unknown method ‘index:’


Keyword Send

“hello”.send(
“index:”, “o”
)
Ruby


Keyword Send

‘hello’ ~index: ‘o’


Keyword Send

def bytecode(g)
if @method_name[0] == ?~
ruby_style
else
smalltalk_style
end
end


Keyword Send

“hello”.send(
“index”, “o”
)
Ruby


$ rbx bin/repl.rb
> ‘hello’ ~index: ‘o’
=> 4
NoMethodError:
Unknown method ‘index:’


Keyword Send

obj string
at: 0
put: ‘j’


Keyword Send

g.any(:atom,
:unary_send)


Keyword Send

recv = us | atom
ks = recv (pair ‘ ‘)+
pair


Block

[ 1 ]


Keyword Send

g.block =
g.seq(‘[‘, :expr, ‘]’)


Keyword Send

expr = ks | us | atom


Keyword Send

block = “[“ expr “]


Block

[ 1. 2 ]


Keyword Send
g.exprs =
g.seq(:expr,
g.kleene(‘.’,
:expr))


Keyword Send

exprs = (‘.’ expr)*


Keyword Send

block = “[“ exprs “]


$ rbx bin/repl.rb
> 10 ~times: [
Kernel ~puts: ‘hello’
]


$ rbx bin/repl.rb
> 10 ~times: [
Kernel ~puts: ‘rb.la’
]
“rb.la”
“rb.la”
“rb.la”
...
=> 10


$ rbx bin/repl.rb
> 10 ~times: [ :x |
Kernel ~p: x
]


$ rbx bin/repl.rb
> 10 ~times: [ :x |
Kernel ~p: x
]
0
1
2
...
=> 10


Cascade Send

ary concat: a;
concat: b;
concat: c


Operators

3 + 4 * 5


$ rbx bin/repl.rb
> 3 + 4 * 5


$ rbx bin/repl.rb
> 3 + 4 * 5
=> 35


Parens

parens = “(“ expr “)


$ rbx bin/repl.rb
> 3 + (4 * 5)
=> 23


zero to usable


BIG IDEA

little idea


Complex
Language

simple language


Thanks!

See ya out there.


MIA: Return


MIA: =


Developing a Language

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (6)

Similar to Developing a Language

Similar to Developing a Language (16)

More from Engine Yard

More from Engine Yard (12)

Recently uploaded

Recently uploaded (20)

Developing a Language