subtle-lang 0.0.2 → 0.0.3

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode
+script: bundle exec rspec spec

data/README.md

@@ -1,29 +1,37 @@
-# Subtle
+# Subtle [![Build Status](https://travis-ci.org/utkarshkukreti/subtle-lang.png)](https://travis-ci.org/utkarshkukreti/subtle-lang)
 
-TODO: Write a gem description
+Subtle is a Terse, Array based Programming Language, heavily inspired by the K
+Programming Language, and partly by APL and J.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+### Using Git (Recommended)
 
-    gem 'subtle'
+    git clone https://github.com/utkarshkukreti/subtle-lang.git
+    cd subtle-lang
+    bundle install
+    rake install
 
-And then execute:
+### From RubyGems
 
-    $ bundle
+    gem install subtle-lang
 
-Or install it yourself as:
+## Usage
 
-    $ gem install subtle
+Run
 
-## Usage
+    subtle
+
+to start the interactive REPL.
+
+## Documentation
+
+No docs yet, but the language is **heavily** tested.
+
+Best way to learn more is to read the specs in `spec/`.
 
-TODO: Write usage instructions here
+## License
 
-## Contributing
+The MIT License
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Copyright (c) 2012 Utkarsh Kukreti

data/lib/subtle/evaluator.rb

@@ -1,6 +1,7 @@
 module Subtle
   class Evaluator
     def initialize
+      @state = {}
       @parser    = Parser.new
       @transform = Transform.new
     end
@@ -15,7 +16,45 @@ module Subtle
 
       if Hash === t
         type = t[:type]
+
         case type
+        when :assignment
+          identifier = t[:identifier]
+          right      = try_eval t[:right]
+          @state[identifier] = right
+        when :deassignment
+          identifier = t[:identifier]
+          @state[identifier]
+        when :function
+          t[:function]
+        when :function_call
+          function = t[:function]
+          adverb   = t[:adverb]
+          right    = try_eval t[:right]
+          if adverb
+            case adverb
+            when "/:"
+              right = [right] unless Array === right
+              right.map do |r|
+                eval type: :function_call, function: function, right: r
+              end
+            else
+              ae! t, "Invalid adverb #{adverb.inspect} for :function_call."
+            end
+          else
+            _x = @state["x"]
+            @state["x"] = right
+            eval(function).tap do
+              @state["x"] = _x
+            end
+          end
+        when :variable_call
+          identifier = t[:identifier]
+          adverb     = t[:adverb]
+          arguments  = t[:arguments]
+          function = @state[identifier]
+          eval type: :function_call, function: function, adverb: adverb,
+            right: arguments
         when :monad
           verb   = t[:verb]
           adverb = t[:adverb]
@@ -35,6 +74,10 @@ module Subtle
                 " You passed in #{right.class}."
             end
             case adverb
+            when "//:"
+              right.map do |r|
+                eval type: :monad, verb: verb, adverb: "/", right: r
+              end
             when "/"
               right.reduce do |fold, r|
                 eval type: :dyad, verb: verb, left: fold, right: r
@@ -76,21 +119,16 @@ module Subtle
             end
           end
         when :dyad
+          # Evaluate right first.
+          right  = try_eval t[:right]
           left   = try_eval t[:left]
           verb   = t[:verb]
           adverb = t[:adverb]
-          right  = try_eval t[:right]
 
           # `^` in Subtle is `**` in Ruby.
           verb = "**" if verb == "^"
 
           if adverb
-            if Array === left && Array === right
-            else
-              ae! t, "Adverb `#{adverb}` must have arrays on both left and" +
-                " right. You passed in #{left.class} and #{right.class}."
-            end
-
             case adverb
             when "/:" # Map each over right
               right.map do |r|
@@ -125,34 +163,31 @@ module Subtle
                   end
                 else
                   left.zip(right).map do |l, r|
-                    l.send(verb, r)
+                    (try_eval l).send(verb, try_eval(r))
                   end
                 end
 
               elsif Array === left && Numeric === right
-                # Multi-dimensional arrays
-                if Array === left.first
-                  left.map do |l|
+                left.map do |l|
+                  # Multi-dimensional arrays
+                  if Array === l
                     eval type: :dyad, verb: verb, left: l, right: right
-                  end
-                else
-                  left.map do |l|
-                    l.send(verb, right)
+                  else
+                    (try_eval l).send(verb, right)
                   end
                 end
               elsif Numeric === left && Array === right
-                # Multi-dimensional arrays
-                if Array === right.first
-                  right.map do |r|
+                right.map do |r|
+                  # Multi-dimensional arrays
+                  if Array === r
                     eval type: :dyad, verb: verb, left: left, right: r
-                  end
-                else
-                  right.map do |r|
+                  else
                     left.send(verb, r)
                   end
                 end
               else
-                nie! t
+                nie! t, "Left and Array must be Numeric or Arrays." +
+                  " You passed in #{left.class} and #{right.class}."
               end
             when "&", "|"
               verb = "min" if verb == "&"
@@ -197,10 +232,11 @@ module Subtle
           if Numeric === last
             (0...last.floor).to_a
           else
-            nie! t
+            nie! t, "`last` must be Numeric for type: :enumerate. You passed" +
+              " in #{last.class}."
           end
         else
-          nie! t
+          nie! t, "Type #{t[:type].inspect} not implemented."
         end
       else
         t

data/lib/subtle/parser.rb

@@ -2,9 +2,10 @@ module Subtle
   class Parser < Parslet::Parser
     def initialize
       @monadic_verbs = %w{+ - *  / % ^ | & ~}
-      @monadic_adverbs = %w{/: /}
+      @monadic_adverbs = %w{//: /: /}
       @dyadic_verbs = %w{+ - *  / % ^ | & !}
       @dyadic_adverbs = %w{/: \:}
+      @function_adverbs = %w{/:}
     end
 
     rule(:spaces)  { match["\\s"].repeat(1) }
@@ -12,10 +13,39 @@ module Subtle
     rule(:digits)  { match["0-9"].repeat(1) }
     rule(:minus)   { str("-") }
 
-    rule(:integer) { (minus.maybe >> digits).as(:integer) >> spaces? }
-    rule(:float)   { (minus.maybe >> digits >> str(".") >> digits).as(:float) >>
-                     spaces? }
-    rule(:atom)    { float | integer }
+    rule(:integer)      { (minus.maybe >> digits).as(:integer) >> spaces? }
+    rule(:float)        { (minus.maybe >> digits >> str(".") >> digits).
+                          as(:float) >> spaces? }
+    rule(:identifier)   { (match["a-zA-Z"] >> match["a-zA-Z0-9_"].repeat).
+                          as(:identifier) }
+    rule(:assignment)   { (identifier >> spaces? >> str(":") >> spaces? >>
+                           word.as(:right)).as(:assignment) >> spaces? }
+    rule(:deassignment) { identifier.as(:deassignment) >> spaces? }
+
+    rule(:function) do
+      str("{") >> spaces? >> word.as(:function) >> spaces? >> str("}") >>
+      spaces?
+    end
+
+    rule :function_adverb do
+      @function_adverbs.map { |adverb| str(adverb) }.reduce(:|).as(:adverb) >>
+      spaces?
+    end
+
+    rule(:function_call) do
+      (function >> function_adverb.maybe >> word.as(:right)).
+        as(:function_call) >> spaces?
+    end
+
+    rule(:variable_call) do
+      (identifier >> spaces? >> function_adverb.maybe >>
+       (assignment | dyad | noun).as(:arguments)).as(:variable_call)
+    end
+
+    rule(:atom) do
+      variable_call | function_call | function | float | integer | pword |
+        deassignment
+    end
 
     rule :array do
       atom_or_array = (array | (atom >> spaces?).repeat.as(:array)) >> spaces?
@@ -27,7 +57,7 @@ module Subtle
     end
 
     rule :enumerate do
-      (str("!") >> spaces? >> (float | integer).as(:last)).as(:enumerate)
+      (str("!") >> spaces? >> (word).as(:last)).as(:enumerate)
     end
 
     rule(:noun)    { enumerate | array | atom }
@@ -60,7 +90,12 @@ module Subtle
     end
 
     rule :word do
-      dyad | noun | monad
+      assignment | dyad | noun | monad
+    end
+
+    # This is the last option of rule(:atom) above ^
+    rule :pword do
+      str("(") >> spaces? >> word >> spaces? >> str(")") >> spaces?
     end
 
     rule :sentence do

data/lib/subtle/transform.rb

@@ -1,8 +1,8 @@
 module Subtle
   class Transform < Parslet::Transform
-    rule(integer: simple(:x)) { x.to_i }
-    rule(float:   simple(:x)) { x.to_f }
-    rule(array:  subtree(:x)) { x      }
+    rule(integer:    simple(:x)) { x.to_i }
+    rule(float:      simple(:x)) { x.to_f }
+    rule(array:     subtree(:x)) { x.size == 1 ? x.first : x }
 
     rule monad: { verb: simple(:verb), right: subtree(:right) } do
       { type: :monad, verb: verb.to_s, right: right }
@@ -20,11 +20,49 @@ module Subtle
 
     rule dyad: { left: subtree(:left), verb: simple(:verb),
                  adverb: simple(:adverb), right: subtree(:right) } do
-      { type: :dyad, left: left, verb: verb.to_s, adverb: adverb, right: right }
+      { type: :dyad, left: left, verb: verb.to_s, adverb: adverb.to_s,
+        right: right }
     end
 
     rule enumerate: { last: subtree(:last) } do
       { type: :enumerate, last: last }
     end
+
+    rule assignment: { identifier: simple(:identifier),
+                       right: subtree(:right) } do
+      { type: :assignment, identifier: identifier.to_s, right: right }
+    end
+
+    rule deassignment: { identifier: simple(:identifier) } do
+      { type: :deassignment, identifier: identifier.to_s }
+    end
+
+    rule function: subtree(:function) do
+      { type: :function, function: function }
+    end
+
+    rule function_call: { function: subtree(:function),
+                          right: subtree(:right) } do
+      { type: :function_call, function: function, right: right }
+    end
+
+    rule function_call: { function: subtree(:function), adverb: simple(:adverb),
+                          right: subtree(:right) } do
+      { type: :function_call, function: function, adverb: adverb.to_s,
+        right: right }
+    end
+
+    rule variable_call: { identifier: simple(:identifier),
+                          arguments: subtree(:arguments) } do
+      { type: :variable_call, identifier: identifier.to_s,
+        arguments: arguments }
+    end
+
+    rule variable_call: { identifier: simple(:identifier),
+                          adverb: simple(:adverb),
+                          arguments: subtree(:arguments) } do
+      { type: :variable_call, identifier: identifier.to_s, adverb: adverb.to_s,
+        arguments: arguments }
+    end
   end
 end

data/lib/subtle/version.rb

@@ -1,3 +1,3 @@
 module Subtle
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/examples/project_euler_spec.rb

@@ -5,7 +5,13 @@ describe Subtle do
     describe "Project Euler" do
       describe "Problem 1:" +
         " Find the sum of all the multiples of 3 or 5 below 1000." do
-        e "+/&~&/!1000%/:3 5", 233168
+        e "+/&~&/(!1000)%/:3 5", 233168
+      end
+
+      describe "Problem 6:" +
+        " Find the difference between the sum of the squares of the first" +
+        " one hundred natural numbers and the square of the sum." do
+        e "((+/!101)^2)-+/(!101)^2", 25164150
       end
     end
   end

data/spec/spec_helper.rb

@@ -8,10 +8,13 @@ end
 require "subtle"
 
 RSpec.configure do |config|
-  def e(input, output)
+  def e(input, output, evaluator = nil)
     it "should evaluate #{input.inspect} to #{output.inspect}" do
-      evaluator = Subtle::Evaluator.new
-      evaluator.eval(input).should eq output
+      evaluator ||= Subtle::Evaluator.new
+      evaluated = evaluator.eval(input)
+      if output
+        evaluated.should eq output
+      end
     end
   end
 

data/spec/subtle/evaluator_spec.rb

@@ -37,17 +37,17 @@ describe Subtle::Evaluator do
     describe "Rotate (`!`) (on left: Integer, right: Array)" do
       e "2 ! 1 2 3", [3, 1, 2]
       e "2 ! (1 2)", [1, 2]
-      e "2 ! (2 3; 4 5; 8)", [[8], [2, 3], [4, 5]]
+      e "2 ! (2 3; 4 5; 8)", [8, [2, 3], [4, 5]]
       e "-2 ! 1 2 3", [2, 3, 1]
       e "-2 ! (1 2)", [1, 2]
-      e "-2 ! (2 3; 4 5; 8)", [[4, 5], [8], [2, 3]]
+      e "-2 ! (2 3; 4 5; 8)", [[4, 5], 8, [2, 3]]
     end
   end
 
   describe "Enumerate (`!`)" do
     describe "Precedence" do
       e "!4", [0, 1, 2, 3]
-      e "1 - !2 + 2", [-1, -2]
+      e "5 - !2 + 2", [5, 4, 3, 2]
     end
 
     describe "on Floats" do
@@ -63,6 +63,7 @@ describe Subtle::Evaluator do
         e "3 2 3 ^/: 2 3", [[9, 4, 9], [27, 8, 27]]
         e "3 2 3 &/: 2 3", [[2, 2, 2], [3, 2, 3]]
         e "1 2 3 |/: 0 3", [[1, 2, 3], [3, 3, 3]]
+        e "2 !/: (1 2 3; 2 3 4; 4 5 6)", [[3, 1, 2], [4, 2, 3], [6, 4, 5]]
       end
 
       describe "Map over each left (`\:`)" do
@@ -91,6 +92,11 @@ describe Subtle::Evaluator do
         e "+/: ((1 2; 3 4); (5 6; 7 8))", [[[1, 3], [2, 4]], [[5, 7], [6, 8]]]
         e "|/: (0 1; 0 2)", [[1, 0], [2, 0]]
       end
+
+      describe "Map over and fold (`//:`)" do
+        e "+//: (2 4; 3 1)", [6, 4]
+        e "+//:+(2 4; 3 1)", [5, 5]
+      end
     end
   end
 
@@ -111,7 +117,7 @@ describe Subtle::Evaluator do
 
     describe "Reverse (`|`)" do
       e "|1 2", [2, 1]
-      e "|(1 2; 3; (6 7; 8))", [[[6, 7], [8]], [3], [1, 2]]
+      e "|(1 2; 3; (6 7; 8))", [[[6, 7], 8], 3, [1, 2]]
     end
   end
 
@@ -120,12 +126,13 @@ describe Subtle::Evaluator do
       e "(1 2; 3 4; 5 6.6 7)", [[1, 2], [3, 4], [5, 6.6, 7]]
       e "(;;;)", [[], [], [], []]
       e "(;;3 8;)", [[], [], [3, 8], []]
-      e "(1;2.2 3.3;(;;3 8;);)", [[1], [2.2, 3.3], [[], [], [3, 8], []], []]
+      e "(1;2.2 3.3;(;;3 8;);)", [1, [2.2, 3.3], [[], [], [3, 8], []], []]
     end
 
     describe "Dyads" do
       describe "on Atoms and 2D/3D Arrays" do
         e "1 + (;1 2; 3 4)", [[], [2, 3], [4, 5]]
+        e "(1; 2 3) + 1", [2, [3, 4]]
         e "2 ^ ((5 6; 0 1);1 2; 3 4)", [[[32, 64], [1, 2]], [2, 4], [8, 16]]
         e "(;1 2; 3 4) - 1", [[], [0, 1], [2, 3]]
         e "((5 6; 0 1);1 2; 3 4) ^ 2", [[[25, 36], [0, 1]], [1, 4], [9, 16]]
@@ -134,6 +141,7 @@ describe Subtle::Evaluator do
       describe "on 1D/2D/3D Arrays with 2D/3D Arrays" do
         e "(1 2; 3 4) + (2 3; 4 5)", [[3, 5], [7, 9]]
         e "(1 2; 3 4) % (2 3; 4 5)", [[1, 2], [3, 4]]
+        e "(1 2; 3) + (1; 2 3)", [[2, 3], [5, 6]]
         e "((1 2); 5 6) + (3 1)", [[4, 5], [6, 7]]
         e "(((2 4); (6 8)); ((2 4); (6 8))) + 1 2", [[[3, 5], [7, 9]],
                                                      [[4, 6], [8, 10]]]
@@ -141,10 +149,63 @@ describe Subtle::Evaluator do
           [[[4, 16], [36, 64]], [[4, 16], [36, 64]]]
         e "1 2 + (((2 4); (6 8)); ((2 4); (6 8)))", [[[3, 5], [7, 9]],
                                                      [[4, 6], [8, 10]]]
+        e "1 2 + ((2; (6 8)); ((2 4 3); 6))", [[3, [7, 9]],
+                                                     [[4, 6, 5], 8]]
       end
     end
   end
 
+  describe "Parentheses" do
+    e "(1 + 1) * 2", 4
+    e "3 + (1 + 1) * 2", 7
+    e "(1 + 2) * 3", 9
+    e "(((((1 + 1) * 2) + 2) * 3) + 3) * 4", 84
+  end
+
+  describe "Variables" do
+    @e = Subtle::Evaluator.new
+    e "a: 10", 10, @e
+    e "a", 10, @e
+    e "b", nil, @e
+    e "a: 1 + 2", 3, @e
+    e "b: a + 2", 5, @e
+    # Tests whether dyads are evaluated from right to left.
+    e "a: 1", 1, @e
+    e "(a: 10) + (b: 6) * a * (a: 3) + a", 82, @e
+  end
+
+  describe "Functions" do
+    describe "Map" do
+      e "{x * 2 - x} 4", -8
+      e "{x * 2 - x} 4 6 8", [-8, -24, -48]
+      e "{x + 1} {x * 2 - x} 4 6 8", [-7, -23, -47]
+      e "{x + {x + x} x} 1 2 3", [3, 6, 9]
+      e "{!x} 2", [0, 1]
+      e "{!x + 1} 2", [0, 1, 2]
+    end
+
+    describe "Map over each right (`/:`)" do
+      e "{!x}/:1 2 3", [[0], [0, 1], [0, 1, 2]]
+      e "{!x + 1}/:!3", [[0], [0, 1], [0, 1, 2]]
+      e "{+x}/:((1 2; 3 4); (4 5; 6 7))", [[[1, 3], [2, 4]], [[4, 6], [5, 7]]]
+    end
+
+    describe "Storing in variables" do
+      @e = Subtle::Evaluator.new
+      e "a: {x + !x}", nil, @e
+      e "a 3", [3, 4, 5], @e
+      e "a /: 1 2 3", [[1], [2, 3], [3, 4, 5]], @e
+      e "b: {x + 1}", nil, @e
+      e "c: 4", 4, @e
+      e "c: b b b c", 7, @e
+
+      e "d: {x * 2}", nil, @e
+      e "e: {2 * d x}", nil, @e
+      e "f: {(d x) + e x}", nil, @e
+      e "d e f f d e 6", 13824, @e
+    end
+  end
+
   describe "Errors" do
     describe "on Arrays" do
       ae! "1 2 + 2 3 4"

data/subtle.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency "parslet"
 
-  %w{rspec guard-rspec simplecov pry pry-debugger}.each do |name|
+  %w{rspec guard-rspec simplecov pry}.each do |name|
     gem.add_development_dependency name
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: subtle-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-09 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -91,22 +91,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-debugger
-  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: ! "Subtle is a Terse, Array based Programming Language,\n                         heavily
   inspired by the K Programming Language, and\n                         partly by
   APL and J."
@@ -119,6 +103,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - Guardfile
 - LICENSE.txt