klam 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6bfb59d34a33d476f312e82821a8daa9c23a766
+  data.tar.gz: 1e17a5d167569095f128e551504e48ccfc5c3f84
+SHA512:
+  metadata.gz: f2adf161608625ab5b3a7c7d38cb406df8152d98a55b85fa7d77f338c543f7c21a98df1923d507b52e863a2aeb47f3672dce37b18e3c28cc6226e1664b036b97
+  data.tar.gz: 2949ef6dcb1086f138bdd8059cf8419de98eca82c2054754244050511147c6d1119bda3969397e0b436b8b1a49dde962a470d1d5f299cb1e146b7cdcba9e46cd

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+klam-*.gem

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - jruby-1.7.17
+  - rbx

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2014 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/PROGRESS.asciidoc

@@ -0,0 +1,105 @@
+Klam Implementation Progress
+============================
+
+This document tracks the progress of Klam towards a feature-complete 1.0.0
+release.
+
+Implemented
+-----------
+
+Language Features
+~~~~~~~~~~~~~~~~~
+* Reader
+* Environment
+** Global assignment namespace
+** Global function namespace
+* Code Generation
+** Atoms
+** Abstractions
+** Functions
+** Special forms (see marked primimitives below)
+** Application
+*** Functions and abstractions:
+**** Full application
+**** Partial application
+**** Currying
+** Self tail-call optimization
+
+Primitives
+~~~~~~~~~~
+As defined in
+http://www.shenlanguage.org/learn-shen/shendoc.htm#The%20Primitive%20Functions%20of%20K%20Lambda[The
+Primitive Functions of Kl]:
+
+* Boolean Operations
+** +if+ (special form and normal function)
+** +and+ (special form and normal function)
+** +or+ (special form and normal function)
+** +cond+ (special form)
+* Symbols
+** +intern+
+* Strings
+** +pos+
+** +tlstr+
+** +cn+
+** +str+
+** +string?+
+** +n\->string+
+** +string\->n+
+* Assignments
+** +set+
+** +value+
+* Lists
+** +cons+
+** +hd+
+** +tl+
+** +cons?+
+* Error Handling
+** +simple-error+
+** +trap-error+ (special form)
+** +error-to-string+
+* Generic Functions
+** +defun+ (special form)
+** +lambda+ (special form)
+** +let+ (special form)
+** +=+
+** +eval-kl+
+** +freeze+ (special form)
+** +type+ (special form)
+* Vectors
+** +absvector+
+** +address\->+
+** +\<-address+
+** +absvector?+
+* Streams and I/O
+** +write-byte+
+** +read-byte+
+** +open+
+** +close+
+* Time
+** +get-time+
+* Arithmetic
+** +++
+** +-+
+** +*+
+** +/+
+** +>+
+** +<+
+** +>=+
+** +\<=+
+** +number?+
+
+Ruby Interoperation
+~~~~~~~~~~~~~~~~~~~
+* Ruby \<\-> Kl converters
+** Array \<\-> List
+
+Not Yet Implemented
+-------------------
+
+Ruby Interoperation
+~~~~~~~~~~~~~~~~~~~
+* Invoking Kl functions from Ruby
+* Invoking Ruby functions from Kl
+* Ruby \<\-> Kl converters
+** Array \<\-> Absvector

data/README.asciidoc

@@ -0,0 +1,11 @@
+Klam
+====
+
+Klam is a Ruby implementation of Kl, the small Lisp on top of which the
+http://www.shenlanguage.org[Shen] programming language is implemented.
+
+image:https://travis-ci.org/gregspurrier/klam.png?branch=master["Build Status", link="https://travis-ci.org/gregspurrier/klam"]
+
+License
+-------
+Klam is Copyright (C) 2014-2015 Greg Spurrier. It is distributed under the terms of the MIT License. See link:LICENSE.txt[] for the details.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/klam.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'klam/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'klam'
+  s.version     = Klam::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = 'MIT'
+  s.authors     = ['Greg Spurrier']
+  s.email       = ['greg@sourcematters.org']
+  s.homepage    = 'https://github.com/gregspurrier/klam'
+  s.summary     = %q{Klam is a Ruby implementation of the Kl.}
+  s.description = %q{Klam is a Ruby implementation of Kl, the small Lisp on top of which the Shen programming language is implemented.}
+
+  s.required_ruby_version     = '>= 1.9.3'
+
+  s.add_development_dependency 'rake', '~> 10.4', '>= 10.4'
+  s.add_development_dependency 'rspec', '~> 3.1', '>= 3.1.0'
+  s.add_development_dependency 'rspec-autotest', '~> 1.0', '>= 1.0.0'
+  s.add_development_dependency 'ZenTest', '~> 4.11', '>= 4.11'
+
+  git_files            = `git ls-files`.split("\n") rescue ''
+  s.files              = git_files
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths      = ['lib']
+end

data/lib/klam.rb

@@ -0,0 +1,16 @@
+module Klam
+end
+
+require 'klam/version'
+require 'klam/error'
+require 'klam/template'
+require 'klam/variable'
+require 'klam/variable_generator'
+require 'klam/cons'
+require 'klam/primitives'
+require 'klam/converters'
+require 'klam/compilation_stages'
+require 'klam/compiler'
+require 'klam/environment'
+require 'klam/lexer'
+require 'klam/reader'

data/lib/klam/compilation_stages.rb

@@ -0,0 +1,4 @@
+this_dir = File.dirname(__FILE__)
+Dir[File.join(this_dir, 'compilation_stages', '*.rb')].each do |file|
+  require file
+end

data/lib/klam/compilation_stages/convert_freezes_to_lambdas.rb

@@ -0,0 +1,17 @@
+module Klam
+  module CompilationStages
+    module ConvertFreezesToLambdas
+      def convert_freezes_to_lambdas(sexp)
+        if sexp.instance_of?(Array)
+          if sexp[0] == :freeze
+            [:lambda, [], convert_freezes_to_lambdas(sexp[1])]
+          else
+            sexp.map { |form| convert_freezes_to_lambdas(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/convert_lexical_variables.rb

@@ -0,0 +1,79 @@
+module Klam
+  module CompilationStages
+    # Convert Lexical Variables
+    #
+    # Lexically bound variable names are symbols in Kl. In Ruby, variable and
+    # parameter names are represented differently than symbol literals.  The
+    # latter are indicated with a leading ':' (e.g., :foo) and allow an
+    # extended set of characters when using the :"foo-bar" literal syntax.
+    # Ruby variables have no such provision for using additional characters.
+    #
+    # Therefore, if lexical variables remain as symbols, the emission of Ruby
+    # code for symbols would be complicated by the need to differentiate
+    # between symbol literals and lexical variables and to transform Kl
+    # variable names to legal Ruby variable names. Instead, this stage converts
+    # lexical variables to instances of Klam::Variable. This is essentially
+    # alpha conversion and the names of Klam::Variable are generated to be
+    # locally unique and using only allowed Ruby variable names.
+    #
+    # Alpha conversion also avoids potential problems when the let primitive is
+    # used to re-bind an already bound lexical var.
+    module ConvertLexicalVariables
+      def convert_lexical_variables(sexp)
+        convert_lexical_vars(sexp, {})
+      end
+
+    private
+
+      def convert_lexical_vars(sexp, var_map)
+        if sexp.instance_of? Array
+          case sexp[0]
+          when :defun
+            convert_lexical_vars_defun(sexp, var_map)
+          when :lambda
+            convert_lexical_vars_lambda(sexp, var_map)
+          when :let
+            convert_lexical_vars_let(sexp, var_map)
+          else
+            sexp.map { |form| convert_lexical_vars(form, var_map) }
+          end
+        else
+          var_map[sexp] || sexp
+        end
+      end
+
+      def convert_lexical_vars_defun(sexp, var_map)
+        rator, name, params, expr = sexp
+        var_map = extend_var_map(var_map, params)
+
+        params = params.map { |p| var_map[p] }
+        expr = convert_lexical_vars(expr, var_map)
+        [rator, name, params, expr]
+      end
+
+      def convert_lexical_vars_lambda(sexp, var_map)
+        rator, params, expr = sexp
+        var_map = extend_var_map(var_map, params)
+
+        params = params.map { |p| var_map[p] }
+        expr = convert_lexical_vars(expr, var_map)
+        [rator, params, expr]
+      end
+
+      def convert_lexical_vars_let(sexp, var_map)
+        rator, var_sym, value_expr, expr = sexp
+        extended_var_map = extend_var_map(var_map, [var_sym])
+
+        value_expr = convert_lexical_vars(value_expr, var_map)
+        expr = convert_lexical_vars(expr, extended_var_map)
+        [rator, extended_var_map[var_sym], value_expr, expr]
+      end
+
+      def extend_var_map(var_map, syms)
+        new_var_map = Hash.new { |_, k| var_map[k] }
+        syms.each { |sym| new_var_map[sym] = fresh_variable }
+        new_var_map
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/convert_partial_applications_to_lambdas.rb

@@ -0,0 +1,35 @@
+module Klam
+  module CompilationStages
+    module ConvertPartialApplicationsToLambdas
+      def convert_partial_applications_to_lambdas(sexp)
+        if sexp.instance_of?(Array)
+          rator = sexp[0]
+          if rator.kind_of?(Symbol)
+            rands = sexp[1..-1]
+            converted_rands = rands.map do |rand|
+              convert_partial_applications_to_lambdas(rand)
+            end
+
+            rator_arity = arity(rator)
+            if rator_arity == -1 || rator_arity == rands.length
+              converted_rands.unshift(rator)
+            elsif rator_arity > rands.length
+              # Partial application
+              vars = (rator_arity - rands.length).times.map { fresh_variable }
+              [:lambda, vars, [rator] + converted_rands + vars]
+            else
+              # Uncurrying
+              now_rands = rands[0...rator_arity]
+              deferred_rands = rands[rator_arity..-1]
+              [[rator] + now_rands, *deferred_rands]
+            end
+          else
+            sexp.map { |form| convert_partial_applications_to_lambdas(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/convert_self_tail_calls_to_loops.rb

@@ -0,0 +1,147 @@
+module Klam
+  module CompilationStages
+    # Convert Self Tail Calls To Loops
+    #
+    # The Shen specification requires that self tail calls be optimized.  This
+    # stage transforms defuns containing self tail calls into a loop/recur form
+    # akin to Clojure's loop/recur. The code emitter knows how to handle these
+    # synthetic special forms.
+    #
+    # For example, this code with tail calls:
+    #
+    #   (defun fact-iter (N Accum)
+    #     (if (= N 0)
+    #       Accum
+    #       (fact-iter (- N 1) (* N Accum))))
+    #
+    # is converted to:
+    #
+    #   (defun fact-iter (N Accum)
+    #     ([LOOP]
+    #       (if (= N 0)
+    #         Accum
+    #         ([RECUR] (N Accum) ((- N 1) (* N Accum))))))
+    #
+    # The variable names are carried along with their new binding expressions
+    # in the [RECUR] form so that they can be rebound before looping.
+    #
+    # Note that this rebinding of variables causes a wrinkle with respect to
+    # closures created in the body. Those closures should close over the value
+    # at the point of closing rather than the ultimate values after rebinding.
+    # To solve this, another sythetic primitive, [FIX-VARS], is used to wrap
+    # these cases and the emitted Ruby code samples those variables.
+    #
+    # This compilation stage must come _after_ SimplifyBooleanOperations and
+    # ConvertFreezesToLambdas.
+    module ConvertSelfTailCallsToLoops
+      def convert_self_tail_calls_to_loops(sexp)
+        # Self tail calls can only be found in functions defined by defun.
+        # defun is only allowed at the top level, so there's no need to
+        # walk the tree if this form is not a defun.
+        if sexp.kind_of?(Array) && sexp[0] == :defun
+          _, name, params, body = sexp
+          if contains_self_tail_calls?(body, name)
+            insert_loop_and_recur_into_defun(fix_vars(sexp, params))
+          else
+            sexp
+          end
+        else
+          sexp
+        end
+      end
+
+    private
+
+      def contains_self_tail_calls?(body, name)
+        if body.instance_of?(Array)
+          case body[0]
+          when name
+            true
+          when :if
+            _, _, true_expr, false_expr = body
+            contains_self_tail_calls?(true_expr, name) ||
+              contains_self_tail_calls?(false_expr, name)
+          when :let
+            contains_self_tail_calls?(body[3], name)
+          when :do
+            contains_self_tail_calls?(body[2], name)
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def insert_loop_and_recur_into_defun(form)
+        rator, name, params, body = form
+        body_with_loop = [:"[LOOP]", name, params,
+                          insert_recur_into_expr(body, name, params)]
+        [rator, name, params, body_with_loop]
+      end
+
+      def insert_recur_into_expr(sexp, name, params)
+        if sexp.instance_of?(Array)
+          case sexp[0]
+          when name
+            if sexp.length - 1 == params.length
+              [:"[RECUR]", params, sexp[1..-1]]
+            else
+              sexp
+            end
+          when :if
+            rator, test_expr, true_expr, false_expr = sexp
+            [rator,
+             test_expr,
+             insert_recur_into_expr(true_expr, name, params),
+             insert_recur_into_expr(false_expr, name, params)]
+          when :let
+            rator, var, val_expr, body_expr = sexp
+            [rator,
+             var,
+             val_expr,
+             insert_recur_into_expr(body_expr, name, params)]
+          when :do
+            rator, first_expr, second_expr = sexp
+            [rator, first_expr, insert_recur_into_expr(second_expr, name, params)]
+          else
+            sexp
+          end
+        else
+          sexp
+        end
+      end
+
+      def fix_vars(sexp, params)
+        if sexp.kind_of?(Array)
+          if sexp[0] == :lambda
+            referenced_vars = vars_referenced_in(sexp, params)
+            if referenced_vars.empty?
+              sexp
+            else
+              [:"[FIX-VARS]", referenced_vars, sexp]
+            end
+          else
+            # Local variables must also be fixed
+            if sexp[0] == :let
+              params = params + [sexp[1]]
+            end
+            sexp.map { |x| fix_vars(x, params) }
+          end
+        else
+          sexp
+        end
+      end
+
+      def vars_referenced_in(sexp, vars)
+        if sexp.kind_of?(Array)
+          sexp.map { |x| vars_referenced_in(x, vars) }.flatten.uniq
+        elsif vars.include?(sexp)
+          [sexp]
+        else
+          []
+        end
+      end
+    end
+  end
+end