klam 0.0.1

data/lib/klam/primitives/lists.rb

@@ -0,0 +1,23 @@
+module Klam
+  module Primitives
+    module Lists
+      EMPTY_LIST = nil
+
+      def cons(head, tail)
+        ::Klam::Cons.new(head, tail)
+      end
+
+      def hd(l)
+        l.hd
+      end
+
+      def tl(l)
+        l.tl
+      end
+
+      def cons?(l)
+        l.instance_of?(::Klam::Cons)
+      end
+    end
+  end
+end

data/lib/klam/primitives/streams.rb

@@ -0,0 +1,32 @@
+module Klam
+  module Primitives
+    module Streams
+      def read_byte(stream)
+        if stream.eof?
+          -1
+        else
+          stream.readbyte
+        end
+      end
+      alias_method :"read-byte", :read_byte
+      remove_method :read_byte
+
+      def write_byte(byte, stream)
+        stream.putc byte
+        byte
+      end
+      alias_method :"write-byte", :write_byte
+      remove_method :write_byte
+
+      def open(name, direction)
+        ::File.open(::File.expand_path(name, value(:'*home-directory*')),
+                    direction == :out ? 'w' : 'r')
+      end
+
+      def close(stream)
+        stream.close
+        :NIL
+      end
+    end
+  end
+end

data/lib/klam/primitives/strings.rb

@@ -0,0 +1,58 @@
+module Klam
+  module Primitives
+    module Strings
+      def pos(str, n)
+        if n < 0 || n >= str.length
+          ::Kernel.raise ::Klam::Error, "index out of bounds: #{n}"
+        end
+        str[n]
+      end
+
+      def tlstr(str)
+        if str.empty?
+          ::Kernel.raise ::Klam::Error, 'attempted to take tail of empty string'
+        end
+        str[1..-1]
+      end
+
+      def cn(s1, s2)
+        s1 + s2
+      end
+
+      def str(x)
+        case x
+        when String
+          '"' + x + '"'
+        when Symbol
+          x.to_s
+        when Numeric
+          x.to_s
+        when TrueClass, FalseClass
+          x.to_s
+        when Proc
+          x.to_s
+        when IO
+          x.to_s
+        else
+          ::Kernel.raise ::Klam::Error, "str applied to non-atomic type: #{x.class}"
+        end
+      end
+
+      def string?(x)
+        x.kind_of?(String)
+      end
+
+      def n_to_string(n)
+        '' << n
+      end
+      alias_method :"n->string", :n_to_string
+      remove_method :n_to_string
+
+      def string_to_n(str)
+        str.ord
+      end
+      alias_method :"string->n", :string_to_n
+      remove_method :string_to_n
+    end
+  end
+end

data/lib/klam/primitives/symbols.rb

@@ -0,0 +1,16 @@
+module Klam
+  module Primitives
+    module Symbols
+      def intern(str)
+        case str
+        when 'true'
+          true
+        when 'false'
+          false
+        else
+          str.intern
+        end
+      end
+    end
+  end
+end

data/lib/klam/primitives/time.rb

@@ -0,0 +1,19 @@
+module Klam
+  module Primitives
+    module Time
+      def get_time(type)
+        case type
+        when :real, :run
+          ::Time.now.to_f
+        when :unix
+          ::Time.now.to_i
+        else
+          ::Kernel.raise ::Klam::Error, "invalid time parameter: #{type}"
+        end
+
+      end
+      alias_method :"get-time", :get_time
+      remove_method :get_time
+    end
+  end
+end

data/lib/klam/primitives/vectors.rb

@@ -0,0 +1,26 @@
+module Klam
+  module Primitives
+    module Vectors
+      def absvector(n)
+        ::Array.new(n)
+      end
+
+      def absvec_store(vec, n, val)
+        vec[n] = val
+        vec
+      end
+      alias_method :"address->", :absvec_store
+      remove_method :absvec_store
+
+      def absvec_read(vec, n)
+        vec[n]
+      end
+      alias_method :"<-address", :absvec_read
+      remove_method :absvec_read
+
+      def absvector?(v)
+        v.instance_of?(::Array)
+      end
+    end
+  end
+end

data/lib/klam/reader.rb

@@ -0,0 +1,46 @@
+module Klam
+  class Reader
+    include Klam::Converters::List
+
+    def initialize(stream)
+      @lexer = Klam::Lexer.new(stream)
+    end
+
+    def next
+      token = @lexer.next
+      unless token.nil?
+        if token.kind_of? Klam::Lexer::OpenParen
+          read_list
+        else
+          token
+        end
+      end
+    end
+
+  private
+
+    def read_list
+      items = []
+      stack = [items]
+
+      until stack.empty? do
+        token = @lexer.next
+        raise Klam::SyntaxError, 'Unterminated list' if token.nil?
+        case token
+        when Klam::Lexer::OpenParen
+          items = []
+          stack.push items
+        when Klam::Lexer::CloseParen
+          array = stack.pop
+          unless stack.empty?
+            items = stack.last
+            items << array
+          end
+        else
+          items << token
+        end
+      end
+      arrayToList(array)
+    end
+  end
+end

data/lib/klam/template.rb

@@ -0,0 +1,38 @@
+module Klam
+  module Template
+    def render_string(template, *args)
+      args = join_array_arguments(args)
+      segments = segment_string(template)
+      segments.map do |segment|
+        if segment =~ /^\$(\d+)$/
+          args[$1.to_i - 1]
+        else
+          segment
+        end
+      end.join
+    end
+
+  private
+
+    def join_array_arguments(args)
+      args.map do |arg|
+        if arg.kind_of?(Array)
+          arg.join(',')
+        else
+          arg
+        end
+      end
+    end
+    def segment_string(str)
+      segments = []
+      pre, placeholder, str = str.partition(/\$\d+/)
+      until placeholder.empty? && str.empty?
+        segments << pre
+        segments << placeholder
+        pre, placeholder, str = str.partition(/\$\d+/)
+      end
+      segments << pre
+      segments
+    end
+  end
+end

data/lib/klam/variable.rb

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

data/lib/klam/variable_generator.rb

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

data/lib/klam/version.rb

@@ -0,0 +1,3 @@
+module Klam
+  VERSION = '0.0.1'
+end

data/spec/functional/application_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe 'Application', :type => :functional do
+  describe 'of functions' do
+    describe 'when all arguments are provided' do
+      it 'returns the result of applying the function to its arguments' do
+        eval_kl('(defun add (A B) (+ A B))')
+        expect_kl('(add 2 3)').to eq(5)
+      end
+    end
+
+    describe 'when not all arguments are provided' do
+      before(:each) do
+        eval_kl('(defun add3 (A B C) (+ (+ A B) C))')
+      end
+
+      it 'returns a function' do
+        expect_kl('(add3 1)').to be_kind_of(Proc)
+      end
+
+      it 'evaluates once all of the arguments are provided' do
+        expect_kl('((add3 1) 2 3)').to eq(6)
+      end
+
+      it 'allows further partial application' do
+        expect_kl('(((add3 1) 2) 3)').to eq(6)
+      end
+    end
+
+    describe 'uncurrying' do
+      before(:each) do
+        eval_kl('(defun add3 (A) (lambda B (lambda C (+ (+ A B) C))))')
+      end
+
+      it 'provides the equivalent behavior to defining a polyadic function' do
+        expect_kl('(add3 1 2 3)').to eq(6)
+        expect_kl('((add3 1 2) 3)').to eq(6)
+        expect_kl('((add3 1) 2 3)').to eq(6)
+      end
+    end
+
+    describe 'when the function takes no arguments' do
+      it 'returns the result of evaluating the function\'s body' do
+        eval_kl('(defun thirty-seven () 37)')
+        expect_kl('(thirty-seven)').to eq(37)
+      end
+    end
+  end
+
+  describe 'of abstractions' do
+    describe 'when applied directly' do
+      it 'returns the result of applying the abstraction to its argument' do
+        expect_kl('((lambda X (+ X 3)) 2)').to eq(5)
+      end
+
+      it 'uncurries additional arguments' do
+        expect_kl('((lambda A (lambda B (lambda C (+ (+ A B) C)))) 1 2 3)')
+          .to eq(6)
+      end
+    end
+
+    describe 'when returned from another function' do
+      it 'returns the result of applying the returned abstraction to its arg' do
+        eval_kl('(defun make-adder (X) (lambda Y (+ X Y)))')
+        expect_kl('((make-adder 3) 2)').to eq(5)
+      end
+    end
+  end
+
+  describe "of variables" do
+    describe "when bound to functions" do
+      describe 'when applied directly' do
+        it 'returns the result of applying the abstraction to its argument' do
+          expect_kl('(let F (lambda X (+ X 3)) (F 2))').to eq(5)
+        end
+
+        it 'uncurries additional arguments' do
+          expect_kl('(let F (lambda A (lambda B (lambda C (+ (+ A B) C)))) (F 1 2 3))')
+            .to eq(6)
+        end
+      end
+    end
+
+    describe "when bound to symbols" do
+      it 'invokes the function bound to the symobl in the global environment' do
+        expect_kl('(let F + (F 1 2))').to eq(3)
+      end
+
+      it 'supports partial evaluation' do
+        expect_kl('(let F + ((F 1) 2))').to eq(3)
+      end
+    end
+  end
+end

data/spec/functional/atoms_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'Atoms', :type => :functional do
+  describe 'numbers' do
+    it 'integers evaluate to themselves' do
+      expect_kl('37').to eq(read_kl('37'))
+    end
+
+    it 'reals evaluate to themselves' do
+      expect_kl('37.42').to eq(read_kl('37.42'))
+    end
+  end
+
+  describe 'symbols' do
+    it 'evaluate to themselves' do
+      expect_kl('sym').to eq(read_kl('sym'))
+    end
+
+    it 'supports the full range of initial symbol characters' do
+      # See http://www.shenlanguage.org/learn-shen/shendoc.htm#The%20Syntax%20of%20Symbols
+      all_chars = 'abcdefghijklmnopqrstuvwxyz'
+      all_chars += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+      all_chars += "=-*/+_?$!@~.><&%'#`;:{}"
+
+      all_chars.each_char do |c|
+        expect_kl(c).to eq(read_kl(c))
+      end
+    end
+  end
+
+  describe 'strings' do
+    it 'evaluate to themselves' do
+      expect_kl('"a string"').to eq(read_kl('"a string"'))
+    end
+
+    it 'supports embedded single quotes' do
+      expect_kl('"\'quote\'"').to eq(read_kl('"\'quote\'"'))
+    end
+  end
+
+  describe 'booleans' do
+    it 'evaluates true to itself' do
+      expect_kl('true').to eq(read_kl('true'))
+    end
+
+    it 'evaluates false to itself' do
+      expect_kl('false').to eq(read_kl('false'))
+    end
+  end
+
+  describe 'empty list' do
+    it 'evaluates to itself' do
+      expect_kl('()').to be(Klam::Primitives::Lists::EMPTY_LIST)
+    end
+  end
+end