shen-ruby 0.3.1 → 0.4.0

data/.gitignore

@@ -2,3 +2,5 @@
 .idea
 *.gem
 *.iml
+.rbx
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-nightly-19mode

data/Gemfile

@@ -1,6 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
 group :development do
+  gem 'rake', '~> 0.9'
   gem 'rspec', '~> 2.12.0'
-  gem 'ZenTest', '~> 4.8.3'
 end

data/HISTORY.md

@@ -1,5 +1,17 @@
 # ShenRuby Release History
 
+## 0.4.0 - March 15, 2013
+### Features
+- Upgrade to Shen 9.0
+### Bug Fixes
+- [Issue 8](https://github.com/gregspurrier/shen-ruby/issues/8) -- `quit` no longer raises a type error when invoked with type checking enabled.
+- Fixed many instances of ShenRuby's behavior not matching the Shen CLisp reference implementation:
+  - `absvector`, `address->`, `<-address`, `intern`, `n->string`, `pos`, `string->n`, and `tlstr` now throw errors catchable by `trap-error` when type violations occur with their arguments.
+  - `tlstr` now raises an error when applied to an empty string
+  - `set` and `value` now require their first arugment to be a symbol
+  - `hd` and `tl` now raise an error when applied to non-lists
+  - `freeze` now supports partial application with zero arguments
+
 ## 0.3.1 - January 24, 2013
 - No code changes. Updates Gemspec to refer to Shen 8.0.
 

data/README.md

@@ -1,7 +1,7 @@
 # ShenRuby
 ShenRuby is a Ruby port of the [Shen](http://shenlanguage.org/) programming language. Shen is a modern, functional Lisp that supports pattern matching, currying, and optional static type checking.
 
-ShenRuby supports Shen version 8.0, which was released in January, 2013.
+ShenRuby supports Shen version 9.0, which was released in March, 2013.
 
 The ShenRuby project has two primary goals. The first is to be a low barrier-to-entry means for Rubyists to explore Shen. To someone with a working installation of Ruby 1.9.3, a Shen REPL is only a gem install away.
 
@@ -9,10 +9,12 @@ Second, ShenRuby aims to enable hybrid applications implemented using a combinat
 
 ShenRuby 0.1.0 began to satisfy the first goal by providing a Shen REPL accessible from the command line. The second goal is more ambitious and is the subject of ongoing work beginning with the 0.2.0 release and leading up to the eventual 1.0.0 release.
 
+[![Build Status](https://travis-ci.org/gregspurrier/shen-ruby.png)](https://travis-ci.org/gregspurrier/shen-ruby)
+
 ## Installation
-NOTE: ShenRuby requires Ruby 1.9 language features. It has been tested with Ruby 1.9.3-p362. It is not yet working under JRuby or Rubinius.
+NOTE: ShenRuby requires Ruby 1.9 language features. It has been tested with Ruby 1.9.3-p392. It has been lightly tested with Rubinius 2.0.0-head running in 1.9 mode. It is not yet working under JRuby.
 
-ShenRuby 0.3.1 is the current release. To install it as gem, use the following command:
+ShenRuby 0.4.0 is the current release. To install it as gem, use the following command:
 
     gem install shen-ruby
 
@@ -24,9 +26,9 @@ Once the gem has been installed, the Shen REPL can be launched via the `srrepl`
     Loading.... Completed in 10.29 seconds.
     
     Shen 2010, copyright (C) 2010 Mark Tarver
-    www.shenlanguage.org, version 8
+    www.shenlanguage.org, version 9
     running under Ruby, implementation: ruby 1.9.3
-    port 0.3.1 ported by Greg Spurrier
+    port 0.4.0 ported by Greg Spurrier
     
     
     (0-) 
@@ -137,7 +139,7 @@ The following resources may be helpful for those wanting to learn more about the
 - [Learn Shen](http://www.shenlanguage.org/learn-shen/index.html) -- The Shen Website's suggested resources for--and approaches to--learning Shen, including the [Shen in 15 Minutes](http://www.shenlanguage.org/learn-shen/tutorials/shen_in_15mins.html) tutorial for experienced functional programmers.
 - [The Shen Official Standard](http://www.shenlanguage.org/Documentation/shendoc.htm)
 - [System Functions and their Types in Shen](http://www.shenlanguage.org/learn-shen/system.pdf) -- A reference for all of the standard Shen functions and their types.
-- [The Book of Shen](http://www.shenlanguage.org/tbos.html) -- The official guide to the Shen programming language. The first printing quickly sold out, but another printing is expected in January, 2013. See this [discussion](https://groups.google.com/d/topic/qilang/V8so3Rirkk0/discussion) on the Shen News Group for the most up-to-date information.
+- [The Book of Shen](http://www.fast-print.net/bookshop/1278/the-book-of-shen) -- The official guide to the Shen programming language.
 - [Shen Google Group](https://groups.google.com/group/qilang?hl=en) -- This is the online forum for discussions related to Shen. Don't be confused by the group's name (Qilang). Qi was the predecessor of Shen and the group retains its name.
 
 ## Road Map to 1.0
@@ -156,8 +158,9 @@ The following features and improvements are among those planned for ShenRuby as
 - ShenRuby fails to load under JRuby ([Issue #6](https://github.com/gregspurrier/shen-ruby/issues/6)) and Rubinius ([Issue #])(https://github.com/gregspurrier/shen-ruby/issues/7)].
 
 ## Contributors
-The following people are gratefully acknowledged for their contributions of code to ShenRuby:
+The following people are gratefully acknowledged for their contributions to ShenRuby:
 
+- Brian Shirai
 - Bruno Deferrari
 
 ## License

data/Rakefile

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'rspec/core/rake_task'
+
+SHENRUBY_ROOT = File.expand_path(File.dirname(__FILE__))
+
+# Run implementation specs
+RSpec::Core::RakeTask.new(:spec)
+
+# Run K Lambda specs
+RSpec::Core::RakeTask.new(:k_lambda_spec) do |t|
+  t.rspec_opts = '-I k_lambda_spec'
+  t.pattern = 'k_lambda_spec/**/*_spec.rb'
+end
+
+# Import Shen Release
+RELEASE_DIR = File.join(SHENRUBY_ROOT, 'shen/release')
+IMPORT_DIR = File.join(SHENRUBY_ROOT, 'import')
+SHEN_ZIP = File.join(IMPORT_DIR, 'Shen.zip')
+
+namespace :shen do
+  namespace :import do
+    task :release => [:remove_old_release, :import_dirs, :cleanup]
+    task :import_dirs => [:k_lambda, :test_programs, :benchmarks]
+
+    task :remove_old_release do
+      rm_rf IMPORT_DIR
+      rm_rf RELEASE_DIR
+    end
+
+    task :cleanup do
+      rm_r IMPORT_DIR
+    end
+
+    directory IMPORT_DIR
+    directory RELEASE_DIR
+
+    file SHEN_ZIP => [IMPORT_DIR] do
+      sh "curl -s http://www.shenlanguage.org/Download/Shen.zip > '#{SHEN_ZIP}'"
+    end
+
+    task :unzip => SHEN_ZIP do
+      sh "(cd #{IMPORT_DIR}; unzip Shen.zip)"
+    end
+
+    def dst_path(src_root, src_path, dst_root)
+      path_tail = src_path[src_root.length..-1]
+      File.join(dst_root, path_tail.gsub(/[\s ']/, '_'))
+    end
+
+    def import_dir(dirname)
+      src_root = Dir.glob(File.join('import/Shen *', dirname)).first
+      dst_root = File.join(RELEASE_DIR, dirname.downcase.gsub(/\s/, '_'))
+
+      src_paths = Dir.glob(File.join(src_root, '**/*'))
+      src_dirs, src_files = src_paths.partition { |p| File.directory?(p) }
+      
+      mkdir_p dst_root
+      src_dirs.each { |dir| mkdir_p dst_path(src_root, dir, dst_root) }
+      src_files.each { |file| cp file, dst_path(src_root, file, dst_root) }
+    end
+
+    def fix_load_paths(path)
+      lines = File.readlines(path)
+      File.open(path, 'w') do |f|
+        lines.each do |l|
+          if l =~ /\(load\s+"([^"]+)"\)/
+            path = $1
+            new_path = path.gsub(/[\s']/, '_')
+            l.sub!(path, new_path)
+          end
+          f.puts l
+        end
+      end
+    end
+    
+    task :k_lambda => [:unzip, RELEASE_DIR] do
+      import_dir('K Lambda')
+    end
+
+    task :test_programs => [:unzip, RELEASE_DIR] do
+      import_dir('Test Programs')
+      fix_load_paths(File.join(RELEASE_DIR, 'test_programs/tests.shen'))
+    end
+
+    task :benchmarks => [:unzip, RELEASE_DIR] do
+      import_dir('Benchmarks')
+      fix_load_paths(File.join(RELEASE_DIR, 'benchmarks/benchmarks.shen'))
+    end
+  end
+end
+
+task :default => [:spec, :k_lambda_spec]

data/bin/srrepl

@@ -23,7 +23,7 @@ class ReplInterrupt < StandardError; end
 Signal.trap("INT") { raise ReplInterrupt }
 
 # Launch the REPL
-command = :"shen-shen"
+command = :"shen.shen"
 begin
   shen.__eval(Kl::Cons.list([command]))
 rescue StandardError => e
@@ -35,6 +35,6 @@ rescue StandardError => e
   else
     puts "Ruby exception: #{e.message}"
   end
-  command = :"shen-loop"
+  command = :"shen.loop"
   retry
 end

data/k_lambda_spec/primitives/arithmetic_spec.rb

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,44 @@
+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/generic_functions_spec.rb

@@ -1,7 +1,120 @@
 require 'spec_helper'
 
 describe 'Primitives for Generic Functions' do
-  describe 'freeze' do
-    # Should the frozen result be re-evaluated on each thaw?
+  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