klam 0.0.1

data/lib/klam/compilation_stages/curry_abstraction_applications.rb

@@ -0,0 +1,33 @@
+module Klam
+  module CompilationStages
+    # Curry Abstraction Applications
+    #
+    # This stage converts all applications of abstractions (i.e., any
+    # application that does not have a symbol in rator position) to
+    # a curried form in which only one argument is applied at a time.
+    # For example:
+    #
+    #   ((foo) 1 2 3)
+    #
+    # becomes:
+    #
+    #   ((((foo) 1) 2) 3)
+    module CurryAbstractionApplications
+      def curry_abstraction_applications(sexp)
+        if sexp.instance_of?(Array)
+          if !sexp[0].instance_of?(Symbol) && sexp.length > 2
+            [curry_abstraction_applications(sexp[0..-2]),
+             curry_abstraction_applications(sexp[-1])]
+          elsif sexp[0] == :defun
+            sexp[0,3] +
+              sexp[3..-1].map { |form| curry_abstraction_applications(form) }
+          else
+            sexp.map { |form| curry_abstraction_applications(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/emit_ruby.rb

@@ -0,0 +1,232 @@
+module Klam
+  module CompilationStages
+    # Emit Ruby
+    #
+    # This is the final stage in the compilation pipeline. It is responsible
+    # for converting the compiler's internal representation to a string
+    # containing Ruby code that is suitable for execution via instance_eval in
+    # the context of a Klam::Environment object.
+    #
+    # By the time compilation reaches this stage, all of the heavy lifting
+    # should be complete. Emitting Ruby is simply a matter of transliterating
+    # the simplified s-expression into Ruby.
+    module EmitRuby
+      include Klam::Template
+
+      PRIMITIVE_TEMPLATES = {
+        :+ => [2, '($1 + $2)'],
+        :- => [2, '($1 - $2)'],
+        :* => [2, '($1 * $2)'],
+        :< => [2, '($1 < $2)'],
+        :> => [2, '($1 > $2)'],
+        :<= => [2, '($1 <= $2)'],
+        :>= => [2, '($1 >= $2)'],
+        :"=" => [2, '($1 == $2)'],
+        :absvector => [1, '::Array.new($1)'],
+        :absvector? => [1, '$1.instance_of?(::Array)'],
+        :"<-address" => [2, '$1[$2]'],
+        :cons => [2, '::Klam::Cons.new($1, $2)'],
+        :cons? => [1, '$1.instance_of?(::Klam::Cons)'],
+        :hd => [1, '$1.hd'],
+        :set => [2, '(@assignments[$1] = $2)'],
+        :tl => [1, '$1.tl'],
+        :value => [1, '@assignments[$1]']
+      }
+
+      def emit_ruby(sexp)
+        case sexp
+        when Symbol
+          emit_symbol(sexp)
+        when String
+          emit_string(sexp)
+        when Klam::Variable, Numeric, true, false
+          sexp.to_s
+        when Array
+          if sexp.empty?
+            Klam::Primitives::Lists::EMPTY_LIST.inspect
+          else
+            emit_compound_form(sexp)
+          end
+        end
+      end
+
+    private
+
+      def emit_compound_form(form)
+        # Handle special forms and fall back to normal function application
+        case form[0]
+        when :defun
+          emit_defun(form)
+        when :if
+          emit_if(form)
+        when :lambda
+          emit_lambda(form)
+        when :let
+          emit_let(form)
+        when :"trap-error"
+          emit_trap_error(form)
+        when :do
+          emit_do(form)
+        when :"[FIX-VARS]"
+          emit_fix_vars(form)
+        when :"[LOOP]"
+          emit_loop(form)
+        when :"[RECUR]"
+          emit_recur(form)
+        else
+          if full_primitive_form?(form)
+            emit_primitive(form)
+          else
+            emit_application(form)
+          end
+        end
+      end
+
+      def full_primitive_form?(form)
+        num_args, template = PRIMITIVE_TEMPLATES[form[0]]
+        num_args && (num_args == form.size - 1)
+      end
+
+      def emit_primitive(form)
+        _, template = PRIMITIVE_TEMPLATES[form[0]]
+        rands_rb = form[1..-1].map { |rand| emit_ruby(rand) }
+        render_string(template, *rands_rb)
+      end
+
+      def emit_application(form)
+        rator = form[0]
+        rands = form[1..-1]
+        rator_rb = emit_ruby(rator)
+        rands_rb = rands.map { |rand| emit_ruby(rand) }
+
+        if rator.kind_of?(Symbol)
+          # Application of a function defined in the environment. At this point
+          # partial application and currying has been taken care of, so a
+          # simple send suffices.
+          render_string('__send__($1)', [rator_rb] + rands_rb)
+        else
+          render_string('__apply($1)', [rator_rb] + rands_rb)
+        end
+      end
+
+      def emit_defun(form)
+        _, name, params, body = form
+        name_rb = emit_ruby(name)
+        params_rb = params.map { |param| emit_ruby(param) }
+        body_rb = emit_ruby(body)
+
+        # Some valid Kl function names (e.g. foo-bar) are not valid when used
+        # with Ruby's def syntax. They will work with define_method, but the
+        # resulting methods are slower than if they had been defined via def.
+        # To maximize performance, methods are defined with def and then
+        # renamed to their intended name afterwards.
+        mangled_name = '__klam_fn_' + name.to_s.gsub(/[^a-zA-Z0-9]/, '_')
+        render_string(<<-EOT, name_rb, params_rb, body_rb, mangled_name, params.size)
+          def $4($2)
+            $3
+          end
+          @eigenclass.rename_method(:$4, $1)
+          @arities[$1] = $5
+          @curried_methods.delete($1)
+          @loop_cache.delete($1)
+          $1
+        EOT
+      end
+
+      def emit_do(form)
+        rands = form[1,2]
+        rands_rb = rands.map { |rand| emit_ruby(rand) }
+        '(' + rands_rb.join(';') + ')'
+      end
+
+      def emit_fix_vars(form)
+        _, params, expr = form
+        params_rb = params.map { |param| emit_ruby(param) }
+        expr_rb = emit_ruby(expr)
+
+        render_string('(::Kernel.lambda { |$1| $2 }).call($1)',
+                      params_rb, expr_rb)
+      end
+
+      def emit_if(form)
+        args = form[1..3].map { |sexp| emit_ruby(sexp) }
+        render_string('($1 ? $2 : $3)', *args)
+      end
+
+      def emit_lambda(form)
+        _, params, body = form
+        params_rb = params.map { |param| emit_ruby(param) }
+        body_rb = emit_ruby(body)
+
+        render_string('(::Kernel.lambda { |$1| $2 })', params_rb, body_rb)
+      end
+
+      def emit_let(form)
+        _, var, value_expr, body_expr = form
+
+        var_rb = emit_ruby(var)
+        value_expr_rb = emit_ruby(value_expr)
+        body_expr_rb = emit_ruby(body_expr)
+
+        render_string('($1 = $2; $3)', var_rb, value_expr_rb, body_expr_rb)
+      end
+
+      def emit_loop(form)
+        name_rb = emit_ruby(form[1])
+        params_rb = form[2].map {|v| emit_ruby(v)}
+        expr_rb = emit_ruby(form[3])
+        render_string('(@loop_cache[$1] ||= ::Kernel.lambda { |$2| $3 }).call($2)', name_rb,
+                      params_rb, expr_rb)
+      end
+
+      def emit_recur(form)
+        _, params, new_value_exprs = form
+        if params.size > 0
+          params_rb = params.map { |param| emit_ruby(param) }
+          new_value_exprs_rb = new_value_exprs.map { |expr| emit_ruby(expr) }
+
+          render_string('(($1 = $2); redo)', params_rb, new_value_exprs_rb)
+        else
+          'redo'
+        end
+      end
+
+      def emit_string(str)
+        "'" + escape_string(str) + "'"
+      end
+
+      def emit_symbol(sym)
+        ':"' + sym.to_s + '"'
+      end
+
+      def emit_trap_error(form)
+        _, expr, handler = form
+        err_var = fresh_variable
+
+        expr_rb = emit_ruby(expr)
+        apply_handler_rb = emit_application([handler, err_var])
+        err_var_rb = emit_ruby(err_var)
+
+        render_string('(begin; $2; rescue => $1; $3; end)', err_var_rb,
+                      expr_rb, apply_handler_rb)
+      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
+    end
+  end
+end

data/lib/klam/compilation_stages/kl_to_internal_representation.rb

@@ -0,0 +1,21 @@
+module Klam
+  module CompilationStages
+    # Kl to Internal Represenation
+    #
+    # To simplify coding and improve performance, the compiler uses arrays
+    # rather than Kl lists to represent nested s-expressions. This stage
+    # performs the conversion.
+    module KlToInternalRepresentation
+      include Klam::Primitives::Lists
+      include Klam::Converters::List
+
+      def kl_to_internal_representation(kl)
+        if cons?(kl) || kl == Klam::Primitives::Lists::EMPTY_LIST
+          listToArray(kl)
+        else
+          kl
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/make_abstractions_monadic.rb

@@ -0,0 +1,26 @@
+module Klam
+  module CompilationStages
+    # Make Abstractions Monadic
+    #
+    # By the time the Ruby code is emitted, we want abstractions to take
+    # no more than one parameter. This simplifies code generation and
+    # avoids the need for using Proc#curry, which is slow.
+    #
+    # This stage converts (lambda [X Y] form) to (lambda [X] (lambda [Y] form))
+    module MakeAbstractionsMonadic
+      def make_abstractions_monadic(sexp)
+        if sexp.instance_of?(Array)
+          if sexp[0] == :lambda && sexp[1].length > 1
+            params = sexp[1]
+            [:lambda, [params[0]],
+              make_abstractions_monadic([:lambda, params[1..-1], sexp[2]])]
+          else
+            sexp.map { |form| make_abstractions_monadic(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/make_abstractions_variadic.rb

@@ -0,0 +1,23 @@
+module Klam
+  module CompilationStages
+    # Make Abstractions Variadic
+    #
+    # Kl's lambda special form only accepts a single parameter for the
+    # abstraction. It is useful internally, however, to allow abstractions to
+    # have zero or more parameters.
+    module MakeAbstractionsVariadic
+      def make_abstractions_variadic(sexp)
+        if sexp.instance_of?(Array)
+          if sexp[0] == :lambda
+            rator, param, form = sexp
+            [rator, [param], make_abstractions_variadic(form)]
+          else
+            sexp.map { |form| make_abstractions_variadic(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/simplify_boolean_operations.rb

@@ -0,0 +1,74 @@
+module Klam
+  module CompilationStages
+    # Simplify Boolean Operations
+    #
+    # Kl defines four special forms for boolean operations: if, or, and, and
+    # cond. Having if or cond alone is sufficient for implementing the complete
+    # set. This compilation stages recasts or, and, and cond in terms of if.
+    module SimplifyBooleanOperations
+      def simplify_boolean_operations(sexp)
+        if sexp.instance_of?(Array)
+          case sexp[0]
+          when :and
+            simplify_and(sexp)
+          when :cond
+            simplify_cond(sexp)
+          when :or
+            simplify_or(sexp)
+          else
+            sexp.map { |form| simplify_boolean_operations(form) }
+          end
+        else
+          sexp
+        end
+      end
+
+    private
+
+      def simplify_and(sexp)
+        # Only convert the fully-applied case
+        if sexp.length == 3
+          _, expr1, expr2 = sexp
+          expr1 = simplify_boolean_operations(expr1)
+          expr2 = simplify_boolean_operations(expr2)
+
+          [:if, expr1, expr2, false]
+        else
+          sexp.map { |form| simplify_boolean_operations(form) }
+        end
+      end
+
+      def simplify_cond(sexp)
+        # Cond expressions are of the form:
+        #   (cond (Test1 Expr1) ... (TestN ExprN))
+        clauses = sexp[1..-1]
+        simplify_cond_clauses(clauses)
+      end
+
+      def simplify_cond_clauses(clauses)
+        if clauses.empty?
+          # An error is raised if none of the clauses match.
+          [:"simple-error", 'cond failure']
+        else
+          test, expr = clauses[0]
+          test = simplify_boolean_operations(test)
+          expr = simplify_boolean_operations(expr)
+          [:if, test, expr, simplify_cond_clauses(clauses[1..-1])]
+        end
+      end
+
+      def simplify_or(sexp)
+        # Only convert the fully-applied case
+        if sexp.length == 3
+          _, expr1, expr2 = sexp
+          expr1 = simplify_boolean_operations(expr1)
+          expr2 = simplify_boolean_operations(expr2)
+
+          [:if, expr1, true, expr2]
+        else
+          sexp.map { |form| simplify_boolean_operations(form) }
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/strip_type_declarations.rb

@@ -0,0 +1,24 @@
+module Klam
+  module CompilationStages
+    # Strip Type Declarations
+    #
+    # The Kl type primitive is provided to pass type hints from the Shen
+    # compiler to the Kl compiler. Klam does not make use of them, so they are
+    # removed in this stage to simplify the s-expression and avoid having to
+    # take the type primitive into account when optimizing self tail calls.
+    module StripTypeDeclarations
+      def strip_type_declarations(sexp)
+        if sexp.instance_of?(Array)
+          if sexp[0] == :type
+            _, form, _ = sexp
+            strip_type_declarations(form)
+          else
+            sexp.map { |form| strip_type_declarations(form) }
+          end
+        else
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/klam/compiler.rb

@@ -0,0 +1,63 @@
+module Klam
+  class Compiler
+    # Compiliation is implmented as a series of stages, each defined in
+    # its own module. The first stage converts Kl s-expressions to the
+    # the compiler's internal represenation. The final stage converts
+    # the internal representation of a string containing Ruby code
+    # suitable for use with instance_eval in the context of a
+    # Klam::Environment instance.
+
+    include Klam::CompilationStages::KlToInternalRepresentation
+    include Klam::CompilationStages::StripTypeDeclarations
+    include Klam::CompilationStages::MakeAbstractionsVariadic
+    include Klam::CompilationStages::ConvertLexicalVariables
+    include Klam::CompilationStages::ConvertFreezesToLambdas
+    include Klam::CompilationStages::SimplifyBooleanOperations
+    include Klam::CompilationStages::ConvertPartialApplicationsToLambdas
+    include Klam::CompilationStages::CurryAbstractionApplications
+    include Klam::CompilationStages::MakeAbstractionsMonadic
+    include Klam::CompilationStages::ConvertSelfTailCallsToLoops
+    include Klam::CompilationStages::EmitRuby
+
+    def initialize(environment)
+      @environment = environment
+      @generator = Klam::VariableGenerator.new
+    end
+
+    def compile(kl)
+      stages = [
+        :kl_to_internal_representation,
+        :strip_type_declarations,
+        :make_abstractions_variadic,
+        :convert_lexical_variables,
+        :convert_freezes_to_lambdas,
+        :simplify_boolean_operations,
+        :convert_partial_applications_to_lambdas,
+        :curry_abstraction_applications,
+        :make_abstractions_monadic,
+        :convert_self_tail_calls_to_loops,
+        :emit_ruby
+      ]
+      apply_stages(stages, kl)
+    end
+
+  private
+
+    def apply_stages(stages, kl)
+      stages.reduce(kl) do |exp, stage|
+        send(stage, exp)
+      end
+    end
+
+    def arity(sym)
+      @environment.__arity(sym)
+    end
+
+    # Returns a new Klam::Variable object that is unique within this
+    # instance of the compiler. Variables are never used in a global
+    # context in Kl, so this is sufficient to avoid collisions.
+    def fresh_variable
+      @generator.next
+    end
+  end
+end