klam 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc3dcaef0efecdb916e9c2907f08db38c0ea5a5e
-  data.tar.gz: a5751310c733519a4815040f0005fff1f36196b3
+  metadata.gz: 388bcd5f65c90c9afc48ad0953555aeec43a9c1d
+  data.tar.gz: fbfad96792a844628a80dde207ffa46e7ca83bf6
 SHA512:
-  metadata.gz: 41d80904122f50bbd3b1d7c1586e5666e44f38135d680ae5ca81844df4ca100c693bdc9f031eaf6b698f76881fe5f2db916b80a9d340981839481d23ff725802
-  data.tar.gz: 9635963254c84641c58e9d69f3bb4a803fd7e1702a0b7360b7b3a397ac940ffa04a3674f248be4d1224a8f964336420fe0da1590e1276e75f07fd4ea44b8209f
+  metadata.gz: e899e06dd8a393c2c0c7e7cd5d2a9b7ba1bf0a64d3d624663831589638e287ac829631372c52a9e14b52489406f0b51c0d34be6d4eec8aef759feef979a2a1ea
+  data.tar.gz: 9c9ceace49289e0326ee835d4db0570d5c93c148dcc11ffd5a492495aca4c74184a8f704e91c2d366132bdee5c7c2dc5601a4aa3cc7b506de00def53a343773a

data/HISTORY.asciidoc

@@ -1,6 +1,15 @@
 Relase History
 ==============
 
+v0.0.8 -- March 15, 2015
+------------------------
+Performance Improvements
+~~~~~~~~~~~~~~~~~~~~~~~~
+* Self tail calls are now implemented with while loops rather than lambda/redo.
+* Lists containing only constants are created once and cached.
+* `Klam::Absvector` contains an `Array` instance rather than inheriting from
+  `Array`
+
 v0.0.7 -- February 24, 2015
 ---------------------------
 New Features

data/lib/klam.rb

@@ -4,6 +4,8 @@ end
 require 'klam/version'
 require 'klam/error'
 require 'klam/template'
+require 'klam/constant'
+require 'klam/constant_generator'
 require 'klam/variable'
 require 'klam/variable_generator'
 require 'klam/absvector'

data/lib/klam/absvector.rb

@@ -1,21 +1,33 @@
 module Klam
-  class Absvector < Array
-    def [](i)
-      if i < 0 || i >= size
-        raise Klam::Error, "index out of bounds: #{i}"
+  class Absvector
+    include Enumerable
+    attr_reader :size, :array
+
+    def initialize(n_or_array, fill = nil)
+      if n_or_array.kind_of?(Array)
+        # This is a convenience constructor for making Shen vectors from Ruby
+        # Arrays. Shen vectors use 1-based indexing and store the size in
+        # slot zero.
+        @array = Array.new(n_or_array)
+        @array.unshift(@array.size)
+      else
+        @array = Array.new(n_or_array, fill)
       end
-      super(i)
+        @size = @array.size
     end
 
-    def []=(i, x)
-      if i < 0 || i >= size
+    def [](i)
+      if i < 0 || i >= @size
         raise Klam::Error, "index out of bounds: #{i}"
       end
-      super(i, x)
+      @array[i]
     end
 
     def store(i, x)
-      self[i] = x
+      if i < 0 || i >= @size
+        raise Klam::Error, "index out of bounds: #{i}"
+      end
+      @array[i] = x
       self
     end
 
@@ -27,9 +39,16 @@ module Klam
     end
 
     def to_a
-      a = super
-      a.shift
-      a
+      @array[1..-1]
+    end
+
+    def ==(other)
+      other.kind_of?(Klam::Absvector) && other.size == @size &&
+        other.array == @array
+    end
+
+    def hash
+      @array.hash
     end
   end
 end

data/lib/klam/compilation_stages/constantize_constructed_constants.rb

@@ -0,0 +1,63 @@
+module Klam
+  module CompilationStages
+    module ConstantizeConstructedConstants
+      def constantize_constructed_constants(sexp)
+        constant_bindings = []
+        converted_sexp = extract_constructed_constants(sexp, constant_bindings)
+        if constant_bindings.empty?
+          sexp
+        else
+          bind_constants(converted_sexp, constant_bindings)
+        end
+      end
+
+    private
+
+      def extract_constructed_constants(sexp, constant_bindings)
+        if sexp.kind_of?(Array)
+          if sexp.size == 3 && sexp[0] == :cons
+            hd_expr = extract_constructed_constants(sexp[1], constant_bindings)
+            tl_expr = extract_constructed_constants(sexp[2], constant_bindings)
+            converted_cons = [:cons, hd_expr, tl_expr]
+            if constant?(hd_expr) && constant?(tl_expr)
+              const = fresh_constant
+              constant_bindings << [const, converted_cons]
+              const
+            else
+              converted_cons
+            end
+          else
+            sexp.map do |expr|
+              extract_constructed_constants(expr, constant_bindings)
+            end
+          end
+        else
+          sexp
+        end
+      end
+
+      def bind_constants(sexp, bindings)
+        if sexp.kind_of?(Array) && sexp[0] == :defun
+          sexp[0] = :"[DEFUN-CLOSURE]"
+        end
+
+        until bindings.empty?
+          binding = bindings.pop
+          sexp = [:let, binding[0], binding[1], sexp]
+        end
+        sexp
+      end
+
+      def constant?(sexp)
+        case sexp
+        when FalseClass, TrueClass, String, Symbol, Numeric, Klam::Constant
+          true
+        when []
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/klam/compilation_stages/convert_self_tail_calls_to_loops.rb

@@ -75,17 +75,19 @@ module Klam
 
       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)]
+        loop_var = fresh_variable
+        body_with_loop = [:"[LOOP]", loop_var,
+                          insert_recur_into_expr(body, name, params,
+                                                 loop_var)]
         [rator, name, params, body_with_loop]
       end
 
-      def insert_recur_into_expr(sexp, name, params)
+      def insert_recur_into_expr(sexp, name, params, loop_var)
         if sexp.instance_of?(Array)
           case sexp[0]
           when name
             if sexp.length - 1 == params.length
-              [:"[RECUR]", params, sexp[1..-1]]
+              [:"[RECUR]", params, sexp[1..-1], loop_var]
             else
               sexp
             end
@@ -93,17 +95,18 @@ module Klam
             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)]
+             insert_recur_into_expr(true_expr, name, params, loop_var),
+             insert_recur_into_expr(false_expr, name, params, loop_var)]
           when :let
             rator, var, val_expr, body_expr = sexp
             [rator,
              var,
              val_expr,
-             insert_recur_into_expr(body_expr, name, params)]
+             insert_recur_into_expr(body_expr, name, params, loop_var)]
           when :do
             rator, first_expr, second_expr = sexp
-            [rator, first_expr, insert_recur_into_expr(second_expr, name, params)]
+            [rator, first_expr, insert_recur_into_expr(second_expr, name,
+                                                       params, loop_var)]
           else
             sexp
           end

data/lib/klam/compilation_stages/emit_ruby.rb

@@ -40,7 +40,7 @@ module Klam
           emit_symbol(sexp)
         when String
           emit_string(sexp)
-        when Klam::Variable, Numeric, true, false
+        when Klam::Constant, Klam::Variable, Numeric, true, false
           sexp.to_s
         when Array
           if sexp.empty?
@@ -68,6 +68,8 @@ module Klam
           emit_trap_error(form)
         when :do
           emit_do(form)
+        when :"[DEFUN-CLOSURE]"
+          emit_defun_closure(form)
         when :"[FIX-VARS]"
           emit_fix_vars(form)
         when :"[LOOP]"
@@ -129,7 +131,28 @@ module Klam
           @eigenclass.rename_method(:$4, $1)
           @arities[$1] = $5
           @curried_methods.delete($1)
-          @loop_cache.delete($1)
+          $1
+        EOT
+      end
+
+      def emit_defun_closure(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]/, '_')).intern
+        mangled_name_rb = emit_ruby(mangled_name)
+        render_string(<<-EOT, name_rb, params_rb, body_rb, mangled_name_rb, params.size)
+          @eigenclass.def_method($4, -> ($2) { $3 })
+          @eigenclass.rename_method($4, $1)
+          @arities[$1] = $5
+          @curried_methods.delete($1)
           $1
         EOT
       end
@@ -173,22 +196,36 @@ module Klam
       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)
+        _, loop_var, expr = form
+        val_var = fresh_variable
+
+        expr_rb = emit_ruby(expr)
+        loop_var_rb = emit_ruby(loop_var)
+        val_var_rb = emit_ruby(val_var)
+
+        render_string(<<-EOT, loop_var_rb, val_var_rb, expr_rb)
+          $1 = false
+          $2 = nil
+          begin
+            $1 = false
+            $2 = $3
+          end while $1
+          $2
+        EOT
       end
 
       def emit_recur(form)
-        _, params, new_value_exprs = form
+        _, params, new_value_exprs, loop_var = form
+        loop_var_rb = emit_ruby(loop_var)
+
         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)
+          render_string('(($1 = $2); $3 = true)', params_rb,
+                        new_value_exprs_rb, loop_var_rb)
         else
-          'redo'
+          render_string('$1 = true', loop_var_rb)
         end
       end
 

data/lib/klam/compiler.rb

@@ -16,12 +16,14 @@ module Klam
     include Klam::CompilationStages::ConvertPartialApplicationsToLambdas
     include Klam::CompilationStages::CurryAbstractionApplications
     include Klam::CompilationStages::MakeAbstractionsMonadic
+    include Klam::CompilationStages::ConstantizeConstructedConstants
     include Klam::CompilationStages::ConvertSelfTailCallsToLoops
     include Klam::CompilationStages::EmitRuby
 
     def initialize(environment)
       @environment = environment
-      @generator = Klam::VariableGenerator.new
+      @constant_generator = Klam::ConstantGenerator.new
+      @variable_generator = Klam::VariableGenerator.new
       @ruby_interop_syntax_enabled = false
     end
 
@@ -36,6 +38,7 @@ module Klam
         :convert_partial_applications_to_lambdas,
         :curry_abstraction_applications,
         :make_abstractions_monadic,
+        :constantize_constructed_constants,
         :convert_self_tail_calls_to_loops,
         :emit_ruby
       ]
@@ -66,11 +69,12 @@ module Klam
       @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_constant
+      @constant_generator.next
+    end
+
     def fresh_variable
-      @generator.next
+      @variable_generator.next
     end
   end
 end

data/lib/klam/constant.rb

@@ -0,0 +1,21 @@
+module Klam
+  class Constant
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    def ==(other)
+      other.kind_of?(Constant) && name == other.name
+    end
+
+    def hash
+      name.hash
+    end
+  end
+end

data/lib/klam/constant_generator.rb

@@ -0,0 +1,12 @@
+module Klam
+  class ConstantGenerator
+    def initialize
+      @index = 0
+    end
+
+    def next
+      @index += 1
+      Klam::Constant.new('__KLAMC_%03d' % @index)
+    end
+  end
+end

data/lib/klam/environment.rb

@@ -23,7 +23,6 @@ module Klam
 
       @arities = ::Hash.new { |h, k| h[k] = __arity(k) }
       @curried_methods = ::Hash.new { |h, k| h[k] = __method(k).to_proc.curry }
-      @loop_cache = {}
 
       # Grab a handle to this object's eigenclass for use later when the
       # compiled code needs to reference it. It is used, e.g., when renaming
@@ -58,6 +57,11 @@ module Klam
     end
 
     class << self
+      # Define method is private, so open it up
+      def def_method(name, proc)
+        define_method(name, proc)
+      end
+
       def rename_method(old_name, new_name)
         alias_method(new_name, old_name)
         remove_method(old_name)

data/lib/klam/variable_generator.rb

@@ -6,7 +6,7 @@ module Klam
 
     def next
       @index += 1
-      Klam::Variable.new('__KLAM_%03d' % @index)
+      Klam::Variable.new('__KLAMV_%03d' % @index)
     end
   end
 end

data/lib/klam/version.rb

@@ -1,3 +1,3 @@
 module Klam
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/spec/functional/extensions/interop_spec.rb

@@ -17,11 +17,14 @@ describe 'extension: Ruby interop primitives', :type => :functional do
       eval_kl('(set vec (absvector 2))')
       result = eval_kl <<-EOKL
         (let V (absvector 2)
-          (do (rb-send-block (cons 1 (cons 2 ())) each_with_index
+          (do (rb-send-block (cons 37 (cons 42 ())) each_with_index
                              (lambda X (lambda Y (address-> V Y X))))
               V))
       EOKL
-      expect(result).to eq([1, 2])
+      expected = Klam::Absvector.new(2)
+      expected.store(0, 37)
+      expected.store(1, 42)
+      expect(result).to eq(expected)
     end
 
     it 'supports symbols as blocks' do

data/spec/unit/klam/absvector_spec.rb

@@ -4,9 +4,9 @@ describe Klam::Absvector do
   describe '#to_a' do
     it 'skips the first element' do
       a = Klam::Absvector.new(3)
-      a[0] = 1
-      a[1] = 2
-      a[2] = 3
+      a.store(0, 1)
+      a.store(1, 2)
+      a.store(2, 3)
       expect(a.to_a).to eq([2,3])
     end
   end
@@ -14,9 +14,9 @@ describe Klam::Absvector do
   describe '#each' do
     it 'skips the first element' do
       a = Klam::Absvector.new(3)
-      a[0] = 1
-      a[1] = 2
-      a[2] = 3
+      a.store(0, 1)
+      a.store(1, 2)
+      a.store(2, 3)
       b = []
       a.each { |x| b << x }
       expect(b).to eq([2,3])

data/spec/unit/klam/compilation_stages/constantize_constructed_constants_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+
+describe Klam::CompilationStages::ConstantizeConstructedConstants do
+  include Klam::CompilationStages::ConstantizeConstructedConstants
+
+  # ConstantizeConstructedConstants requires this function to be defined
+  # by its including class.
+  def fresh_constant
+    @generator.next
+  end
+
+  def reset_generator
+    @generator = Klam::ConstantGenerator.new
+  end
+
+  before(:each) do
+    reset_generator
+  end
+
+  it 'constantizes lists of constants' do
+    const1 = fresh_constant
+    const2 = fresh_constant
+    expr = [:defun, :f, [],
+             [:cons, 1, [:cons, 2, []]]]
+
+    expected = [:let, const1, [:cons, 2, []],
+                 [:let, const2, [:cons, 1, const1],
+                   [:"[DEFUN-CLOSURE]", :f, [],
+                     const2]]]
+
+    reset_generator
+    expect(constantize_constructed_constants(expr)).to eq(expected)
+  end
+end

data/spec/unit/klam/compilation_stages/convert_self_tail_calls_to_loops_spec.rb

@@ -2,32 +2,48 @@ require 'spec_helper'
 
 describe Klam::CompilationStages::ConvertSelfTailCallsToLoops do
   include Klam::CompilationStages::ConvertSelfTailCallsToLoops
+
+  # ConvertSelfTailCallsToLoops requires this function to be defined
+  # by its including class.
+  def fresh_variable
+    @generator.next
+  end
+
+  def reset_generator
+    @generator = Klam::VariableGenerator.new
+  end
+
+  before(:each) do
+    reset_generator
+  end
+
   it 'converts self tail calls to loop/recur' do
-    # For simplicity the vars below are symbols, but will be
-    # Klam::Variables in practice. They do not come into play for
-    # the conversion, though.
+    loop_var = fresh_variable
     expr = [:defun, :f, [:X, :Y],
              [:if, true,
                [:f, 7, 8],
                [:let, :Z, 37,
                  [:f, :Z, 99]]]]
     expected = [:defun, :f, [:X, :Y],
-                 [:"[LOOP]", :f, [:X, :Y],
+                 [:"[LOOP]", loop_var,
                    [:if, true,
-                     [:"[RECUR]", [:X, :Y], [7, 8]],
+                     [:"[RECUR]", [:X, :Y], [7, 8], loop_var],
                      [:let, :Z, 37,
-                      [:"[RECUR]", [:X, :Y], [:Z, 99]]]]]]
+                      [:"[RECUR]", [:X, :Y], [:Z, 99], loop_var]]]]]
 
+    reset_generator
     expect(convert_self_tail_calls_to_loops(expr)).to eq(expected)
   end
 
   it 'does not convert partial calls' do
+    loop_var = fresh_variable
     expr = [:defun, :f, [:X, :Y],
              [:f, :X]]
     expected = [:defun, :f, [:X, :Y],
-                 [:"[LOOP]", :f, [:X, :Y],
+                 [:"[LOOP]", loop_var,
                    [:f, :X]]]
 
+    reset_generator
     expect(convert_self_tail_calls_to_loops(expr)).to eq(expected)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: klam
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Greg Spurrier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-25 00:00:00.000000000 Z
+date: 2015-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -111,6 +111,7 @@ files:
 - lib/klam.rb
 - lib/klam/absvector.rb
 - lib/klam/compilation_stages.rb
+- lib/klam/compilation_stages/constantize_constructed_constants.rb
 - lib/klam/compilation_stages/convert_freezes_to_lambdas.rb
 - lib/klam/compilation_stages/convert_lexical_variables.rb
 - lib/klam/compilation_stages/convert_partial_applications_to_lambdas.rb
@@ -124,6 +125,8 @@ files:
 - lib/klam/compilation_stages/strip_type_declarations.rb
 - lib/klam/compiler.rb
 - lib/klam/cons.rb
+- lib/klam/constant.rb
+- lib/klam/constant_generator.rb
 - lib/klam/converters.rb
 - lib/klam/converters/.list.rb.swp
 - lib/klam/converters/list.rb
@@ -159,6 +162,7 @@ files:
 - spec/functional/tail_call_optimization_spec.rb
 - spec/spec_helper.rb
 - spec/unit/klam/absvector_spec.rb
+- spec/unit/klam/compilation_stages/constantize_constructed_constants_spec.rb
 - spec/unit/klam/compilation_stages/convert_lexical_variables_spec.rb
 - spec/unit/klam/compilation_stages/convert_self_tail_calls_to_loops_spec.rb
 - spec/unit/klam/compilation_stages/curry_abstraction_applications_spec.rb
@@ -213,6 +217,7 @@ test_files:
 - spec/functional/tail_call_optimization_spec.rb
 - spec/spec_helper.rb
 - spec/unit/klam/absvector_spec.rb
+- spec/unit/klam/compilation_stages/constantize_constructed_constants_spec.rb
 - spec/unit/klam/compilation_stages/convert_lexical_variables_spec.rb
 - spec/unit/klam/compilation_stages/convert_self_tail_calls_to_loops_spec.rb
 - spec/unit/klam/compilation_stages/curry_abstraction_applications_spec.rb