Loell

lazy object evaluation little language

Last Update

10/16/2005; 1:22:40 AM

Try XHTML 2.0
Src XHTML 2.0
RDF Metadata

Loell is an experimental programming language in development. The idea is to have a small core with a lot of power. For the rest I plan to use it to try out new language ideas, which I usually get from Lambda the Ultimate. The focus is on testing out language features that improve productivity, like goal directed programming, helpful typing features, readability and building abstractions.

Try some code:

Core syntax

exprs separator expr: First evaluates exprs and if that does not return failure then returns expr. Valid expression separators are ; and a new line, if the indentation on the new line is not bigger than the indentation of the line of the start of the expression.
expr.(exprs) expr.(exprs) = expr: Gets/sets a property.
{ exprs }: Creates a closure, the current scope is stored in the scope property.
expr # closure: Evaluate a closure, using expr as scope.
expr < exprs >: Creates a new object, using expr as prototype (stored in the proto property). The current scope is stored in the scope property. If expr is ommited, Any is used. exprs is evaluated in the current scope, but with current set the newly created object.
expr closure expr: Simulates a method call. (object method argument) The closure is called with the scope it was defined in, but with this set to the left value, and that set to the right value.
expr ident= expr: A method call, where the object is set to the result.
$: The current scope.
ident ident = expr: Gets/sets a property of the current scope
[ exprs ]: Creates a list, with for each expression an element with the value of that expression.

Shortcut syntax

expr.ident expr.ident = expr: Gets/sets a property.
.ident .ident = expr .(exprs) .(exprs) = expr: Gets/sets a property of this inside a closure definition, or of the current inside an object definition.
{ \ident separator exprs }: Creates a closure. The value of that is assigned to ident. (This makes ident the argument name for methods) The identifier may be extended to a test expression.
ident: Proper identifier tokens are: /[A-Za-z_][A-Za-z0-9_]*/, ==, != or any combination of * + - & ^ ? | /
/*...*/ //...: Javascript style comments are supported

All objects

These methods are defined:

== !=: test if it is (not) the same object
isA: test if the argument is a prototype of this object
then: Evaluates the argument if this is not failure. Use a closure if you want short-circuiting. (similar to && in Javascript)
else: Evaluates the argument if this is failure. Use a closure if you want short-circuiting. (similar to || in Javascript)

Lists

These methods are defined:

+: list concatenation
item n: Get the nth item from the list.
all closure: Returns a new list by calling closure once for every item, passing each item as the argument to closure. The result of closure is used as the given item in the new list. If a call fails, all fails.
some closure: Returns a new list by calling closure once for every item, passing each item as the argument to closure. The result of closure is used as the given item in the new list, if the call succeeds. some can be used to filter a list.

Closures

These methods are defined:

closureA | closureB: Creates a new closure, that first calls closureA, then calls closureB if that fails.

Strings

The syntax is equivalent to javascript. These methods are defined:

+: string concatenation
== !=: test for (in)equality

Numbers

The syntax is equivalent to javascript. These methods are defined:

+ - * /: arithmetic
lt gt: less than and greater than tests
== !=: test for (in)equality

Booleans

Loell has basic goal directed programming support. True is success and false is failure. Most test methods return failure when the test failes, and this when the test succeeds.

! expr: not. Turns failure into success, and anything else into failure.

// implementation of the Complex prototype
Complex = <
  /** property definitions **/
  .r = Number<>
  .i = Number<>
  
  /** method definition **/
  .toString = {'' + .r + '+' + .i + 'i'}
  .makeComplex = {\value
    value isA Complex else Complex<.r = value; .i = 0>
  }
  .+ = {
    that = this makeComplex that
    Complex<
      .r = this.r + that.r
      .i = this.i + that.i
    >
  }
  .* = {
    that = this makeComplex that
    Complex<
      .r = this.r * that.r - this.i * that.i
      .i = this.r * that.i + this.i * that.r
    >
  }
>
// make a new complex number
i = Complex<.r = 0; .i = 1>
x = i*2+1
x toString

// implementation of while
// while is used as a method of the current scope
while = {\test
  $.whileScope = this
  <.do = {\code
    (#test) then {
      #code
      whileScope while test do code
    } else success
  }>
}
 
// implementation of until
// until is a method of closures
Closure.until = {\test
  #this
  (#test) else {
    this until test
  }
}
 
// testcode
a = 2
b = (1==2) then {a = 3} else {a = 4}
 
$while {a!=1} do {
  a -= 1
  b += 5
}
 
{
  a += 1
  b -= 4
} until {a==4}
 
b

Shape=<
  .x = Number<>
  .y = Number<>
  .moveTo = {\pos {.x isA Number gt 0; .y isA Number gt 0}
    .x = pos.x
    .y = pos.y
  }
  .rMoveTo = {\pos {.x isA Number; .y isA Number}
    .x += pos.x
    .y += pos.y
  }
>
 
Rectangle = Shape<
  .width = Number<>
  .height = Number<>
  .draw = {
    "Drawing a Rectangle at:(" + .x + "," + .y +
      "), width " + .width + ", height " + .height + "\n"
  }
>
 
Circle = Shape<
  .radius = Number<>
  .draw = {
    "Drawing a Circle at:(" + .x + "," + .y +
         "), radius " + .radius + "\n"
  }
>
 
result = ''
 
// create a collection containing various shape instances
scribble = [
  Rectangle<.x=10; .y=20; .width=5; .height=6>
  Circle<.x=15; .y=25; .radius=8>
]
 
// iterate through the collection and handle shapes polymorphically
scribble all {\ashape
   result += ashape draw
   ashape rMoveTo <.x=100; .y=100>
   result += ashape draw
}
 
// access a rectangle specific function
arectangle = Rectangle<
  .x=0; .y=0
  .width=15; .height=15
>
arectangle.width = 30
result += arectangle draw

// add support for 'currying' closures
Closure.using={\thatValue
  $.clos = this;
  {this (clos) thatValue}
}
 
// extend the List prototype
List {
  .foldr = {.hd; .hd (that) .tl foldr that}
         | {that.nilValue}
  .foldl = {
    this foldl2 <.f = that; .nilValue = that.nilValue>
  }
  .foldl2 = {
    .hd
    .tl foldl2 <
      .f = that.f
      .nilValue = that.nilValue (that.f) this.hd
    >
  } | {that.nilValue}
  .sum = .foldr using Number.+
  .product = .foldr using Number.*
}
  
// set values to be used with foldr and foldl
Number {
  .+.nilValue = 0
  .*.nilValue = 1
}
 
// example
a = 2 to 5
decimal = List.foldl using {this*10+that}<.nilValue = 0>
a (decimal) // == 2345
'sum: '+(a sum)+', product: '+(a product)

Number.sign = {this gt 0;  1}
            | {this lt 0; -1}
            | 0
             
// test
// -3 sign
 
List {
  .zip = {!this.hd; []}
       | {!that.hd; []}
       | {[[this.hd; that.hd]] + (this.tl zip that.tl)}
 
  .qsort = {
    $.x = .hd
    $.elts_lt_x  = .tl some {that lt  x} qsort
    $.elts_gte_x = .tl some {that gte x} qsort
    elts_lt_x + [.hd] + elts_gte_x
  } | {[]}
}
  
// test
// [1;2] zip [3;4;5]
[1;4;3;3;1;2] qsort

// default recursion closure is just the closure
Closure.recurse = {this}
 
fib_nr = {\n
  $.fib_nr = closure recurse
  (n lt 2) then 1 else {
    $ fib_nr (n-1) + $ fib_nr (n-2)
  }
}
 
// this is slow:
// $ fib_nr 13
 
// let the recursion closure cache the results
fib_nr_fast = fib_nr<
  .cache = <>
  .recurse = {
    $.fnf = this
    {\arg
      fnf.cache.(arg) else {fnf.cache.(arg) = $ fnf arg}
    }
  }
>
 
$ fib_nr_fast 13