.gitignore

vendor/ruby
.bundle

*.rbc

.rvmrc

if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
  && -s "${rvm_path:-$HOME/.rvm}/environments/rbx-head@europa" ]] ; then
  \. "${rvm_path:-$HOME/.rvm}/environments/rbx-head@europa"
else
  rvm --create  "rbx-head@europa"
fi

europa.bnf

EXP        : { MESSAGE | TERMINATOR }

MESSAGE    : SYMBOL [ARGUMENTS]

ARGUMENTS  : "(" [EXP [ { "," EXP } ]] ")"

SYMBOL     : IDENTIFIER | LITERAL

IDENTIFER  : ( "_" | alphabetic_char ) [ any_char* ]

LITERAL    : string | numeric

TERMINATOR : "\n" | ";"

alphabetic_char : [a-zA-Z]
numeric_char    : [ "-" ] [0-9] [\.0-9]
white_space     : [ \n\t]
any_char        : !white_space

Europa.mkd

Europa

Abstract

Europa is an attempt at an object-oriented, reflective, modern language. As computers get faster with more cores and memory, it is important that parallelization and concurrency be made as simple as possible. Additionally, most modern network applications spend the majority of their time waiting on and manipulating IO. A web framework gets an HTTP request, processes it, turns it into one or several database queries that run sequentially, builds a response document in memory, then sends it back out on the network. All of these operations could be done in parallel on a multi-core system, which is the purpose behind functional languages. However, functional languages are missing the equivalent of Ruby or Python, that is, a language that optimizes for developer time.

Managing IO

Since IO is so fundamental to the performance and operation of every network server, it is absolutely imperative that the language support it at a very low level, and make it transparent to the developer. Some features in functional languages make this easier.

Exemplar Sample

def sleep_and_print(time)
  x = sleep(time)
  print x
end

print_and_sleep(4)
print_and_sleep(2)

Notes

Given:

1. The #sleep method sleeps for the given number of seconds. However, since all methods are asynchronous, it might take a little longer, and so returns the actual time slept.
2. Method calls always execute in order, so even though the first sleeps for longer, they output is printed in the correct order.
3. The method calls happen in parallel, so the total run time is slightly more than 4 seconds.

Output

$ time europa sample.eur
4.0021
2.0003
europa sample.eur 0.00s user 0.00s system 0% cpu 4.083 total

What I don't want

• eval of any kind
• This is a high-level server language, not a command-line utility language, like Perl and its descendants. I'd like to avoid things like environment variables and command like options, if it can at all be helped. JavaScript seems to be able to get away with it...
• No "protected" or "private" methods. In Ruby, its just a formality, because you can always #send the method. Instead, the public API should be exposed via documentation.

Syntax

Syntax is mostly inspired by Ruby and Python, with some other sugar taken from Lua and JavaScript.

Trailing commas are legal

fruit = [
  apple,
  banana,
  orange,
]

Function overloading

Simplify this common idiom:

def find(*args)
  case args.shift
  when :first
    find_one(*args)
  when :all
    find_many(*args)
  end
end

def find_one(*args)
  # find one
end

def find_many(*args)
  # find many
end

With this:

def find(:first, *args)
  # find one
end

def find(:all, *args)
  # find all
end

Sugar

"keywords" like class, module, def are just sugar. The following are equivalent:

class MyClass

  def foo(bar, baz)
    # ...
  end

end

uses the sugar methods, but the actual language specification is:

MyClass = Object.clone do

  foo = method(bar, baz) do
    # ...
  end

end

europa.rb

# Autogenerated from a Treetop grammar. Edits may be lost.


module Europa
  include Treetop::Runtime

  def root
    @root ||= :exp
  end

  def _nt_exp
    start_index = index
    if node_cache[:exp].has_key?(index)
      cached = node_cache[:exp][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_message
    if r1
      r0 = r1
    else
      r2 = _nt_terminator
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:exp][start_index] = r0

    r0
  end

  module Message0
    def symbol
      elements[0]
    end

  end

  def _nt_message
    start_index = index
    if node_cache[:message].has_key?(index)
      cached = node_cache[:message][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_symbol
    s0 << r1
    if r1
      if has_terminal?('\G[arguments]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      s0 << r2
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Message0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:message][start_index] = r0

    r0
  end

  def _nt_symbol
    start_index = index
    if node_cache[:symbol].has_key?(index)
      cached = node_cache[:symbol][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_identifier
    if r1
      r0 = r1
    else
      r2 = _nt_literal
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:symbol][start_index] = r0

    r0
  end

  module Identifier0
    def alphabetic_char
      elements[0]
    end

  end

  def _nt_identifier
    start_index = index
    if node_cache[:identifier].has_key?(index)
      cached = node_cache[:identifier][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_alphabetic_char
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        r3 = _nt_alphanumeric_char
        if r3
          s2 << r3
        else
          break
        end
      end
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      s0 << r2
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Identifier0)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:identifier][start_index] = r0

    r0
  end

  def _nt_literal
    start_index = index
    if node_cache[:literal].has_key?(index)
      cached = node_cache[:literal][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_string
    if r1
      r0 = r1
    else
      r2 = _nt_number
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:literal][start_index] = r0

    r0
  end

  module String0
  end

  module String1
  end

  def _nt_string
    start_index = index
    if node_cache[:string].has_key?(index)
      cached = node_cache[:string][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    if has_terminal?('"', false, index)
      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('"')
      r1 = nil
    end
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3 = index
        i4, s4 = index, []
        i5 = index
        if has_terminal?('"', false, index)
          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('"')
          r6 = nil
        end
        if r6
          r5 = nil
        else
          @index = i5
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s4 << r5
        if r5
          if index < input_length
            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("any character")
            r7 = nil
          end
          s4 << r7
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(String0)
        else
          @index = i4
          r4 = nil
        end
        if r4
          r3 = r4
        else
          if has_terminal?('\"', false, index)
            r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
            @index += 2
          else
            terminal_parse_failure('\"')
            r8 = nil
          end
          if r8
            r3 = r8
          else
            @index = i3
            r3 = nil
          end
        end
        if r3
          s2 << r3
        else
          break
        end
      end
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      s0 << r2
      if r2
        if has_terminal?('"', false, index)
          r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('"')
          r9 = nil
        end
        s0 << r9
      end
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(String1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:string][start_index] = r0

    r0
  end

  module Number0
  end

  module Number1
  end

  def _nt_number
    start_index = index
    if node_cache[:number].has_key?(index)
      cached = node_cache[:number][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      if has_terminal?('\G[0-9]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      if r2
        s1 << r2
      else
        break
      end
    end
    if s1.empty?
      @index = i1
      r1 = nil
    else
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    end
    s0 << r1
    if r1
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        if has_terminal?('.', false, index)
          r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('.')
          r5 = nil
        end
        s4 << r5
        if r5
          if has_terminal?('\G[0-9]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          s4 << r6
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(Number0)
        else
          @index = i4
          r4 = nil
        end
        if r4
          s3 << r4
        else
          break
        end
      end
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      s0 << r3
    end
    if s0.last
      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
      r0.extend(Number1)
    else
      @index = i0
      r0 = nil
    end

    node_cache[:number][start_index] = r0

    r0
  end

  def _nt_alphabetic_char
    start_index = index
    if node_cache[:alphabetic_char].has_key?(index)
      cached = node_cache[:alphabetic_char][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    if has_terminal?('\G[A-Za-z_]', true, index)
      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      r0 = nil
    end

    node_cache[:alphabetic_char][start_index] = r0

    r0
  end

  def _nt_alphanumeric_char
    start_index = index
    if node_cache[:alphanumeric_char].has_key?(index)
      cached = node_cache[:alphanumeric_char][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_alphabetic_char
    if r1
      r0 = r1
    else
      if has_terminal?('\G[0-9]', true, index)
        r2 = true
        @index += 1
      else
        r2 = nil
      end
      if r2
        r0 = r2
      else
        @index = i0
        r0 = nil
      end
    end

    node_cache[:alphanumeric_char][start_index] = r0

    r0
  end

  def _nt_whitespace_char
    start_index = index
    if node_cache[:whitespace_char].has_key?(index)
      cached = node_cache[:whitespace_char][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    if has_terminal?('\G[ \\t\\n\\r]', true, index)
      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      r0 = nil
    end

    node_cache[:whitespace_char][start_index] = r0

    r0
  end

  def _nt_non_whitespace_char
    start_index = index
    if node_cache[:non_whitespace_char].has_key?(index)
      cached = node_cache[:non_whitespace_char][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_whitespace_char
    if r1
      r0 = nil
    else
      @index = i0
      r0 = instantiate_node(SyntaxNode,input, index...index)
    end

    node_cache[:non_whitespace_char][start_index] = r0

    r0
  end

  def _nt_whitespace
    start_index = index
    if node_cache[:whitespace].has_key?(index)
      cached = node_cache[:whitespace][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    s0, i0 = [], index
    loop do
      r1 = _nt_whitespace_char
      if r1
        s0 << r1
      else
        break
      end
    end
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)

    node_cache[:whitespace][start_index] = r0

    r0
  end

  def _nt_non_whitespace
    start_index = index
    if node_cache[:non_whitespace].has_key?(index)
      cached = node_cache[:non_whitespace][index]
      if cached
        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
        @index = cached.interval.end
      end
      return cached
    end

    i0 = index
    r1 = _nt_whitespace
    if r1
      r0 = nil
    else
      @index = i0
      r0 = instantiate_node(SyntaxNode,input, index...index)
    end

    node_cache[:non_whitespace][start_index] = r0

    r0
  end

end

class EuropaParser < Treetop::Runtime::CompiledParser
  include Europa
end

europa.tt

grammar Europa

  rule script
    statement+
  end

  rule statement
    exp (whitespace+ exp)*
  end

  rule exp
    (message ( "." message)*) / terminator / comment
  end

  rule message
    symbol arguments*
  end

  rule symbol
    identifier / literal
  end

  rule arguments
    "(" whitespace* ( exp whitespace* ( "," whitespace* exp whitespace* )* )* whitespace* ")"
  end

  rule identifier
    [a-zA-Z_] [\w]*
  end

  rule literal
    string / number / label
  end

  rule string
    single_quoted_string / double_quoted_string
  end

  rule single_quoted_string
    '"' (!'"' . / '\"')* '"'
  end

  rule double_quoted_string
    "'" (!"'" . )* "'"
  end

  rule number
    integer ( "." integer )*
  end

  rule integer
    [0-9]+ {
      def value
        text_value.to_i
      end
    }
  end

  rule label
    ":" ([\w]+ / string)
  end

  rule terminator
    space* (";" / newline)
  end

  rule comment
    '#' ( !newline . )+ ( newline / !. )
  end

  rule newline
    [\r\n]
  end

  rule space
    [ \t]
  end

  rule whitespace
    (space / newline)
  end

end

example1.eur

# A comment is a # at the start of a line, to the end of the line

# Integer
42

# Number
3.1415

# Single-quoted String
'foo'

# Double-quoted String
"bar"

# labels
:label
:"quoted label"
:'another label'

# variable
foo
foo_bar
_bar
Baz

# method calls
foo.bar
foo.bar(42)

# more complex syntax

if(something,
  do_when_true,
  do_when_false
)

if(something)
then(do_when_true)
else(do_when_false)

# suffix conditional
do_stuff unless(dont_do_stuff)

Gemfile

source :rubygems

gem "ruby-llvm"
gem "parslet"
gem "minitest"

Gemfile.lock

GEM
  remote: http://rubygems.org/
  specs:
    blankslate (2.1.2.3)
    ffi (1.0.5)
      rake (>= 0.8.7)
    minitest (2.0.2)
    parslet (1.0.0)
      blankslate (~> 2.1.2.3)
    rake (0.8.7)
    ruby-llvm (2.7.0)
      ffi (>= 0.5.4)

PLATFORMS
  ruby

DEPENDENCIES
  minitest
  parslet
  ruby-llvm

object model.dot

digraph object_model {

  graph [
    rankdir = "RL"
  ];

  node [
    shape = "record"
  ];

  edge [
  ];

  empty [
    label = "EmptyObject|\
    __clone\l\
    __send\l\
    "
  ];

  object [
    label = "Object|\
    clone\l\
    send\l\
    object_id\l\
    ==\l\
    ===\l\
    eql?\l\
    equal?\l\
    []\l\
    []=\l\
    "
  ];
  object -> empty;

  number [
    label = "Number|\
    +\l\
    -\l\
    *\l\
    /\l\
    "
  ];
  number -> object;

  integer [
    label = "Integer|\
    \l\
    "
  ];
  integer -> number;

  buffer [
    label = "Buffer|\
    each\l\
    "
  ];
  buffer -> object;

  string [
    label = "String|\
    \l\
    "
  ];
  string -> buffer;

  "label" [
    label = "Label|\
    \l\
    "
  ];
  "label" -> object;

  kernel [
    label = "Kernel|\
    print\l\
    "
  ];
  kernel -> object;

  array [
    label = "Array|\
    []\l\
    []=\l\
    each\l\
    "
  ];
  array -> object;

  boolean [
    label = "Boolean|\
    "
  ];
  boolean -> object;

  "true" [
    label = "true|\
    "
  ];
  "true" -> boolean;

  "false" [
    label = "false|\
    "
  ];
  "false" -> boolean;



  nil [
    label = "nil|\
    nil?\l\
    blank?\l\
    "
  ];
  nil -> object;

  undefined [
    label = "undefined|\
    blank?\l\
    "
  ];
  undefined -> object;



}

object model.dot.svg

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Generated by graphviz version 2.26.3 (20100126.1600)
 -->
<!-- Title: object_model Pages: 1 -->
<svg width="416pt" height="596pt"
 viewBox="0.00 0.00 416.00 596.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph1" class="graph" transform="scale(1 1) rotate(0) translate(4 592)">
<title>object_model</title>
<polygon fill="white" stroke="white" points="-4,5 -4,-592 413,-592 413,5 -4,5"/>
<!-- empty -->
<g id="node1" class="node"><title>empty</title>
<polygon fill="none" stroke="black" points="0.5,-254.5 0.5,-315.5 93.5,-315.5 93.5,-254.5 0.5,-254.5"/>
<text text-anchor="middle" x="47" y="-298.9" font-family="Times,serif" font-size="14.00">EmptyObject</text>
<polyline fill="none" stroke="black" points="0.5,-292.5 93.5,-292.5 "/>
<text text-anchor="start" x="8.5" y="-275.9" font-family="Times,serif" font-size="14.00">__clone</text>
<text text-anchor="start" x="8.5" y="-260.9" font-family="Times,serif" font-size="14.00"> __send</text>
</g>
<!-- object -->
<g id="node2" class="node"><title>object</title>
<polygon fill="none" stroke="black" points="130,-202 130,-368 204,-368 204,-202 130,-202"/>
<text text-anchor="middle" x="167" y="-351.4" font-family="Times,serif" font-size="14.00">Object</text>
<polyline fill="none" stroke="black" points="130,-345 204,-345 "/>
<text text-anchor="start" x="138" y="-328.4" font-family="Times,serif" font-size="14.00">clone</text>
<text text-anchor="start" x="138" y="-313.4" font-family="Times,serif" font-size="14.00"> send</text>
<text text-anchor="start" x="138" y="-298.4" font-family="Times,serif" font-size="14.00"> object_id</text>
<text text-anchor="start" x="138" y="-283.4" font-family="Times,serif" font-size="14.00"> ==</text>
<text text-anchor="start" x="138" y="-268.4" font-family="Times,serif" font-size="14.00"> ===</text>
<text text-anchor="start" x="138" y="-253.4" font-family="Times,serif" font-size="14.00"> eql?</text>
<text text-anchor="start" x="138" y="-238.4" font-family="Times,serif" font-size="14.00"> equal?</text>
<text text-anchor="start" x="138" y="-223.4" font-family="Times,serif" font-size="14.00"> []</text>
<text text-anchor="start" x="138" y="-208.4" font-family="Times,serif" font-size="14.00"> []=</text>
</g>
<!-- object&#45;&gt;empty -->
<g id="edge2" class="edge"><title>object&#45;&gt;empty</title>
<path fill="none" stroke="black" d="M129.689,-285C121.48,-285 112.607,-285 103.824,-285"/>
<polygon fill="black" stroke="black" points="103.602,-281.5 93.6018,-285 103.602,-288.5 103.602,-281.5"/>
</g>
<!-- number -->
<g id="node4" class="node"><title>number</title>
<polygon fill="none" stroke="black" points="244.5,-496.5 244.5,-587.5 309.5,-587.5 309.5,-496.5 244.5,-496.5"/>
<text text-anchor="middle" x="277" y="-570.9" font-family="Times,serif" font-size="14.00">Number</text>
<polyline fill="none" stroke="black" points="244.5,-564.5 309.5,-564.5 "/>
<text text-anchor="start" x="252.5" y="-547.9" font-family="Times,serif" font-size="14.00">+</text>
<text text-anchor="start" x="252.5" y="-532.9" font-family="Times,serif" font-size="14.00"> &#45;</text>
<text text-anchor="start" x="252.5" y="-517.9" font-family="Times,serif" font-size="14.00"> *</text>
<text text-anchor="start" x="252.5" y="-502.9" font-family="Times,serif" font-size="14.00"> /</text>
</g>
<!-- number&#45;&gt;object -->
<g id="edge4" class="edge"><title>number&#45;&gt;object</title>
<path fill="none" stroke="black" d="M245.057,-496.288C243.266,-493.192 241.562,-490.079 240,-487 222.497,-452.5 207.192,-412.787 195.177,-377.753"/>
<polygon fill="black" stroke="black" points="198.398,-376.353 191.877,-368.004 191.768,-378.598 198.398,-376.353"/>
</g>
<!-- integer -->
<g id="node6" class="node"><title>integer</title>
<polygon fill="none" stroke="black" points="350.5,-518.5 350.5,-565.5 407.5,-565.5 407.5,-518.5 350.5,-518.5"/>
<text text-anchor="middle" x="379" y="-548.9" font-family="Times,serif" font-size="14.00">Integer</text>
<polyline fill="none" stroke="black" points="350.5,-542.5 407.5,-542.5 "/>
</g>
<!-- integer&#45;&gt;number -->
<g id="edge6" class="edge"><title>integer&#45;&gt;number</title>
<path fill="none" stroke="black" d="M350.316,-542C340.859,-542 330.126,-542 319.847,-542"/>
<polygon fill="black" stroke="black" points="319.783,-538.5 309.783,-542 319.783,-545.5 319.783,-538.5"/>
</g>
<!-- buffer -->
<g id="node8" class="node"><title>buffer</title>
<polygon fill="none" stroke="black" points="250,-432 250,-478 304,-478 304,-432 250,-432"/>
<text text-anchor="middle" x="277" y="-461.4" font-family="Times,serif" font-size="14.00">Buffer</text>
<polyline fill="none" stroke="black" points="250,-455 304,-455 "/>
<text text-anchor="start" x="258" y="-438.4" font-family="Times,serif" font-size="14.00">each</text>
</g>
<!-- buffer&#45;&gt;object -->
<g id="edge8" class="edge"><title>buffer&#45;&gt;object</title>
<path fill="none" stroke="black" d="M249.959,-433.738C246.398,-430.346 242.961,-426.721 240,-423 228.679,-408.774 218.279,-392.528 209.095,-376.298"/>
<polygon fill="black" stroke="black" points="212.02,-374.355 204.119,-367.296 205.893,-377.741 212.02,-374.355"/>
</g>
<!-- string -->
<g id="node10" class="node"><title>string</title>
<polygon fill="none" stroke="black" points="352,-431.5 352,-478.5 406,-478.5 406,-431.5 352,-431.5"/>
<text text-anchor="middle" x="379" y="-461.9" font-family="Times,serif" font-size="14.00">String</text>
<polyline fill="none" stroke="black" points="352,-455.5 406,-455.5 "/>
</g>
<!-- string&#45;&gt;buffer -->
<g id="edge10" class="edge"><title>string&#45;&gt;buffer</title>
<path fill="none" stroke="black" d="M351.934,-455C340.406,-455 326.769,-455 314.31,-455"/>
<polygon fill="black" stroke="black" points="314.193,-451.5 304.193,-455 314.193,-458.5 314.193,-451.5"/>
</g>
<!-- label -->
<g id="node12" class="node"><title>label</title>
<polygon fill="none" stroke="black" points="250,-366.5 250,-413.5 304,-413.5 304,-366.5 250,-366.5"/>
<text text-anchor="middle" x="277" y="-396.9" font-family="Times,serif" font-size="14.00">Label</text>
<polyline fill="none" stroke="black" points="250,-390.5 304,-390.5 "/>
</g>
<!-- label&#45;&gt;object -->
<g id="edge12" class="edge"><title>label&#45;&gt;object</title>
<path fill="none" stroke="black" d="M250.179,-366.365C246.729,-363.242 243.264,-360.062 240,-357 230.677,-348.256 220.841,-338.752 211.514,-329.603"/>
<polygon fill="black" stroke="black" points="213.742,-326.886 204.161,-322.363 208.831,-331.874 213.742,-326.886"/>
</g>
<!-- kernel -->
<g id="node14" class="node"><title>kernel</title>
<polygon fill="none" stroke="black" points="249,-302 249,-348 305,-348 305,-302 249,-302"/>
<text text-anchor="middle" x="277" y="-331.4" font-family="Times,serif" font-size="14.00">Kernel</text>
<polyline fill="none" stroke="black" points="249,-325 305,-325 "/>
<text text-anchor="start" x="257" y="-308.4" font-family="Times,serif" font-size="14.00">print</text>
</g>
<!-- kernel&#45;&gt;object -->
<g id="edge14" class="edge"><title>kernel&#45;&gt;object</title>
<path fill="none" stroke="black" d="M248.958,-314.803C238.209,-310.894 225.636,-306.322 213.611,-301.949"/>
<polygon fill="black" stroke="black" points="214.724,-298.63 204.13,-298.502 212.331,-305.208 214.724,-298.63"/>
</g>
<!-- array -->
<g id="node16" class="node"><title>array</title>
<polygon fill="none" stroke="black" points="250,-208 250,-284 304,-284 304,-208 250,-208"/>
<text text-anchor="middle" x="277" y="-267.4" font-family="Times,serif" font-size="14.00">Array</text>
<polyline fill="none" stroke="black" points="250,-261 304,-261 "/>
<text text-anchor="start" x="258" y="-244.4" font-family="Times,serif" font-size="14.00">[]</text>
<text text-anchor="start" x="258" y="-229.4" font-family="Times,serif" font-size="14.00"> []=</text>
<text text-anchor="start" x="258" y="-214.4" font-family="Times,serif" font-size="14.00"> each</text>
</g>
<!-- array&#45;&gt;object -->
<g id="edge16" class="edge"><title>array&#45;&gt;object</title>
<path fill="none" stroke="black" d="M249.809,-255.64C238.966,-259.485 226.165,-264.023 213.912,-268.368"/>
<polygon fill="black" stroke="black" points="212.506,-265.152 204.251,-271.793 214.845,-271.75 212.506,-265.152"/>
</g>
<!-- boolean -->
<g id="node18" class="node"><title>boolean</title>
<polygon fill="none" stroke="black" points="244.5,-144 244.5,-190 309.5,-190 309.5,-144 244.5,-144"/>
<text text-anchor="middle" x="277" y="-173.4" font-family="Times,serif" font-size="14.00">Boolean</text>
<polyline fill="none" stroke="black" points="244.5,-167 309.5,-167 "/>
<text text-anchor="middle" x="277" y="-150.4" font-family="Times,serif" font-size="14.00"> </text>
</g>
<!-- boolean&#45;&gt;object -->
<g id="edge18" class="edge"><title>boolean&#45;&gt;object</title>
<path fill="none" stroke="black" d="M249.097,-190.312C245.963,-193.169 242.869,-196.104 240,-199 230.128,-208.963 220.067,-220.083 210.694,-230.932"/>
<polygon fill="black" stroke="black" points="207.838,-228.886 204.004,-238.763 213.16,-233.433 207.838,-228.886"/>
</g>
<!-- true -->
<g id="node20" class="node"><title>true</title>
<polygon fill="none" stroke="black" points="352,-176 352,-222 406,-222 406,-176 352,-176"/>
<text text-anchor="middle" x="379" y="-205.4" font-family="Times,serif" font-size="14.00">true</text>
<polyline fill="none" stroke="black" points="352,-199 406,-199 "/>
<text text-anchor="middle" x="379" y="-182.4" font-family="Times,serif" font-size="14.00"> </text>
</g>
<!-- true&#45;&gt;boolean -->
<g id="edge20" class="edge"><title>true&#45;&gt;boolean</title>
<path fill="none" stroke="black" d="M351.934,-190.509C341.993,-187.39 330.482,-183.779 319.511,-180.337"/>
<polygon fill="black" stroke="black" points="320.237,-176.897 309.648,-177.243 318.142,-183.576 320.237,-176.897"/>
</g>
<!-- false -->
<g id="node22" class="node"><title>false</title>
<polygon fill="none" stroke="black" points="352,-112 352,-158 406,-158 406,-112 352,-112"/>
<text text-anchor="middle" x="379" y="-141.4" font-family="Times,serif" font-size="14.00">false</text>
<polyline fill="none" stroke="black" points="352,-135 406,-135 "/>
<text text-anchor="middle" x="379" y="-118.4" font-family="Times,serif" font-size="14.00"> </text>
</g>
<!-- false&#45;&gt;boolean -->
<g id="edge22" class="edge"><title>false&#45;&gt;boolean</title>
<path fill="none" stroke="black" d="M351.934,-143.491C341.993,-146.61 330.482,-150.221 319.511,-153.663"/>
<polygon fill="black" stroke="black" points="318.142,-150.424 309.648,-156.757 320.237,-157.103 318.142,-150.424"/>
</g>
<!-- nil -->
<g id="node24" class="node"><title>nil</title>
<polygon fill="none" stroke="black" points="247.5,-64.5 247.5,-125.5 306.5,-125.5 306.5,-64.5 247.5,-64.5"/>
<text text-anchor="middle" x="277" y="-108.9" font-family="Times,serif" font-size="14.00">nil</text>
<polyline fill="none" stroke="black" points="247.5,-102.5 306.5,-102.5 "/>
<text text-anchor="start" x="255.5" y="-85.9" font-family="Times,serif" font-size="14.00">nil?</text>
<text text-anchor="start" x="255.5" y="-70.9" font-family="Times,serif" font-size="14.00"> blank?</text>
</g>
<!-- nil&#45;&gt;object -->
<g id="edge24" class="edge"><title>nil&#45;&gt;object</title>
<path fill="none" stroke="black" d="M247.362,-125.247C244.745,-128.44 242.242,-131.72 240,-135 227.81,-152.83 216.527,-173.002 206.657,-192.638"/>
<polygon fill="black" stroke="black" points="203.515,-191.096 202.223,-201.612 209.791,-194.197 203.515,-191.096"/>
</g>
<!-- undefined -->
<g id="node26" class="node"><title>undefined</title>
<polygon fill="none" stroke="black" points="240,-0 240,-46 314,-46 314,-0 240,-0"/>
<text text-anchor="middle" x="277" y="-29.4" font-family="Times,serif" font-size="14.00">undefined</text>
<polyline fill="none" stroke="black" points="240,-23 314,-23 "/>
<text text-anchor="start" x="248" y="-6.4" font-family="Times,serif" font-size="14.00">blank?</text>
</g>
<!-- undefined&#45;&gt;object -->
<g id="edge26" class="edge"><title>undefined&#45;&gt;object</title>
<path fill="none" stroke="black" d="M247.133,-46.069C244.498,-48.8864 242.056,-51.8795 240,-55 212.895,-96.1432 195.288,-148.025 184.172,-192.095"/>
<polygon fill="black" stroke="black" points="180.737,-191.407 181.76,-201.952 187.536,-193.071 180.737,-191.407"/>
</g>
</g>
</svg>

parser.rb

require 'parslet'

class EuropaParser < Parslet::Parser

  rule(:script)               { (statement | comment).repeat }

  rule(:statement)            { atom.repeat(1) >> eol }

  rule(:atom)                 { identifier | literal }

  rule(:identifier)           { match['a-z_'].repeat(1) }

  rule(:literal)              { number | string | symbol }

  rule(:number)               { integer >> ( str('.') >> integer ).maybe }

  rule(:integer)              { match['0-9'].repeat(1) }

  rule(:string)               { single_quoted_string | double_quoted_string }

  rule(:single_quoted_string) {
    single_quote >> (single_quote.absnt? >> any).repeat >> single_quote
  }

  rule(:double_quoted_string) {
    double_quote >> (double_quote.absnt? >> any).repeat >> double_quote
  }

  rule(:symbol)               { str(':') >> (identifier | string) }

  rule(:comment)              {
    (space.maybe >> str('#') >> (eol.absnt? >> any).repeat >> eol).repeat(1)
  }

  rule(:eol)                  { match('[\r\n]').repeat(1) }
  rule(:space)                { match['\\s'].repeat(1) }
  rule(:space?)               { space.maybe }

  rule(:single_quote)         { str("'") }
  rule(:double_quote)         { str('"') }

  root(:script)
end

if $0 == __FILE__
  require 'minitest/autorun'

  class ParserTest < MiniTest::Unit::TestCase

    def setup
      @parser = EuropaParser.new
    end

    def assert_parses(code)
      begin
        @parser.parse code
      rescue Parslet::ParseFailed => err
        raise MiniTest::Assertion, err.to_s + "\n" + @parser.root.error_tree.to_s
      end
    end

    def test_comment
      assert_parses <<-CODE
# comment
      CODE
    end

    def test_multiline_comment
      assert_parses <<-CODE
#######################
# Fancy Comment Block #
#######################
      CODE
    end

    def test_indented_comment
      assert_parses <<-CODE
        # indent
      CODE
    end

    def test_integer
      assert_parses <<-CODE
42
      CODE
    end

    def test_number
      assert_parses <<-CODE
42.0
      CODE
    end

    def test_single_quoted_string
      assert_parses <<-CODE
'hello, world!'
      CODE
    end

    def test_double_quoted_string
      assert_parses <<-CODE
"hello, world!"
      CODE
    end

    def test_escaping_in_strings
      skip "Implement escaped quotes"
      assert_parses <<-CODE
"hello, \\\"world\\\""
      CODE
    end

    def test_symbol
      assert_parses <<-CODE
:symbol
      CODE
    end

    def test_string_symbols
      assert_parses <<-CODE
:"42"
:'illegal-identifier'
      CODE
    end


  end

end