trxl 0.1.5

data/spec/trxl/booleans_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe "For writing boolean expressions, the language" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+
+  it "should allow a logical AND operation by using '&&'" do
+    eval("TRUE && TRUE").should be_true
+    eval("FALSE && FALSE").should be_false
+    eval("TRUE && FALSE").should be_false
+    eval("FALSE && TRUE").should be_false
+    
+    eval("TRUE && NULL").should be_false
+    eval("NULL && TRUE").should be_false
+    eval("NULL && NULL").should be_false
+    
+    eval("(2 == 2) && (2 == 2)").should be_true
+
+    lambda { eval("TRUE && TRUE && TRUE") }.should_not raise_error
+    lambda { eval("TRUE && TRUE && FALSE") }.should_not raise_error
+    lambda { eval("(2 == 2) && (2 == 2) && (2 == 2)") }.should_not raise_error
+    lambda { eval("(2 == 2) && (2 == 2) && (2 == 3)") }.should_not raise_error
+  end
+  
+  it "should allow a logical OR operation by using '||'" do
+    eval("TRUE || TRUE").should be_true
+    eval("TRUE || FALSE").should be_true
+    eval("FALSE || TRUE").should be_true
+    eval("FALSE || FALSE").should be_false
+    eval("(2 == 2) || (2 == 2)").should be_true
+    eval("(2 == 2) || (2 == 3)").should be_true
+    eval("(2 == 3) || (2 == 3)").should be_false
+  end
+  
+  it "should allow a logical NOT operation by using '!'" do
+    eval("!TRUE").should be_false
+    eval("!FALSE").should be_true
+    eval("!1").should be_false
+    eval("!(1+1)").should be_false
+    eval("!(TRUE || FALSE)").should be_false
+    eval("!(TRUE && FALSE)").should be_true
+    eval("!(2 == 2)").should be_false
+    eval("!(2 == 3)").should be_true
+    eval("a = TRUE; !a").should be_false
+  end
+  
+end
+
+
+describe "For comparing expressions, the language" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+
+  it "should allow to test if two expressions are equal by using '=='" do
+    eval("(TRUE == TRUE)").should be_true
+    eval("(FALSE == FALSE)").should be_true
+    eval("(TRUE == FALSE)").should be_false
+    eval("(NULL == NULL)").should be_true
+    
+    eval("2.0 == 1.999999999").should         == (2.0 == 1.999999999)
+    eval("2.0 == 2.000000001").should         == (2.0 == 2.000000001)
+    eval("1.333333333 == 1.333333333").should == (1.333333333 == 1.333333333)
+    
+    eval("'foo' == 'foo'").should be_true
+    eval("'foo' == 'bar'").should be_false
+    
+    eval("'foo' != 'foo'").should be_false
+    eval("'foo' != 'bar'").should be_true
+  end
+
+  it "should allow to test if two expressions are not equal by using '!='" do
+    eval("(TRUE != TRUE)").should be_false
+    eval("(TRUE != FALSE)").should be_true
+    eval("(FALSE != FALSE)").should be_false
+    eval("(NULL != NULL)").should be_false
+    
+    eval("2.0 != 1.999999999").should         == (2.0 != 1.999999999)
+    eval("2.0 != 2.000000001").should         == (2.0 != 2.000000001)
+    eval("1.333333333 != 1.333333334").should == (1.333333333 != 1.333333334)
+  end
+
+  it "should allow to compare two expressions by using '<'" do
+    eval("(1 < 1)").should be_false
+    eval("(1 < 2)").should be_true
+    eval("(2 < 1)").should be_false
+    
+    eval("2.0 < 1.999999999").should         == (2.0 < 1.999999999)
+    eval("2.0 < 2.000000001").should         == (2.0 < 2.000000001)
+    eval("1.333333333 < 1.333333332").should == (1.333333333 < 1.333333332)
+    eval("1.333333333 < 1.333333333").should == (1.333333333 < 1.333333333)
+    eval("1.333333333 < 1.333333334").should == (1.333333333 < 1.333333334)
+  end
+
+  it "should allow to compare two expressions by using '>'" do
+    eval("(1 > 1)").should be_false
+    eval("(2 > 1)").should be_true
+    eval("(1 > 2)").should be_false
+    
+    eval("2.0 > 1.999999999").should         == (2.0 > 1.999999999)
+    eval("2.0 > 2.000000001").should         == (2.0 > 2.000000001)
+    eval("1.333333333 > 1.333333332").should == (1.333333333 > 1.333333332)
+    eval("1.333333333 > 1.333333333").should == (1.333333333 > 1.333333333)
+    eval("1.333333333 > 1.333333334").should == (1.333333333 > 1.333333334)
+  end
+
+  it "should allow to compare two expressions by using '<='" do
+    eval("(1 <= 1)").should be_true
+    eval("(1 <= 2)").should be_true
+    eval("(2 <= 1)").should be_false
+    
+    eval("2.0 <= 1.999999999").should         == (2.0 <= 1.999999999)
+    eval("2.0 <= 2.000000001").should         == (2.0 <= 2.000000001)
+    eval("1.333333333 <= 1.333333332").should == (1.333333333 <= 1.333333332)
+    eval("1.333333333 <= 1.333333333").should == (1.333333333 <= 1.333333333)
+    eval("1.333333333 <= 1.333333334").should == (1.333333333 <= 1.333333334)
+  end
+
+  it "should allow to compare two expressions by using '>='" do
+    eval("(1 >= 1)").should be_true
+    eval("(2 >= 1)").should be_true
+    eval("(1 >= 2)").should be_false
+    
+    eval("2.0 >= 1.999999999").should         == (2.0 >= 1.999999999)
+    eval("2.0 >= 2.000000001").should         == (2.0 >= 2.000000001)
+    eval("1.333333333 >= 1.333333332").should == (1.333333333 >= 1.333333332)
+    eval("1.333333333 >= 1.333333333").should == (1.333333333 >= 1.333333333)
+    eval("1.333333333 >= 1.333333334").should == (1.333333333 >= 1.333333334)
+  end
+  
+end

data/spec/trxl/builtins_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe "The language" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should allow to access the current environment by calling ENV" do
+    env = eval("ENV", {})
+    env.should be_kind_of(Trxl::Environment)
+    env.should be_empty
+    
+    env = eval("ENV", { :a => 1, :b => 2 })
+    env.should be_kind_of(Trxl::Environment)
+    env.should have_key(:a)
+    env.should have_key(:b)
+    env[:a].should == 1
+    env[:b].should == 2
+  end
+
+  it "should allow to access variables by name by calling ENV['foo']" do
+    eval("ENV['a']", {}).should == nil
+    eval("ENV['a']", { :a => 1 }).should == 1
+    eval("ENV['a']", { :a => "yes" }).should == "yes"
+    eval("ENV['a']", { :a => [ 1, 2, 3 ] }).should == [ 1, 2, 3 ]
+  end
+
+  it "should allow to access ranges in the current environment by calling ENV['a'..'z']" do
+    eval("ENV['a'..'a']", { :a => 1, :b => 2, :c => 3 }).should == [ 1 ]
+    eval("ENV['a'..'b']", { :a => 1, :b => 2, :c => 3 }).should include(1)
+    eval("ENV['a'..'b']", { :a => 1, :b => 2, :c => 3 }).should include(2)
+    eval("ENV['a'..'c']", { :a => 1, :b => 2, :c => 3 }).should include(1)
+    eval("ENV['a'..'c']", { :a => 1, :b => 2, :c => 3 }).should include(2)
+    eval("ENV['a'..'c']", { :a => 1, :b => 2, :c => 3 }).should include(3)
+  end
+  
+  it "should be able to PRINT and PRINT_LINE to STDOUT" do
+    eval("PRINT('- This is output from PRINT. ')").should be_nil
+    eval("PRINT_LINE('And this is output from PRINT_LINE')").should be_nil
+  end
+  
+  it "should be able to split strings by calling SPLIT(some_string, split_char)" do
+    eval("SPLIT('foo/bar', '/')").should == [ 'foo', 'bar' ]
+  end
+  
+  it "should be able to convert values into integers by calling TO_INT(alpha_numeric_string)" do
+    eval("TO_INT('1')").should == 1
+  end
+  
+  it "should be able to convert values into floats by calling TO_FLOAT(alpha_numeric_string)" do
+    eval("TO_FLOAT('1.12')").should == 1.12
+  end
+  
+  it "should be able to convert values into arrays by calling TO_ARRAY(some_value)" do
+    eval("TO_ARRAY(1)").should == [ 1 ]
+    eval("TO_ARRAY('1')").should == [ '1' ]
+    eval("TO_ARRAY([1])").should == [ 1 ]
+    eval("TO_ARRAY({ 1 => 2 })").should == [ [1, 2] ]
+    eval("TO_ARRAY({ 1 => 2, 3 => 4 })").should == [ [1, 2], [3, 4] ]
+  end
+
+  it "should be able to round numbers to a given number of decimal places by calling ROUND(num, digits)" do
+    program =  "ROUND(1.2222,0)"
+    eval(program).should == 1
+    program =  "ROUND(1.6666,0)"
+    eval(program).should == 2
+    program =  "ROUND(1.2222,1)"
+    eval(program).should == 1.2
+    program =  "ROUND(1.2222,2)"
+    eval(program).should == 1.22
+    program =  "ROUND(1.2782,2)"
+    eval(program).should == 1.28
+    program =  "ROUND(fun(){1.1234567}(),4)"
+    eval(program).should == 1.1235
+    program =  "ROUND(NULL,2)"
+    eval(program).should be_nil
+    program =  "ROUND(FALSE,2)"
+    eval(program).should be_nil
+    program =  "ROUND(TRUE,2)"
+    eval(program).should be_nil
+  end
+
+  it "should be able to calculate SUM for an arbitrary number of argument expressions" do
+    program = "SUM()"
+    eval(program).should == 0
+    program = "SUM(NULL)"
+    eval(program).should == 0
+    program = "SUM(0)"
+    eval(program).should == 0
+    program = "SUM(1)"
+    eval(program).should == 1
+    program = "SUM(1,2,3,4)"
+    eval(program).should == 10
+    program = "SUM(1,2,3,NULL)"
+    eval(program).should == 6
+    program = "SUM(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
+    eval(program).should == 12
+    program = "SUM(x)"
+    eval(program, { :x => [ 1, 2, 3 ] }).should == 6
+    
+    program =  "SUM([2,2,2],[4,4,4],[3,3,3])"
+    eval(program).should == 27
+    
+    program =  "SUM([ [2,2,2], [4,4,4], [3,3,3] ])"
+    eval(program).should == 27
+  end
+  
+  it "should be able to calculate MULT for an arbitrary number of argument expressions" do
+    program =  "MULT()"
+    eval(program).should == 0
+    program =  "MULT(NULL)"
+    eval(program).should == 0
+    program =  "MULT(0)"
+    eval(program).should == 0
+    program =  "MULT(1)"
+    eval(program).should == 1
+    program =  "MULT(1,2,3,4)"
+    eval(program).should == 24
+    program =  "MULT(1,2,3,NULL)"
+    eval(program).should == 6
+    program =  "MULT(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
+    eval(program).should == 64
+    program = "MULT(x)"
+    eval(program, { :x => [ 1, 2, 3 ] }).should == 6
+  end
+  
+  it "should be able to calculate AVG for an arbitrary number of argument expressions" do
+    program =  "AVG()"
+    eval(program).should == 0
+    program =  "AVG(NULL)"
+    eval(program).should be_nil
+    program =  "AVG(0)"
+    eval(program).should == 0
+    program =  "AVG(1)"
+    eval(program).should == 1
+    program =  "AVG(3,3,3)"
+    eval(program).should == 3
+    program =  "AVG(3,3,3)"
+    eval(program).should == 3
+    program =  "AVG(3,5,0)"
+    eval(program).should be_close(2.66666666666, 0.01)
+    program =  "AVG(FALSE, 3,5,0)"
+    eval(program).should == 4
+    program =  "AVG(TRUE, 3,5,0)"
+    eval(program).should be_close(2.66666666666, 0.01)
+    program =  "AVG(3,NULL,3)"
+    eval(program).should == 3
+    program =  "AVG(3.3,3.3,3.3)"
+    eval(program).should be_close(3.3, 0.01)
+    program =  "AVG(3,5,4)"
+    eval(program).should == 4
+    program =  "AVG(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
+    eval(program).should == 4
+    
+    program =  "AVG([1,2,3],[4,4,4],[6,6,6])"
+    eval(program).should == 4
+    program =  "AVG([2,2],[4,4,4],[6,6])"
+    eval(program).should == 4
+  end
+  
+  it "should be able to calculate AVG_SUM for an arbitrary number of argument expressions" do
+    program =  "AVG_SUM([1,2,3],[4,4,4],[6,6,6])"
+    eval(program).should == 12
+    program =  "AVG_SUM([2,2],[4,4,4],[6,6])"
+    eval(program).should == 12
+    
+    env = {
+      :ap => [138542.0, 136795.0, 134256.0], # 136531
+      :aq => [124580.0, 21458.0, 34560.0],   #  60199.3333333333
+      :ar => [1200.0, 1200.0, 1200.0],       #   1200
+      :as => [1235.0, 1265.0, 5620.0],       #   2706.66666666667
+      :at => [5201.0, 4263.0, 8452.0],       #   5972
+      :au => [250.0, 250.0, 250.0]           #    250
+                                             # ------------------
+                                             # 206859
+                                             
+    }
+    eval("AVG_SUM(ENV['ap'..'au'])", env).should == 206859
+    
+    env = {
+      :ap => [138542.0, 136795.0, 134256.0], # 136531
+      :aq => [124580.0, 21458.0, 34560.0],   #  60199.3333333333
+      :ar => [1200.0, 1200.0, 1200.0],       #   1200
+      :as => [1235.0, 1265.0, 5620.0],       #   2706.66666666667
+      :at => [5201.0, 4263.0, 8452.0],       #   5972
+      :au => [0, 0, 0]                       #      0
+                                             # ------------------
+                                             # 206609
+                                             
+    }
+    eval("AVG_SUM(ENV['ap'..'au'])", env).should == 206609
+    
+  end
+
+  it "should be able to calculate MIN for an arbitrary number of argument expressions" do
+    program =  "MIN()"
+    eval(program).should == 0
+    program =  "MIN(0)"
+    eval(program).should == 0
+    program =  "MIN(1)"
+    eval(program).should == 1
+    program =  "MIN(1,2,3)"
+    eval(program).should == 1
+    program =  "MIN(1.0, 2.0, 3.0)"
+    eval(program).should == 1.0
+    program =  "MIN(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
+    eval(program).should == 4
+  end
+
+  it "should be able to calculate MAX for an arbitrary number of argument expressions" do
+    program =  "MAX()"
+    eval(program).should == 0
+    program =  "MAX(0)"
+    eval(program).should == 0
+    program =  "MAX(1)"
+    eval(program).should == 1
+    program =  "MAX(1,2,3)"
+    eval(program).should == 3
+    program =  "MAX(1.0, 2.0, 3.0)"
+    eval(program).should == 3.0
+    program =  "MAX(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
+    eval(program).should == 4
+  end
+  
+  it "should be able to map all hash ids that match a given value by calling MATCHING_IDS" do
+    env = { :foo => { :a => "bar", :b => "bar", :c => "baz" } }
+    eval("MATCHING_IDS('bar', foo)", env).should include(:a)
+    eval("MATCHING_IDS('bar', foo)", env).should include(:b)
+    eval("MATCHING_IDS('baz', foo)", env).should == [ :c ]
+    eval("MATCHING_IDS('bam', foo)", env).should == []
+  end
+  
+  it "should define a VALUES_OF_TYPE function" do
+    env = { 
+      :all_types => { :a => "bar", :b => "bar", :c => "baz" },
+      :all_values => { :a => 100, :b => 200, :c => 300 }
+    }
+    eval("VALUES_OF_TYPE('bar', all_types, all_values)", env).should include(100)
+    eval("VALUES_OF_TYPE('bar', all_types, all_values)", env).should include(200)
+    eval("VALUES_OF_TYPE('baz', all_types, all_values)", env).should == [ 300 ]
+    eval("VALUES_OF_TYPE('bam', all_types, all_values)", env).should == []
+
+    env = { 
+      :all_types => { :a => "bar", :b => "bar", :c => "baz" },
+      :all_values => { :a => [100,200,300], :b => [400,500,600], :c => [700,800,900] }
+    }
+    eval("VALUES_OF_TYPE('bar', all_types, all_values)", env).should include([100,200,300])
+    eval("VALUES_OF_TYPE('bar', all_types, all_values)", env).should include([400,500,600])
+    eval("VALUES_OF_TYPE('baz', all_types, all_values)", env).should == [ [700,800,900] ]
+    eval("VALUES_OF_TYPE('bam', all_types, all_values)", env).should == []
+
+    env = { 
+      :all_types => { :a => "bar", :b => "bar", :c => "baz" },
+      :all_values => []
+    }
+    lambda { eval("VALUES_OF_TYPE('bar', all_types, all_values)", env) }.should raise_error(Trxl::InvalidArgumentException)
+    
+    env = { 
+      :all_types => [],
+      :all_values => { :a => [100,200,300], :b => [400,500,600], :c => [700,800,900] }
+    }
+    lambda { eval("VALUES_OF_TYPE('bar', all_types, all_values)", env) }.should raise_error(Trxl::InvalidArgumentException)
+  end
+  
+end

data/spec/trxl/closures_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+describe "For defining closures, the language" do
+  
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+
+  it "should parse lambdas with no parameters" do
+    parse("fun() {1}").eval.to_s.should == "fun() {1}"
+  end
+
+  it "should parse lambdas with one parameter" do
+    parse("fun(x) {x}").eval.to_s.should == "fun(x) {x}"
+  end
+
+  it "should parse lambdas with multiple parameters" do
+    parse("fun(x,y) {x + y}").eval.to_s.should == "fun(x,y) {x + y}" 
+  end
+  
+  it "should parse lambdas that return another lambda" do
+    program =  "fun(x) {fun(y) {x + y}}(5)"
+    eval(program).to_s.should == "fun(y) {x + y}"
+  end
+  
+
+  it "should be able to apply lambdas with no parameters" do
+    parse("fun() {2 * 2} ()").eval.should == 4
+  end
+
+  it "should be able to apply lambdas with one parameter" do
+    parse("fun(x) {x} (1)").eval.should == 1
+  end
+
+  it "should be able to apply lambdas with multiple parameters" do
+    parse("fun(x,y) {x + y} (5,5)").eval.should == 10
+  end
+
+  it "should be able to store lambdas in a variable and apply them later" do
+    eval("a = fun(x,y) {x + y}; a(5,5);").should == 10
+  end
+
+  it "should be able to return closures, store them in variables and apply them later" do
+    program  = "foo = 2;"
+    program << "adder = fun(x) {fun(y) {x + y}}(5);"
+    program << "adder(2);"
+    eval(program).should == 7
+  end
+
+  it "should have read access to the enclosing scope in closures" do
+    program =  "a = 1;"
+    program << "fun(){a}();"
+    eval(program).should == 1
+  end
+  
+  it "should have write access to the enclosing scope in closures" do
+    program =  "a = 0;"
+    program << "fun(x){a = x}(1);"
+    program << "a;"
+    eval(program).should == 1
+
+    program = <<-PROGRAM
+    foo = fun() {
+      a = 0;
+      fun(y) { a = y }(1);
+      a;
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 1
+  end
+
+
+  it "should allow multiple statements in a function body" do
+    program = <<-PROGRAM
+    foo = fun(x) {
+      a = 3;
+      x + a;
+    };
+    foo(3)
+    PROGRAM
+    eval(program).should == 6
+  end
+
+  it "should be able to perform arithmetics in function bodies" do
+    eval("fun(x,y) {x+y} (5,5)").should == 10
+    eval("fun(x,y) {x-y} (5,5)").should == 0
+    eval("fun(x,y) {x*y} (5,5)").should == 25
+    eval("fun(x,y) {x/y} (10,5)").should == 2
+    eval("fun(x,y) {x%y} (10,2)").should == 0
+    
+    eval("fun(x,y) {x+y*3} (5,5)").should == 20
+    eval("fun(x,y) {(x-y)*3} (5,5)").should == 0
+    eval("fun(x,y) {(x*y)+5} (5,5)").should == 30
+    eval("fun(x,y) {x/(y-3)} (10,5)").should == 5
+    eval("fun(x,y) {(x+y)%2} (10,2)").should == 0
+  end
+
+  it "should be able to perform recursive calls" do
+    program =  <<-PROGRAM
+      fact = fun(x) { if(x == 0) 1 else fact(x - 1) * x end};
+      fact(5);
+    PROGRAM
+    eval(program).should == 5*4*3*2*1
+  end
+
+  
+  it "should allow nested applications of recursive functions" do
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      inject(0, [[1,2],[3,4]], fun(m, arr) {
+        m + inject(0, arr, fun(sum, v) {
+          sum + v
+        })
+      })
+    PROGRAM
+    lambda { eval(program).should == 10 }.should_not raise_error
+  end
+
+  it "should evaluate actual parameters that are function applications" do
+    program =  "a = 5;"
+    program << "b = 10;"
+    program << "sum = fun(x,y) {x + y};"
+    program << "div = fun(x,y) {x / y};"
+    program << "div(sum(a,b),a);"
+    eval(program).should == 3
+  end
+
+  it "should be able to apply previously defined closures inside function bodies" do
+    program =  "a = 5;"
+    program << "b = 10;"
+    program << "sum = fun(x,y) {x + y};"
+    program << "foo = fun(x,y) {sum(x,y)};"
+    program << "foo(a,b);"
+    eval(program).should == 15
+  end
+  
+  it "should perform left associative chained applications" do
+    program = "fun(x) {fun(y) {x + y}}(5)(5);"
+    eval(program).should == 10
+    program = "fun(a,b) {fun(c,d) {a * b + c * d}}(5,5)(5,5);"
+    eval(program).should == 50
+    program =  "sum = fun(x,y) {x + y};"
+    program << "fun(a,b) {fun(c,d) {a * b + c * d}}(sum(5,5),sum(5,5))(5,5);"
+    eval(program).should == 125
+    program =  "sum = fun(x,y) {x + y};"
+    program << "mult = fun(x,y) {x * y};"
+    program << "fun(a,b) {fun(c,d) {a * b + c * d}}(sum(mult(5,5),5),sum(5,5))(sum(5,5),mult(5,5));"
+    eval(program).should == 550
+  end
+
+  it "should be able to use function applications as left operand in binary operations" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "sum(2,2) + 1"
+    eval(program).should == 5
+  end
+
+  it "should be able to use function applications as right operand in binary operations" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "1 + sum(2,2);"
+    eval(program).should == 5
+  end
+
+  it "should be able to use function applications as operands in binary operations" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "sum(1,2) + sum(3,4)"
+    eval(program).should == 10
+  end
+
+  it "should be able to use function applications as left operands in binary expressions inside function bodies" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "foo = fun(x,y) {sum(x,y) + x};"
+    program << "foo(5,10);"
+    eval(program).should == 20
+  end
+
+  it "should be able to use function applications as right operands in binary expressions inside function bodies" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "foo = fun(x,y) {x + sum(x,y)};"
+    program << "foo(5,10);"
+    eval(program).should == 20
+  end
+
+  it "should be able to use function applications as operands in binary expressions inside function bodies" do
+    program =  "sum = fun(x,y) {x + y};"
+    program << "foo = fun(x,y) {sum(x,y) + sum(x,y)};"
+    program << "foo(5,10);"
+    eval(program).should == 30
+  end
+
+  it "should be able to use predefined function applications as operands in binary expressions" do
+    program =  "AVG(10,15,20) / AVG(3,3,3)"
+    eval(program).should == 5
+  end
+
+  it "should be able to use predefined function applications as operands in binary expressions acting as actual parameters to another predefined function" do
+    program =  "ROUND( AVG(10,15,20) / AVG(3,3,3) , 2 )"
+    eval(program).should == 5
+  end
+
+  it "should be able to use predefined and regular function applications as operands in binary expressions acting as a parameter to another predefined function" do
+    program =  "ROUND( AVG(fun(x){x}(10),15,fun(x,y){x+y}(10,10)) / AVG(fun(x){x}(3),3,fun(x,y){x+y}(1,2)) , 2 )"
+    eval(program).should == 5
+  end
+
+  it "should have the arguments variable available in function bodies" do
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      sum = fun() { inject(0, arguments, fun(memo, i) { memo + i }); };
+      sum(1,2,3,4,5);
+    PROGRAM
+    eval(program).should == 15
+    
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      sum = fun(x,y) { inject(0, arguments, fun(memo, i) { memo + i }); };
+      sum(1,2);
+    PROGRAM
+    eval(program).should == 3
+    
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      sum = fun(x,y) { inject(0, arguments, fun(memo, i) { memo + i }); };
+      sum(1,2,3,4,5);
+    PROGRAM
+    eval(program).should == 15
+    
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      sum = fun(x,y,z) { inject(0, arguments, fun(memo, i) { memo + i }); };
+      sum(1,2);
+    PROGRAM
+    lambda { eval(program) }.should raise_error(Trxl::WrongNumberOfArgumentsException)
+    
+    begin
+      eval(program)
+    rescue Trxl::WrongNumberOfArgumentsException => e
+      e.message.should == "2 instead of 3"
+    end
+  end
+  
+end