shen-ruby 0.10.0 → 0.11.0

data/k_lambda_spec/atom_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe 'Atoms:' do
-  describe 'a string' do
-    it 'is self-evaluating' do
-      kl_eval('"string"').should == 'string'
-    end
-  end
-
-  describe 'a symbol' do
-    it 'is self-evaluating' do
-      kl_eval('symbol').should == :symbol
-    end
-
-    it 'may include any of the legal characters for symbol' do
-      # See http://www.shenlanguage.org/documentation/shendoc.htm#The%20Syntax%20of%20Symbols
-      all_legal_chars = 'abcdefghijklmnopqrstuvwxyz' +
-          'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
-          '0123456789' +
-          '=-*/+_?$!@~.><&%\'#`;:{}'
-      kl_eval(all_legal_chars).should == all_legal_chars.to_sym
-    end
-
-    it 'may begin with any legal character other than a digit' do
-      legal_non_digits = 'abcdefghijklmnopqrstuvwxyz' +
-          'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
-          '=-*/+_?$!@~.><&%\'#`;:{}'
-      legal_non_digits.each_char do |char|
-        kl_eval(char).should == char.to_sym
-      end
-    end
-
-    it 'may not begin with a digit' do
-      digits = '01234567890'
-      digits.each_char do |char|
-        kl_eval(char).should_not be_kind_of Symbol
-      end
-    end
-  end
-
-  describe 'numbers' do
-    it 'parses integers as integers' do
-      result = kl_eval('123')
-      result.should == 123
-      result.should be_kind_of Fixnum
-    end
-
-    it 'parses floating point numbers as reals' do
-      result = kl_eval('12.3')
-      result.should == 12.3
-      result.should be_kind_of Float
-    end
-
-    describe 'with leading sign characters' do
-      it 'recognizes negative numbers' do
-        kl_eval('-123').should == -123
-      end
-
-      it 'treats any odd number of minuses as negative' do
-        kl_eval('---123').should == -123
-      end
-
-      it 'treats any even number of minuses as positive' do
-        kl_eval('----123').should == 123
-      end
-
-      it 'ignores leading plusses' do
-        kl_eval('+123').should == 123
-        kl_eval('--+-123').should == -123
-      end
-    end
-  end
-
-  describe 'true' do
-    it 'evaluates to boolean true rather than a symbol' do
-      kl_eval('true').should == true
-    end
-  end
-
-  describe 'false' do
-    it 'evaluates to boolean false rather than a symbol' do
-      kl_eval('false').should == false
-    end
-  end
-end

data/k_lambda_spec/primitives/arithmetic_spec.rb

@@ -1,175 +0,0 @@
-require 'spec_helper'
-
-describe 'Primitives for Arithmetic' do
-  describe '+' do
-    it 'adds its arguments' do
-      kl_eval('(+ 1 2)').should == 3
-    end
-
-    it 'returns an integer when both arguments are integers' do
-      kl_eval('(+ 1 2)').should be_kind_of Fixnum
-    end
-
-    it ('returns a real when either argument is a real') do
-      kl_eval('(+ 1.0 2)').should be_kind_of Float
-      kl_eval('(+ 1 2.0)').should be_kind_of Float
-    end
-
-    include_examples 'argument types', %w(+ 1 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(+ 1 2)
-    include_examples 'partially-applicable function', %w(+ 1 2)
-  end
-
-  describe '-' do
-    it 'subtracts its second argument from its first' do
-      kl_eval('(- 3 2)').should == 1
-    end
-
-    it 'returns an integer when both arguments are integers' do
-      kl_eval('(- 3 2)').should be_kind_of Fixnum
-    end
-
-    it ('returns a real when either argument is a real') do
-      kl_eval('(- 3.0 2)').should be_kind_of Float
-      kl_eval('(- 3 2.0)').should be_kind_of Float
-    end
-
-    include_examples 'argument types', %w(- 3 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(- 3 2)
-    include_examples 'partially-applicable function', %w(- 3 2)
-  end
-
-  describe '*' do
-    it 'multiplies its arguments' do
-      kl_eval('(* 2 3)').should == 6
-    end
-
-    it 'returns an integer when both arguments are integers' do
-      kl_eval('(* 2 3)').should be_kind_of Fixnum
-    end
-
-    it ('returns a real when either argument is a real') do
-      kl_eval('(* 2.0 3)').should be_kind_of Float
-      kl_eval('(* 2 3.0)').should be_kind_of Float
-    end
-
-    include_examples 'argument types', %w(* 2 3),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(* 2 3)
-    include_examples 'partially-applicable function', %w(* 2 3)
-  end
-
-  describe '/' do
-    it 'divides its first argument by its second argument' do
-      kl_eval('(/ 6 3)').should == 2
-    end
-
-    it 'returns an integer when an integer evenly divides another integer' do
-      kl_eval('(/ 6 3)').should be_kind_of Fixnum
-    end
-
-    it 'returns a real when an integer does not evenly divide another integer' do
-      kl_eval('(/ 4 3)').should be_kind_of Float
-    end
-
-    it ('returns a real when either argument is a real') do
-      kl_eval('(/ 6.0 3)').should be_kind_of Float
-      kl_eval('(/ 6 3.0)').should be_kind_of Float
-    end
-
-    include_examples 'argument types', %w(/ 6 3),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(/ 6 3)
-    include_examples 'partially-applicable function', %w(/ 6 3)
-  end
-
-  describe '>' do
-    it 'returns false if its first argument is less than its second argument' do
-      kl_eval('(> 1 2)').should == false
-    end
-
-    it 'returns false if its first argument is equal to its second argument' do
-      kl_eval('(> 2 2)').should == false
-    end
-
-    it 'returns true if its first argument is greater than its second argument' do
-      kl_eval('(> 3 2)').should == true
-    end
-
-    include_examples 'argument types', %w(> 1 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(> 1 2)
-    include_examples 'partially-applicable function', %w(> 1 2)
-  end
-
-  describe '<' do
-    it 'returns true if its first argument is less than its second argument' do
-      kl_eval('(< 1 2)').should == true
-    end
-
-    it 'returns false if its first argument is equal to its second argument' do
-      kl_eval('(< 2 2)').should == false
-    end
-
-    it 'returns false if its first argument is greater than its second argument' do
-      kl_eval('(< 3 2)').should == false
-    end
-
-    include_examples 'argument types', %w(< 1 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(> 1 2)
-    include_examples 'partially-applicable function', %w(> 1 2)
-  end
-
-  describe '>=' do
-    it 'returns false if its first argument is less than its second argument' do
-      kl_eval('(>= 1 2)').should == false
-    end
-
-    it 'returns true if its first argument is equal to its second argument' do
-      kl_eval('(>= 2 2)').should == true
-    end
-
-    it 'returns true if its first argument is greater than its second argument' do
-      kl_eval('(>= 3 2)').should == true
-    end
-
-    include_examples 'argument types', %w(>= 1 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(> 1 2)
-    include_examples 'partially-applicable function', %w(> 1 2)
-  end
-
-  describe '<=' do
-    it 'returns true if its first argument is less than its second argument' do
-      kl_eval('(<= 1 2)').should == true
-    end
-
-    it 'returns true if its first argument is equal to its second argument' do
-      kl_eval('(<= 2 2)').should == true
-    end
-
-    it 'returns false if its first argument is greater than its second argument' do
-      kl_eval('(<= 3 2)').should == false
-    end
-
-    include_examples 'argument types', %w(<= 1 2),
-                     1 => [:integer, :real],
-                     2 => [:integer, :real]
-    include_examples 'applicative order evaluation', %w(> 1 2)
-    include_examples 'partially-applicable function', %w(> 1 2)
-  end
-
-  describe 'number?' do
-    include_examples 'type predicate', 'number?', [:integer, :real]
-  end
-end

data/k_lambda_spec/primitives/assignments_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe 'Primitives for assignment' do
-  describe '(set Name Value)' do
-    it 'associates Value with Name' do
-      kl_eval('(set foo bar)')
-      kl_eval('(value foo)').should == :bar
-    end
-
-    it 'returns Value' do
-      kl_eval('(set foo bar)').should == :bar
-    end
-
-    it 'overwrites the previous value when called again with same Name' do
-      kl_eval('(set foo bar)')
-      kl_eval('(set foo baz)').should == :baz
-    end
-
-    include_examples 'argument types', %w(set foo bar), 1 => [:symbol]
-    include_examples 'partially-applicable function', %w(set foo bar)
-    include_examples 'applicative order evaluation', %w(set foo bar)
-  end
-
-  describe '(value Name)' do
-    before(:each) do
-      # a-symbol is the example symbol used by the argument type specs.
-      # Set it so that they do not throw and unset variable error.
-      kl_eval('(set a-symbol bar)')
-    end
-
-    it 'returns the value associated with Name' do
-      kl_eval('(value a-symbol)').should == :bar
-    end
-
-    it 'raises an error if Name has not previously been set' do
-      expect {
-        kl_eval('(value baz)')
-      }.to raise_error(Kl::Error, 'variable baz has no value')
-    end
-
-    include_examples 'argument types', %w(value a-symbol), 1 => [:symbol]
-    include_examples 'partially-applicable function', %w(value a-symbol)
-  end
-end

data/k_lambda_spec/primitives/boolean_operations_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-describe 'Primitives for Boolean Operations' do
-  describe 'if special form' do
-    include_examples "partially-applicable function", %w(if true a b)
-
-    it 'evaluates its first argument' do
-      define_kl_do
-      kl_eval('(set flag clear)')
-      kl_eval('(if (kl-do (set flag set) true) a b)')
-      kl_eval('(value flag)').should == :set
-    end
-
-    describe 'when its first argument evaluates to true' do
-      it 'returns the normal form of its second argument' do
-        kl_eval('(if true (+ 1 2) 10)').should == 3
-      end
-
-      it 'does not evaluate its third argument' do
-        define_kl_do
-        kl_eval('(set flag clear)')
-        kl_eval('(if true 1 (kl-do (set flag set) 2))')
-        kl_eval('(value flag)').should == :clear
-      end
-    end
-
-    describe 'when its first argument evaluates to false' do
-      it 'returns the normal form of its third argument' do
-        kl_eval('(if false 1 (+ 1 2))').should == 3
-      end
-
-      it 'does not evaluate its second argument' do
-        define_kl_do
-        kl_eval('(set flag clear)')
-        kl_eval('(if false (kl-do (set flag set) 1) 2)')
-        kl_eval('(value flag)').should == :clear
-      end
-    end
-  end
-
-  describe 'and special form' do
-    it 'evaluates its first argument' do
-      define_kl_do
-      kl_eval('(set flag clear)')
-      kl_eval('(and (kl-do (set flag set) true) false)')
-      kl_eval('(value flag)').should == :set
-    end
-
-    describe 'when its first argument evaluates to true' do
-      it 'returns true if its second argument evaluates to true' do
-        kl_eval('(defun return-true () true)')
-        kl_eval('(and true (return-true))').should == true
-      end
-
-      it 'returns false if its second argument evaluates to false' do
-        kl_eval('(defun return-false () false)')
-        kl_eval('(and true (return-false))').should == false
-      end
-    end
-
-    describe 'when its first argument evaluates to false' do
-      it 'returns false' do
-        kl_eval('(and false true)').should == false
-      end
-
-      it 'does not evaluate it second argument' do
-        kl_eval('(set flag clear)')
-        kl_eval('(and false (kl-do (set flag set) true))').should == false
-        kl_eval('(value flag)').should == :clear
-      end
-    end
-
-    describe 'partial application' do
-      include_examples "partially-applicable function", %w(and true false)
-
-      it 'results in it no longer short-circuiting argument evaluation' do
-        define_kl_do
-        kl_eval('(set flag clear)')
-        kl_eval('((and false) (kl-do (set flag set) false)))').should == false
-        kl_eval('(value flag)').should == :set
-      end
-    end
-
-    it 'may be passed as an argument to a higher-order function' do
-      kl_eval('((lambda F (F true false)) and)').should == false
-    end
-  end
-
-  describe 'or special form' do
-    it 'evaluates its first argument' do
-      define_kl_do
-      kl_eval('(set flag clear)')
-      kl_eval('(or (kl-do (set flag set) false) false)')
-      kl_eval('(value flag)').should == :set
-    end
-
-    describe 'when its first argument evaluates to false' do
-      it 'returns true if its second argument evaluates to true' do
-        kl_eval('(defun return-true () true)')
-        kl_eval('(or false (return-true))').should == true
-      end
-
-      it 'returns false if its second argument evaluates to false' do
-        kl_eval('(defun return-false () false)')
-        kl_eval('(or false (return-false))').should == false
-      end
-    end
-
-    describe 'when its first argument evaluates to true' do
-      it 'returns true' do
-        kl_eval('(or true false)').should == true
-      end
-
-      it 'does not evaluate it second argument' do
-        kl_eval('(set flag clear)')
-        kl_eval('(or true (kl-do (set flag set) false))').should == true
-        kl_eval('(value flag)').should == :clear
-      end
-    end
-
-    describe 'partial application' do
-      include_examples "partially-applicable function", %w(or false true)
-
-      it 'results in it no longer short-circuiting argument evaluation' do
-        define_kl_do
-        kl_eval('(set flag clear)')
-        kl_eval('((or true) (kl-do (set flag set) false)))').should == true
-        kl_eval('(value flag)').should == :set
-      end
-    end
-
-    it 'may be passed as an argument to a higher-order function' do
-      kl_eval('((lambda F (F true true)) or)').should == true
-    end
-  end
-end

data/k_lambda_spec/primitives/generic_functions_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe 'Primitives for Generic Functions' do
-  describe '(defun Name ArgList Expr)' do
-    it 'does not evaulate Expr' do
-      kl_eval('(set flag clear)')
-      kl_eval('(defun foo () (set flag set))')
-      kl_eval('(value flag)').should == :clear
-    end
-
-    it 'returns Name' do
-      kl_eval('(defun foo () true)').should == :foo
-    end
-
-    it 'binds Name to a function having ArgList as its formals and Expr as its body' do
-      kl_eval('(defun my-add (A B) (+ A B))')
-      kl_eval('(my-add 1 2)').should == 3
-    end
-
-    it 'allows ArgList to be the empty list' do
-      kl_eval('(defun foo () success)').should == :foo
-      kl_eval('(foo)').should == :success
-    end
-
-    it 'allows previously defined non-primitive functions to be redefined' do
-      kl_eval('(defun my-add (A B) (+ A B))')
-      kl_eval('(defun my-add (A B) surprise!)')
-      kl_eval('(my-add 1 2)').should == :surprise!
-    end
-
-    it 'raises an error when attempting to redefine a primitive' do
-      expect {
-        kl_eval('(defun + (A B) :surprise!)')
-      }.to raise_error(Kl::Error, '+ is primitive and may not be redefined')
-    end
-
-    include_examples 'argument types', %w[defun foo () success],
-                     1 => [:symbol]
-
-    it 'raises an error if ArgList is not a list' do
-      expect {
-        kl_eval('(defun foo bar baz)')
-      }.to raise_error(Kl::Error, 'bar is not a list')
-    end
-
-    it 'raises an error if ArgList contains non-symbols' do
-      expect {
-        kl_eval('(defun foo (1) baz)')
-      }.to raise_error(Kl::Error, '1 is not a symbol')
-    end
-    include_examples "non-partially-applicable function",
-      %w[defun foo () success]
-  end
-
-  describe '(lambda X Expr)' do
-    it 'does not evaulate Expr' do
-      kl_eval('(set flag clear)')
-      kl_eval('(lambda X 37)')
-      kl_eval('(value flag)').should == :clear
-    end
-
-    it 'returns a function' do
-      kl_eval('(lambda X 37)').should be_kind_of Proc
-    end 
-
-    describe 'the returned function, when applied' do
-      it 'evaluates Expr with X bound to its argument' do
-        kl_eval('((lambda X (+ 1 X)) 2)').should == 3
-      end
-    end
-
-    include_examples 'argument types', %w(lambda X 37),
-                     1 => [:symbol]
-    include_examples "non-partially-applicable function", %w(lambda X 37)
-  end
-
-  describe '(freeze Expr)' do
-    it 'does not evaluate Expr' do
-      kl_eval('(set flag clear)')
-      kl_eval('(freeze (set flag set))')
-      kl_eval('(value flag)').should == :clear
-    end
-
-    it 'returns a continuation' do
-      kl_eval('(freeze a)').should be_kind_of Proc
-    end
-
-    describe 'the returned continuation, upon thawing' do
-      before(:each) do
-        kl_eval('(defun my-thaw (X) (X))')
-      end
-
-      it 'evaluates and returns the value of Expr' do
-        kl_eval('(my-thaw (freeze (+ 1 2)))').should == 3
-      end
-
-      it 're-evaluates Expr with each thawing' do
-        define_kl_do
-        kl_eval('(set count 0)')
-        kl_eval('(let C (freeze (set count (+ (value count) 1)))
-                      (kl-do (my-thaw C) (my-thaw C)))')
-        kl_eval('(value count)').should == 2
-      end
-    end
-
-    describe 'partial application' do
-      # Can't compare two functions so we implement this manually
-      it 'supports partial application of 0 arguments' do
-        kl_eval('(defun my-thaw (X) (X))')
-        kl_eval('(my-thaw ((freeze) 37))').should == 37
-      end
-
-      it 'results in it no longer delaying execution of Expr' do
-        kl_eval('(set flag clear)')
-        kl_eval('((freeze) (set flag set))').should
-        kl_eval('(value flag)').should == :set
-      end
-    end
-  end
-end