iode 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10252bb4757e9c4d3cdbb7177e142418f392b212
+  data.tar.gz: 75522eef2c8d52839309381993811fc5e365053d
+SHA512:
+  metadata.gz: a3f403e1b8149bc875d8e32f3d20745143bfbc68d55568038c4077ac1745f528f2bfc6fe33e63d659fac713c665d04db0539203ede36a0e156549d4597dc9687
+  data.tar.gz: efe9309b7b749a962c1456f282f1c634b611e854f82111c126d9ecb067e706ed616d4d9f87639925bd9f931cf4f4fee0b246ae3aea26de5672498a957a21add5

data/README.md

@@ -63,31 +63,106 @@ Of course, functions can be defined recursively too.
 ``` lisp
 ;; Recursive function example.
 (def loop
-     (lambda (n)
-       (if (= n 0)
-         (quote done)
-         (progn
-           (puts n)
-           (loop (- n 1))))))
+ (lambda (n)
+   (if (= n 0)
+     (quote done)
+     (progn
+       (puts n)
+       (loop (- n 1))))))
 
 (loop 20)
 ```
 
-The above code will print 20 through 1 to the screen and finally return the
-Symbol `:done` to Ruby (quoted Iode Symbols are also Ruby Symbols). Note that
-I haven't yet done tail call elimination.
-
 Similarly, closures can be returned from functions.
 
 ``` lisp
-;; Provides partial application of a function
-(def curry
-     (lambda (fn a)
-       (lambda (b) (fn a b))))
+(def dec
+ (lambda (n)
+   (- n 1)))
+
+(def expt
+ (lambda (n x)
+   (if (= x 0)
+      1
+      (* n (expt n (dec x))))))
+
+(def make-expt-fn
+ (lambda (x)
+   (lambda (n) (expt n x))))
+
+(def square
+ (make-expt-fn 2))
+
+(def cube
+ (make-expt-fn 3))
+
+(puts (square 4))
+(puts (cube 4))
+```
+
+Or something that updates some internal state.
+
+``` lisp
+(def make-counter
+ (lambda (n)
+   (lambda () (set! n (inc n)))))
+
+(def counter
+ (make-counter 0))
+
+(puts (counter)) ; 1
+(puts (counter)) ; 2
+(puts (counter)) ; 3
+(puts (counter)) ; 4
+```
+
+#### Macros
+
+Yes, iode has macros. In fact, very powerful macros. You can think of macros in
+the same way you think about lambdas. They are 100% first-class to iode and
+have values that can be assigned to variables, passed into functions etc. Like
+lambdas, they also provide a lexical closure over their environment. The
+difference between a macro and a lambda is that a macro receives unevaluated
+*code* as input and produces *code* as output.
+
+The syntax for returning code is a little cumbersome at this point, since I
+haven't yet added quasiquoting to provide that magical "templating" that lisps
+offer. Lots of `list` and `quote` for now. Quasiquoting is coming, however.
+
+Since iode doesn't yet have a `let` form, let's make our own with a macro.
+
+``` lisp
+(def cadr
+ (lambda (v) (car (cdr v))))
+
+(def let
+ (macro (bindings body)
+   (list
+    (quote apply)
+    (list (quote lambda)
+          (map car bindings)
+          body)
+     (map cadr bindings))))
+
+(let ((x 7)
+      (y 8))
+  (puts (* x y)))
+```
 
-((curry + 2) 3) ; 5
+Note that the body of the macro in this version must be a single s-expression,
+since variadic arguments are not yet implemented in the language. You may use
+a `progn`, however.
+
+``` lisp
+(let ((x 7)
+      (y 8))
+  (progn
+    (puts (str "x = " x))
+    (puts (str "y = " y))
+    (puts (str "x * y = " (* x y)))))
 ```
 
+Macros as values are a powerful feature of iode.
 
 ### In Ruby Code
 

data/lib/iode.rb

@@ -18,8 +18,11 @@ require "iode/version"
 require "iode/core/comparisons"
 require "iode/core/lists"
 require "iode/core/math"
+require "iode/core/strings"
 require "iode/core/output"
 require "iode/scope"
+require "iode/lambda"
+require "iode/macro"
 require "iode/interpreter"
 require "iode/reader"
 

data/lib/iode/core/lists.rb

@@ -32,6 +32,10 @@ module Iode
         _, *v = list
         v
       end
+
+      def map(fn, list)
+        list.map(&fn)
+      end
     end
   end
 end

data/lib/iode/core/output.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 require "iode/core"
+require "pp"
 
 module Iode
   module Core
@@ -26,6 +27,10 @@ module Iode
       def p(*args, &block)
         Kernel.p(*args, &block)
       end
+
+      def pp(*args, &block)
+        Kernel.pp(*args, &block)
+      end
     end
   end
 end

data/lib/iode/core/strings.rb

@@ -0,0 +1,31 @@
+# iode: core/lists.rb
+# 
+# Copyright 2014 Chris Corbyn <chris@w3style.co.uk>
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Iode
+  module Core
+    module Strings
+      def str(*args)
+        args.map(&:to_s).join
+      end
+
+      def format(s, *args)
+        s % args
+      end
+    end
+  end
+end
+
+Iode::Core.register Iode::Core::Strings

data/lib/iode/interpreter.rb

@@ -63,7 +63,7 @@ module Iode
       sexps.inject(nil){|_,s| eval(s)}
     end
 
-    # Create a new lambda for Iode.
+    # Create a new lambda.
     #
     # These lambdas act as closures in their environment.
     #
@@ -73,10 +73,31 @@ module Iode
     # @param [Object...] *sexps
     #   variadic list of S-Expressions for the body
     #
-    # @return [Proc]
+    # @return [Lambda]
     #   a callable lambda
     def lambda(argnames, *sexps)
-      Proc.new do |*args|
+      Lambda.new do |*args|
+        Interpreter.new(
+          @env.push_scope(Hash[argnames.zip(args)])
+        ).progn(*sexps)
+      end
+    end
+
+    # Create a new macro.
+    #
+    # Macros are acually just a special case of lambda and also close their
+    # environment and can be passed as arguments.
+    #
+    # @param [Array] argnames
+    #   a list of argument names as macro inputs
+    #
+    # @param [Object...] *sexps
+    #   variadic list of S-Expressions for the body
+    #
+    # @return [Macro]
+    #   a callable macro
+    def macro(argnames, *sexps)
+      Macro.new do |*args|
         Interpreter.new(
           @env.push_scope(Hash[argnames.zip(args)])
         ).progn(*sexps)
@@ -116,6 +137,8 @@ module Iode
           nil
         when :quote
           car(cdr(sexp))
+        when :quasiquote
+          car(cdr(sexp))
         when :if
           if eval(car(cdr(sexp)))
             eval(car(cdr(cdr(sexp))))
@@ -130,8 +153,18 @@ module Iode
           @env.define(car(cdr(sexp)), eval(car(cdr(cdr(sexp)))))
         when :lambda
           lambda(car(cdr(sexp)), *cdr(cdr(sexp)))
+        when :macro
+          macro(car(cdr(sexp)), *cdr(cdr(sexp)))
+        when :apply
+          eval([car(cdr(sexp)), *car(cdr(cdr(sexp)))])
         else
-          apply(eval(car(sexp)), cdr(sexp).map(&method(:eval)))
+          callee = eval(car(sexp))
+          case callee
+          when Macro
+            eval(apply(callee, cdr(sexp)))
+          else
+            apply(callee, cdr(sexp).map(&method(:eval)))
+          end
         end
       when Symbol
         @env[sexp]

data/lib/iode/lambda.rb

@@ -0,0 +1,21 @@
+# iode: lambda.rb
+# 
+# Copyright 2014 Chris Corbyn <chris@w3style.co.uk>
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Iode
+  # Class that represents a lambda function in iode.
+  class Lambda < Proc
+  end
+end

data/lib/iode/macro.rb

@@ -0,0 +1,21 @@
+# iode: macro.rb
+# 
+# Copyright 2014 Chris Corbyn <chris@w3style.co.uk>
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Iode
+  # Class that represents a macro function in iode.
+  class Macro < Lambda
+  end
+end

data/lib/iode/reader.rb

@@ -28,6 +28,7 @@ module Iode
     # syntax
     rule("(")
     rule(")")
+    rule("'")
 
     # fractions as literals
     rule(:rational => /[0-9]+\/[0-9]+/).as{|n| Rational(n)}
@@ -43,7 +44,7 @@ module Iode
     end
 
     # variables/symbols
-    rule(symbol: /[^\(\)\s;]+/).as do |v|
+    rule(symbol: /[^\(\)\s;'"`:]+/).as do |v|
       case v
       when "nil"
         nil
@@ -75,6 +76,7 @@ module Iode
     # s-exprs
     rule(:sexp) do |r|
       r[:atom]
+      r["'", :sexp].as           {|_, sexp| [:quote, sexp]}
       r["(", :sexp_list, ")"].as {|_, list, _| list}
     end
 

data/lib/iode/version.rb

@@ -15,5 +15,5 @@
 # limitations under the License.
 
 module Iode
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iode
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 0.0.4
 platform: ruby
 authors:
 - Chris Corbyn
@@ -14,55 +13,50 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: whittle
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.8
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "  Iode is a work in progress real language on LLVM.\n  This Ruby Gem
-  exists solely so the author can experiment with new language\n  features before
-  committing those ideas to the real language. It is not\n  intended for general use,
-  nor is it intended to be fast or concise.\n"
+description: |2
+    Iode is a work in progress real language on LLVM.
+    This Ruby Gem exists solely so the author can experiment with new language
+    features before committing those ideas to the real language. It is not
+    intended for general use, nor is it intended to be fast or concise.
 email:
 - chris@w3style.co.uk
 executables:
@@ -70,7 +64,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -83,33 +77,35 @@ files:
 - lib/iode/core/lists.rb
 - lib/iode/core/math.rb
 - lib/iode/core/output.rb
+- lib/iode/core/strings.rb
 - lib/iode/interpreter.rb
+- lib/iode/lambda.rb
+- lib/iode/macro.rb
 - lib/iode/reader.rb
 - lib/iode/scope.rb
 - lib/iode/version.rb
 homepage: https://github.com/d11wtq/iode-rb
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An experimental lisp-family language hosted on Ruby
 test_files: []