lasp 0.8.0 → 0.9.0

data/lib/lasp/stdmacros.lasp

@@ -8,6 +8,7 @@
          (list 'def name
                (list 'macro params body))))
 
+
 ; Shorthand for defining functions
 ;
 ;   (defn f (x) (+ x 1))
@@ -18,6 +19,36 @@
   (list 'def name
         (list 'fn params (cons 'do body))))
 
+
+; Creates local bindings.
+;
+; It does this by (ab)using closures. It rewrites the form as a recursively
+; nested tree of functions, declaring parameters and instantly executing the
+; function passing in corresponding arguments. This should be considered an
+; implementation detail, let can (and should) be used without knowledge or
+; regard to that it creates closures behind the scenes.
+
+; Example:
+;     (let (one 1
+;           two (+ one 1)) ; Previous bindings are available
+;       (+ one two))
+;     ; => 3
+;
+; expands to:
+;     ((fn (one) ((fn (two) (do (+ one two))) (+ one 1))) 1)
+(defn let*
+  (bindings body)
+  (if (empty? bindings)
+    (cons 'do body)
+    (list
+      (list 'fn (list (first bindings)) (let* (drop 2 bindings) body))
+      (second bindings))))
+
+(defm let
+  (bindings & body)
+  (let* bindings body))
+
+
 ; See unevaluated form the macro expands to for debugging macros
 ;
 ; This simply uses the fact that `apply` already has this effect

data/lib/lasp/version.rb

@@ -1,3 +1,3 @@
 module Lasp
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Jimmy Börjesson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-04 00:00:00.000000000 Z
+date: 2016-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -48,6 +48,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - CHANGELOG.md
+- DOCUMENTATION.md
 - EXAMPLES.md
 - Gemfile
 - LICENSE.txt
@@ -59,14 +60,13 @@ files:
 - lib/lasp/corelib.rb
 - lib/lasp/env.rb
 - lib/lasp/errors.rb
-- lib/lasp/eval.rb
+- lib/lasp/ext.rb
 - lib/lasp/fn.rb
+- lib/lasp/interpreter.rb
 - lib/lasp/macro.rb
-- lib/lasp/parameters.rb
 - lib/lasp/params.rb
 - lib/lasp/parser.rb
 - lib/lasp/repl.rb
-- lib/lasp/representation.rb
 - lib/lasp/stdlib.lasp
 - lib/lasp/stdmacros.lasp
 - lib/lasp/version.rb

data/lib/lasp/eval.rb

@@ -1,66 +0,0 @@
-require "lasp/env"
-require "lasp/fn"
-require "lasp/macro"
-
-module Lasp
-  module_function
-
-  def eval(form, env)
-    case form
-    when Symbol then env.fetch(form)
-    when Array  then eval_form(form, env)
-    else form
-    end
-  end
-
-  def eval_form(form, env)
-    head, *tail = *form
-
-    case head
-    when :def   then def_special_form(tail, env)
-    when :fn    then fn_special_form(tail, env)
-    when :do    then do_special_form(tail, env)
-    when :if    then if_special_form(tail, env)
-    when :quote then quote_special_form(tail, env)
-    when :macro then macro_special_form(tail, env)
-    else call_function(head, tail, env)
-    end
-  end
-
-  def call_function(symbol, args, env)
-    fn = Lasp::eval(symbol, env)
-
-    case fn
-    when Macro then Lasp::eval(fn.(*args), env)
-    else fn.(*args.map { |form| Lasp::eval(form, env) })
-    end
-  end
-
-  def def_special_form(form, env)
-    key, value = form
-    env[key] = Lasp::eval(value, env)
-  end
-
-  def fn_special_form(form, env)
-    params, func = form
-    Fn.new(params, func, env)
-  end
-
-  def do_special_form(form, env)
-    form.map { |form| Lasp::eval(form, env) }.last
-  end
-
-  def if_special_form(form, env)
-    conditional, true_form, false_form = form
-    Lasp::eval(conditional, env) ? Lasp::eval(true_form, env) : Lasp::eval(false_form, env)
-  end
-
-  def quote_special_form(form, _)
-    form.first
-  end
-
-  def macro_special_form(form, env)
-    params, func = form
-    Macro.new(params, func, env)
-  end
-end

data/lib/lasp/parameters.rb

@@ -1,93 +0,0 @@
-module Lasp
-  module Parameters
-    def self.new(params)
-      if params.include?(:&)
-        RestParameters.new(params)
-      else
-        FixedParameters.new(params)
-      end
-    end
-
-    class FixedParameters
-      attr_reader :parameter_list
-
-      def initialize(parameter_list)
-        @parameter_list = parameter_list
-        valid_signature!
-      end
-
-      def to_h(args)
-        enforce_arity!(args)
-        Hash[parameter_list.zip(args)]
-      end
-
-      def to_s
-        "(" + parameter_list.join(" ") + ")"
-      end
-
-      private
-
-      def enforce_arity!(args)
-        if args.count != arity
-          fail ArgumentError, "wrong number of arguments (#{args.count} for #{arity})"
-        end
-      end
-
-      def valid_signature!
-        if duplicate_parameter?
-          fail SyntaxError, "Parameter names have to be unique. a is used more than once"
-        end
-      end
-
-      def duplicate_parameter?
-        parameter_list.uniq.length != parameter_list.length
-      end
-
-      def arity
-        parameter_list.count
-      end
-    end
-
-    class RestParameters < FixedParameters
-      def to_h(args)
-        enforce_arity!(args)
-
-        ordered = parameter_list[0, minimum_arguments]
-        rest    = parameter_list.last
-
-        env = ordered.zip(args.take(ordered.length))
-        env << [ rest, args.drop(ordered.length) ]
-
-        Hash[env]
-      end
-
-      private
-
-      def valid_signature!
-        if multiple_rest_arguments? || ampersand_not_second_to_last?
-          fail SyntaxError, "Rest-arguments may only be used once, at the end, with a single binding."
-        end
-        super
-      end
-
-      def multiple_rest_arguments?
-        parameter_list.select { |b| b == :& }.length > 1
-      end
-
-      def ampersand_not_second_to_last?
-        parameter_list.find_index(:&) != minimum_arguments
-      end
-
-      def minimum_arguments
-        parameter_list.count - 2
-      end
-
-      def enforce_arity!(args)
-        if args.count < minimum_arguments
-          fail ArgumentError, "wrong number of arguments (#{args.count} for #{minimum_arguments}+)"
-        end
-      end
-    end
-
-  end
-end

data/lib/lasp/representation.rb

@@ -1,17 +0,0 @@
-class Array
-  def inspect
-    "(#{ map(&:inspect).join(" ") })"
-  end
-end
-
-class Symbol
-  def inspect
-    to_s
-  end
-end
-
-class Hash
-  def inspect
-    "{#{ map { |pair| pair.map(&:inspect).join(" ")}.join(", ") }}"
-  end
-end