shen-ruby 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+.rvmrc
+.idea
+*.gem
+*.iml

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+group :development do
+  gem 'rspec', '~> 2.12.0'
+  gem 'ZenTest', '~> 4.8.3'
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.8.3)
+    diff-lcs (1.1.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.1)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ZenTest (~> 4.8.3)
+  rspec (~> 2.12.0)

data/MIT_LICENSE.txt

@@ -0,0 +1,26 @@
+This license applies to all of ShenRuby except for the portions found under
+the 'shen' directory, which is subject to its own license.
+
+-----
+
+Copyright (c) 2012 Greg Spurrier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,94 @@
+# 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 7.1, which was released in December, 2012.
+
+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.
+
+Second, ShenRuby aims to enable hybrid applications implemented using a combination of Ruby and Shen. Ruby methods should be able to invoke functions written in Shen and vice versa. Performance is a secondary part of this goal. It should be good enough that, for most tasks, the choice between Ruby and Shen is based primarily on which language is best suited for solving the problem at hand.
+
+ShenRuby 0.1.0 begins 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 leading to the eventual 1.0.0 release.
+
+## Installation
+NOTE: ShenRuby requires Ruby 1.9 language features. It has been tested with Ruby 1.9.3 and, to a lesser extent, Rubnius in 1.9 mode. It it not yet passing the Shen Test Suite under JRuby.
+
+ShenRuby 0.1.0 is the current release. To install it as gem, use the following command:
+
+    gem install shen-ruby
+
+## Getting started with the Shen REPL
+
+Once the gem has been installed, the Shen REPL can be launched via the `srrepl` (short for ShenRuby REPL) command. For example:
+
+
+    % srrepl
+    Loading Shen.... Completed in 18.61 seconds.
+    
+    Shen 2010, copyright (C) 2010 Mark Tarver
+    www.shenlanguage.org, version 7.1
+    running under Ruby, implementation: ruby 1.9.3
+    port 0.1.0 ported by Greg Spurrier
+    
+    
+    (0-) 
+    
+Please be patient: the Shen REPL takes a while to load (about 20 seconds on a 2.66 GHz MacBook Pro). This will be addressed in future releases.
+
+The `(0-)` seen above is the Shen REPL prompt. The number in the prompt increases after each expression that is entered.
+
+Here is an example of defining a recursive factorial function via the REPL and trying it out:
+
+    (0-) (define factorial
+           0 -> 1
+           X -> (* X (factorial (- X 1))))
+    factorial
+    
+    (1-) (factorial 5)
+    120
+    
+    (2-) (factorial 20)
+    2432902008176640000
+    
+    (3-) (factorial 100)
+    93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
+
+Shen functions are defined in terms of pattern matching rules. Above we say that the factorial of 0 is 1 and that the factorial of anything else--represented as the variable `X`--is `X` times the factorial of `(X - 1)`. This is very similar to how factorial would be described via mathematical equations.
+
+As can be seen with `(factorial 100)`, ShenRuby uses Ruby's underlying number system and supports arbitrarily large integers.
+
+For a quick tour of Shen via the REPL, please see the [Shen in 15 Minutes](http://www.shenlanguage.org/learn-shen/tutorials/shen_in_15mins.html) tutorial on the Shen Website. To learn more about using the Shen REPL itself, please see the [REPL](http://www.shenlanguage.org/learn-shen/repl.html) documentation, also on the Shen Website. Additional resources for learning about Shen are listed in the Shen Resources section below.
+
+To exit the Shen REPL, execute the `quit` function:
+
+    (4-) (quit)
+    %
+
+## Shen Resources
+
+The following resources may be helpful for those wanting to learn more about the Shen programming language:
+
+- [The Shen Website](http://shenlanguage.org/)
+- [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.
+- [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
+
+The following features and improvements are among those planned for ShenRuby as it approaches its 1.0 release:
+
+- Ability to call Shen functions directly from Ruby
+- Ability to call Ruby methods directly from Shen
+- Support for command-line Shen scripts that under ShenRuby
+- Support for MRI, JRuby, and Rubinius
+- Improved performance
+
+## Known Limitations
+
+The "Qi interpreter - chapter 13" test case in the Shen Test Suite and some of the benchmarks are currently failing with stack overflow errors.
+
+## License
+Shen is Copyright (c) 2010-2012 Mark Tarver and released under the Shen License. A copy of the Shen License may be found in [shen/license.txt](https://github.com/gregspurrier/shen-ruby/blob/master/shen/license.txt). A detailed description of the license, along with questions and answers, may be found at http://shenlanguage.org/license.html. The entire contents of the [shen directory](https://github.com/gregspurrier/shen-ruby/tree/master/shen), including the implementation of the `ShenRuby::Shen` class, is part of Shen and is subject to the Shen license.
+
+The remainder of ShenRuby--i.e., everything outside of the shen directory--is Copyright (c) 2012 Greg Spurrier and released under the MIT License. A copy of the MIT License may be found in [MIT_LICENSE.txt](https://github.com/gregspurrier/shen-ruby/blob/master/MIT_LICENSE.txt).

data/bin/shen_test_suite.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../../shen/lib', __FILE__)
+require 'shen_ruby'
+
+shen = ShenRuby::Shen.new
+shen.__eval(Kl::Cons.list([:cd, "shen/release/test_programs"]))
+shen.__eval(Kl::Cons.list([:load, "README.shen"]))
+shen.__eval(Kl::Cons.list([:load, "tests.shen"]))

data/bin/srrepl

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'shen_ruby'
+
+# Load the Shen Envinronment
+print "Loading..."
+STDOUT.flush
+start = Time.now.to_f
+shen = ShenRuby::Shen.new
+now = Time.now.to_f
+puts ". Completed in %0.2f seconds.\n" % (now - start)
+
+# Launch the REPL
+command = :"shen-shen"
+begin
+  shen.__eval(Kl::Cons.list([command]))
+rescue StandardError => e
+  # K Lambda simple errors are already handled by the Shen REPL. Therefore
+  # this must be another type of exception. Print it as such and reenter
+  # the REPL without re-display the initial credits.
+  puts "Ruby exception: #{e.message}"
+  command = :"shen-loop"
+  retry
+end

data/lib/kl.rb

@@ -0,0 +1,7 @@
+require 'kl/error'
+require 'kl/internal_error'
+require 'kl/empty_list'
+require 'kl/cons'
+require 'kl/absvector'
+require 'kl/reader'
+require 'kl/environment'

data/lib/kl/absvector.rb

@@ -0,0 +1,12 @@
+module Kl
+  # Absvectors are just arrays. We give them their own subclass
+  # to support the absvector? primitive.
+  class Absvector < Array
+    attr_reader :upper_limit
+
+    def initialize(n)
+      super(n, :"shen-fail!")
+      @upper_limit = n
+    end
+  end
+end

data/lib/kl/compiler.rb

@@ -0,0 +1,253 @@
+module Kl
+  module Compiler
+    class << self
+      def compile(form, lexical_vars, in_tail_pos)
+        case form
+        when Symbol
+          if lexical_vars.has_key?(form)
+            lexical_vars[form]
+          else
+            escape_symbol(form)
+          end
+        when String
+          # Emit non-interpolating strings
+          "'" + escape_string(form) + "'"
+        when Kl::Cons
+          compile_form(form, lexical_vars, in_tail_pos)
+        when Kl::EmptyList
+          "::Kl::EmptyList.instance"
+        when Numeric
+          form.to_s
+        when true
+          'true'
+        when false
+          'false'
+        else
+          raise Kl::InternalError, "unexpected form: #{form}"
+        end
+      end
+
+    private
+      def compile_form(form, lexical_vars, in_tail_pos)
+        case form.hd
+        when :defun
+          compile_defun(form, lexical_vars)
+        when :lambda
+          compile_lambda(form, lexical_vars)
+        when :let
+          compile_let(form, lexical_vars, in_tail_pos)
+        when :freeze
+          compile_freeze(form, lexical_vars)
+        when :type
+          compile_type(form, lexical_vars, in_tail_pos)
+        when :if
+          compile_if(form, lexical_vars, in_tail_pos)
+        when :and
+          compile_and(form, lexical_vars, in_tail_pos)
+        when :or
+          compile_or(form, lexical_vars, in_tail_pos)
+        when :cond
+          compile_cond(form, lexical_vars, in_tail_pos)
+        when :"trap-error"
+          compile_trap_error(form, lexical_vars, in_tail_pos)
+        else
+          compile_application(form, lexical_vars, in_tail_pos)
+        end
+      end
+
+      # (defun NAME ARGS BODY)
+      def compile_defun(form, lexical_vars)
+        name, arglist, body = destructure_form(form, 3)
+        unless name.kind_of? Symbol
+          raise Kl::Error, 'first argument to defun must be a symbol'
+        end
+        unless arglist.all? {|a| a.kind_of? Symbol}
+          raise Kl::Error, 'function argument list may only contain symbols'
+        end
+
+        extended_vars = add_vars(lexical_vars, arglist.to_a)
+
+        fn_name = escape_symbol(name)
+        fn_args = arglist.map { |arg| extended_vars[arg] }.join(",")
+        fn_arity = arglist.count
+        fn_body = compile(body, extended_vars, true)
+
+        "(@eigenklass.send(:define_method, #{fn_name}, ::Kernel.lambda { |#{fn_args}| #{fn_body}}); @arity_cache[#{fn_name}] = #{fn_arity}; #{fn_name})"
+      end
+
+      # (lambda VAR BODY)
+      def compile_lambda(form, lexical_vars)
+        var, body = destructure_form(form, 2)
+        unless var.kind_of? Symbol
+          raise Kl::Error, 'first argument to lambda must be a symbol'
+        end
+
+        extended_vars = add_var(lexical_vars, var)
+        fn_arg = extended_vars[var]
+        fn_body = compile(body, extended_vars, true)
+
+        "::Kernel.lambda { |#{fn_arg}| #{fn_body}}"
+      end
+
+      # (let VAR EXPR BODY)
+      def compile_let(form, lexical_vars, in_tail_pos)
+        var, expr, body = destructure_form(form, 3)
+        unless var.kind_of? Symbol
+          raise Kl::Error, 'first argument to let must be a symbol'
+        end
+
+        extended_vars = add_var(lexical_vars, var)
+        bound_var = extended_vars[var]
+        # The bound expression is evaluated in the original lexical scope
+        bound_expr = compile(expr, lexical_vars, false)
+        let_body = compile(body, extended_vars, in_tail_pos)
+
+        "(#{bound_var} = #{bound_expr}; #{let_body})"
+      end
+
+      # (freeze EXPR)
+      def compile_freeze(form, lexical_vars)
+        expr = destructure_form(form, 1).first
+
+        body = compile(expr, lexical_vars, true)
+
+        "::Kernel.lambda { #{body} }"
+      end
+
+      # (type EXPR T)
+      def compile_type(form, lexical_vars, in_tail_pos)
+        # Just ignore the type information for now
+        expr, _ = destructure_form(form, 2)
+        compile(expr, lexical_vars, in_tail_pos)
+      end
+
+      # (if TEST_EXPR TRUE_EXPR FALSE_EXPR)
+      def compile_if(form, lexical_vars, in_tail_pos)
+        test_expr, on_true_expr, on_false_expr = destructure_form(form, 3)
+
+        test_clause = compile(test_expr, lexical_vars, false)
+        true_clause = compile(on_true_expr, lexical_vars, in_tail_pos)
+        false_clause = compile(on_false_expr, lexical_vars, in_tail_pos)
+
+        "(#{test_clause} ? #{true_clause} : #{false_clause})"
+      end
+
+      # (and EXPR1 EXPR2)
+      def compile_and(form, lexical_vars, in_tail_pos)
+        expr1, expr2 = destructure_form(form, 2)
+        compile_if(Kl::Cons.list([:if, expr1, expr2, false]),
+                   lexical_vars, in_tail_pos)
+      end
+
+      # (or EXPR1 EXPR2)
+      def compile_or(form, lexical_vars, in_tail_pos)
+        expr1, expr2 = destructure_form(form, 2)
+        compile_if(Kl::Cons.list([:if, expr1, true, expr2]),
+                   lexical_vars, in_tail_pos)
+      end
+
+      def compile_cond(form, lexical_vars, in_tail_pos)
+        clauses = form.tl
+        if clauses.kind_of? Kl::EmptyList
+          'raise(::Kl::Error, "condition failure")'
+        else
+          clause = clauses.hd
+          test_expr = clause.hd
+          true_expr = clause.tl.hd
+          false_expr = Kl::Cons.new(:cond, clauses.tl)
+          compile_if(Kl::Cons.list([:if, test_expr, true_expr, false_expr]),
+                     lexical_vars,
+                     in_tail_pos)
+        end
+      end
+
+      # (trap-error EXPR ERR_HANDLER)
+      def compile_trap_error(form, lexical_vars, in_tail_pos)
+        expr, err_handler = destructure_form(form, 2)
+
+        # TODO: TCO for try and catch clauses
+        try_clause = compile(expr, lexical_vars, false)
+        extended_vars = add_var(lexical_vars, :err)
+        err_var = extended_vars[:err]
+        catch_clause = compile_application(
+          Kl::Cons.list([err_handler, :err]),
+          extended_vars,
+          false)
+
+        "(begin; #{try_clause}; rescue ::Kl::Error => #{err_var}; " +
+          "#{catch_clause}; end)"
+      end
+
+      # Normal function application
+      def compile_application(form, lexical_vars, in_tail_pos)
+        f = form.hd
+        args = form.tl
+        
+        rator = compile(f, lexical_vars, false)
+        rands = args.map { |arg| compile(arg, lexical_vars, false) }.join(',')
+
+        tfn = gen_sym
+        targs = gen_sym
+
+        if in_tail_pos
+          "(
+             #{tfn} = #{rator};
+             #{targs} = [#{rands}];
+             @tramp_fn = #{tfn};
+             @tramp_args = #{targs}
+            )"
+        else
+          "__apply(#{rator}, [#{rands}])"
+        end
+      end
+      
+      # Escape single quotes and backslashes
+      def escape_string(str)
+        new_str = ""
+        str.each_char do |c|
+          if c == "'"
+            new_str << "\\"
+            new_str << "'"
+          elsif c == '\\'
+            new_str << '\\'
+            new_str << '\\'
+          else
+            new_str << c
+          end
+        end
+        new_str
+      end
+
+      def escape_symbol(sym)
+        ':"' + sym.to_s + '"'
+      end
+
+      def destructure_form(form, expected_arg_count)
+        array = form.to_a
+        unless array.length == expected_arg_count + 1
+          raise Kl::Error, "#{form.first} expects #{expected_arg_count} " +
+            "arguments but was given #{array.length - 1}"
+        end
+        array[1..-1]
+      end
+
+      def add_var(scope, var)
+        add_vars(scope, [var])
+      end
+
+      def add_vars(scope, vars)
+        scope.dup.tap do |new_scope|
+          vars.each do |var|
+            new_scope[var] = gen_sym
+          end
+        end
+      end
+
+      def gen_sym
+        @sym_count ||= 0
+        @sym_count += 1
+        "__kl_VAR_#{@sym_count}"
+      end
+    end
+  end
+end