iode 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88c450a99b55f2e4e32ba2889a229da5efc6f37c
-  data.tar.gz: 00e32521320732d46ce067b49dcb53c6594cd7b0
+  metadata.gz: ef8311e9162a113a3aff4d5741524ac2bd6eafcb
+  data.tar.gz: 56634c23acfedee8d05d6bc38a78392dc9df0865
 SHA512:
-  metadata.gz: 8fc46489cacd07abc6d46c574040f3643aef9f99e7ff5176a9bf47b8c08c8d23cc3ffe954917c0fe81709987b088779d41be2ea360829c009c5768124c2cc7ed
-  data.tar.gz: 20b0ead4cbbaf356c768acb45965a423907ee2acee8a7a57a82404c1f5cc9722e9b83c78dda32643e08b0131175b2a503af2822505b13053d8c09d5fb4e53661
+  metadata.gz: 295055612ba622c3f84503f957e996a9996f32201bf934c571c63a17c93144dad7fe7fa206abfe469c5f4dc0e34262c12f1b19a9e69c24dabe9a9c401a25f837
+  data.tar.gz: fc8b1824b95dbf0583917390f64b4df9614f320e4d0c972d6c8e8d81f84518a9be58d5b2e570feaaf13d5178efddbbb6edee38f0368e03a9cda27be6a6455db9

data/README.md

@@ -53,11 +53,13 @@ with Ruby.
 ``` ruby
 require "iode"
 
-puts Iode.run <<-PROG
+result = Iode.run <<-PROG
 (if ((lambda (x) x) false)
   "x = true"
   "x = false")
 PROG
+
+puts result
 ```
 
 The above code creates a lambda function that simply acts like the identity
@@ -65,7 +67,7 @@ function (i.e. it returns its input). That lambda is then immediately applied
 with the input `false`, thereby returning `false`.
 
 The `if` form evaluates false and therefore evaluates the else part of the
-`if`, returning the string `"x = false"`.
+`if`, returning the string "x = false".
 
 Here's another example showing how you can pass values from Ruby into Iode.
 
@@ -75,12 +77,12 @@ require "iode"
 prog = Iode.run <<-PROG
 (lambda (x)
   (if x
-    42
-    7))
+    (puts 42)
+    (puts 7)))
 PROG
 
-prog[false] #=> 7
-prog[true]  #=> 42
+prog.call(false) #=> 7
+prog.call(true)  #=> 42
 ```
 
 This works because internally, Iode lambdas as represented as Ruby Procs.
@@ -93,18 +95,80 @@ require "iode"
 
 prog = Iode.run <<-PROG
 (lambda (f)
-  (if (f)
-    42
-    7))
+  (f 42))
 PROG
 
-prog.call(->(){ false }) #=> 7
-prog.call(->(){ true })  #=> 42
+prog.call(->(x){ x * 2 }) #=> 84
+prog.call(->(x){ x + 4 }) #=> 46
+```
+
+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))))))
+
+
+(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))))
+
+((curry + 2) 3) ; 5
+```
+
+## Development
+
+Iode (in this Ruby incarnation) is literally a few hours old at the time I
+write this. Much is still not yet developed. However, you may poke around in
+the internals and find some interesting this. A string of source code takes
+this path to being executed as code.
+
+    String(source) -> Reader(data) -> Interpreter(data) -> Core(data) -> Result
+
+The source string is parsed by the Reader into native lisp data (using Ruby
+data types, like Array and Symbol). The data representation is then given to
+the Interpreter's eval method, which is a simple recursive algorithm mapping
+the elements in the data to executable types (e.g. `[:lambda, [], 42]` becomes
+a Proc). Variables are held in the Scope class, which is able to chain Scopes
+together to create lexical closures. Core functions are registered as mixins
+in the Core module.
+
+If you want to add a native Ruby function to be applied like an Iode function,
+put it in a Module and register it into `Iode::Core`:
+
+``` ruby
+require "iode"
+
+module MyFunctions
+  def example(a, b)
+    a + b
+  end
+end
+
+Iode::Core.register MyFunctions
+
+Iode.run('(example 7 5)') #=> 12
 ```
 
-I'd show a more complex example if the language were more than 3 hours old!
-There are not even any mathematic operators or persistent definitions yet,
-though all the wiring is there, I just need to define a core library.
+Once I have namespacing done, you'll be able to write actual Iode code in
+separate files and have them loaded under a namespace.
 
 ## Copyright & Licensing
 

data/lib/iode.rb

@@ -15,8 +15,11 @@
 # limitations under the License.
 
 require "iode/version"
+require "iode/core/comparisons"
+require "iode/core/lists"
+require "iode/core/math"
+require "iode/core/output"
 require "iode/scope"
-require "iode/built_ins"
 require "iode/interpreter"
 require "iode/reader"
 

data/lib/iode/core.rb

@@ -0,0 +1,53 @@
+# iode: core.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
+  # Iode Core language definitions.
+  #
+  # This is simply a module that exposes all its instance methods as functions.
+  #
+  # The actual functions are mixed in by other modules.
+  module Core
+    class << self
+      # Register a new library of functions into the global definitions.
+      #
+      # @param [Module] base
+      #   the module to register
+      def register(base)
+        include(base).tap{@definitions = nil}
+      end
+
+      # Get a singleton instance of all the core definitions.
+      #
+      # @return [Hash]
+      #   core functions and variables
+      def definitions
+        @definitions ||=
+          Hash[
+            names.zip(
+              names.map(&method(:instance_method)).map{|m| m.bind(self)}
+            )
+          ]
+      end
+
+      private
+
+      def names
+        instance_methods
+      end
+    end
+  end
+end

data/lib/iode/{built_ins.rb → core/comparisons.rb}

@@ -1,4 +1,4 @@
-# iode: built_ins.rb
+# iode: core/comparisons.rb
 # 
 # Copyright 2014 Chris Corbyn <chris@w3style.co.uk>
 # 
@@ -14,48 +14,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-module Iode
-  module BuiltIns
-    def car(list)
-      v, *_ = list
-      v
-    end
+require "iode/core"
 
-    def cdr(list)
-      _, *v = list
-      v
-    end
-
-    def cadr(list)
-      car(cdr(list))
-    end
-
-    def cddr(list)
-      cdr(cdr(list))
-    end
-
-    def caddr(list)
-      car(cddr(list))
-    end
-
-    def cdddr(list)
-      cdr(cddr(list))
-    end
-
-    def cadddr(list)
-      car(cdddr(list))
-    end
+module Iode
+  module Core
+    module Comparisons
+      def >(a, b)
+        a > b
+      end
 
-    def cddddr(list)
-      cdr(cdddr(list))
-    end
+      def <(a, b)
+        a < b
+      end
 
-    def caddddr(list)
-      car(cdddr(list))
-    end
+      def ==(a, b)
+        a == b
+      end
 
-    def cdddddr(list)
-      cdr(cddddr(list))
+      alias_method :"=", :==
     end
   end
 end
+
+Iode::Core.register Iode::Core::Comparisons

data/lib/iode/core/lists.rb

@@ -0,0 +1,35 @@
+# 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.
+
+require "iode/core"
+
+module Iode
+  module Core
+    module Lists
+      def car(list)
+        v, *_ = list
+        v
+      end
+
+      def cdr(list)
+        _, *v = list
+        v
+      end
+    end
+  end
+end
+
+Iode::Core.register Iode::Core::Lists

data/lib/iode/core/math.rb

@@ -0,0 +1,41 @@
+# iode: core/math.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.
+
+require "iode/core"
+
+module Iode
+  module Core
+    module Math
+      def *(*args)
+        args.reduce(:*)
+      end
+
+      def /(*args)
+        args.reduce(:/)
+      end
+
+      def +(*args)
+        args.reduce(:+)
+      end
+
+      def -(*args)
+        args.reduce(:-)
+      end
+    end
+  end
+end
+
+Iode::Core.register Iode::Core::Math

data/lib/iode/core/output.rb

@@ -0,0 +1,33 @@
+# iode: core/output.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.
+
+require "iode/core"
+
+module Iode
+  module Core
+    module Output
+      def puts(*args, &block)
+        Kernel.puts(*args, &block)
+      end
+
+      def p(*args, &block)
+        Kernel.p(*args, &block)
+      end
+    end
+  end
+end
+
+Iode::Core.register Iode::Core::Output

data/lib/iode/interpreter.rb

@@ -17,8 +17,6 @@
 module Iode
   # Iode interpreter, providing the central #eval function.
   class Interpreter
-    include BuiltIns # FIXME: Remove this coupling!
-
     # Create a new Interpreter with a given Scope.
     #
     # @param [Scope] scope
@@ -27,6 +25,30 @@ module Iode
       @env = scope
     end
 
+    # Get the head (car) of a list.
+    #
+    # @param [Array] list
+    #   the list to return the car from
+    #
+    # @return [Object]
+    #   the first element in list
+    def car(list)
+      v, *_ = list
+      v
+    end
+
+    # Get the tail (cdr) of a list.
+    #
+    # @param [Array] list
+    #   the list to return the cdr from
+    #
+    # @return [Array]
+    #   all but the head of the list
+    def cdr(list)
+      _, *v = list
+      v
+    end
+
     # Create an explicit progn block.
     #
     # A progn encapsulates a list of S-Expressions to be evaluated in sequence.
@@ -93,19 +115,21 @@ module Iode
         when nil
           nil
         when :quote
-          cadr(sexp)
+          car(cdr(sexp))
         when :if
-          if eval(cadr(sexp))
-            eval(caddr(sexp))
+          if eval(car(cdr(sexp)))
+            eval(car(cdr(cdr(sexp))))
           else
-            eval(cadddr(sexp))
+            eval(car(cdr(cdr(cdr(sexp)))))
           end
         when :progn
           progn(*cdr(sexp))
         when :set!
-          @env[cadr(sexp)] = eval(caddr(sexp))
+          @env[car(cdr(sexp))] = eval(car(cdr(cdr(sexp))))
+        when :def
+          @env.define(car(cdr(sexp)), eval(car(cdr(cdr(sexp)))))
         when :lambda
-          lambda(cadr(sexp), *cddr(sexp))
+          lambda(car(cdr(sexp)), *cdr(cdr(sexp)))
         else
           apply(eval(car(sexp)), cdr(sexp).map(&method(:eval)))
         end

data/lib/iode/scope.rb

@@ -26,12 +26,26 @@ module Iode
     #
     # @param [Scope] parent
     #   the parent scope, if any
-    def initialize(values = {}, parent = nil)
-      @values = values
+    def initialize(values = nil, parent = nil)
+      @values = values || Core.definitions
       @parent = parent
     end
 
-    # Reference a variable in this scope.
+    # Define a new variable.
+    #
+    # @param [Symbol] k
+    #   the name of the variable to define
+    #
+    # @param [Object] v
+    #   the value to set
+    #
+    # @return [Object]
+    #   the newly defined value
+    def define(k, v)
+      @values[k] = v
+    end
+
+    # Reference a variable in this Scope or any parent Scopes.
     #
     # Raises a RuntimeError if the variable does not exist.
     #
@@ -46,13 +60,13 @@ module Iode
       elsif @parent
         @parent[k]
       else
-        raise "Undefined variable `#{k}`"
+        raise "Reference to undefined variable `#{k}`"
       end
     end
 
-    # Re-assign a variable in this scope.
+    # Re-assign a variable in this Scope, or any parent Scope.
     #
-    # If the variable does not exist, it will be initialized.
+    # Raises a RuntimeError if the variable does not exist.
     #
     # @param [Symbol] k
     #   the variable name to assign
@@ -63,13 +77,18 @@ module Iode
     # @return [Object]
     #   the assigned object
     def []=(k, v)
-      @values[k] = v
+      if @values.key?(k)
+        @values[k] = v
+      elsif @parent
+        @parent[k] = v
+      else
+        raise "Reference to undefined variable `#{k}`"
+      end
     end
 
     # Create a new Scope with this Scope as its parent.
     #
-    # The new Scope will have access to all variables in this Scope,
-    # but assignments will only mask variables, not replace them.
+    # The new Scope will have access to all variables in this Scope.
     #
     # @param [Hash] values
     #   variables to exist in the new Scope

data/lib/iode/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iode
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Chris Corbyn
@@ -72,7 +72,11 @@ files:
 - bin/iode-rb
 - iode.gemspec
 - lib/iode.rb
-- lib/iode/built_ins.rb
+- lib/iode/core.rb
+- lib/iode/core/comparisons.rb
+- lib/iode/core/lists.rb
+- lib/iode/core/math.rb
+- lib/iode/core/output.rb
 - lib/iode/interpreter.rb
 - lib/iode/reader.rb
 - lib/iode/scope.rb