subtle-lang 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in subtle.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,3 @@
+guard 'rspec' do
+  watch(/^(lib|spec)/)  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Utkarsh Kukreti
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Subtle
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'subtle'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install subtle
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+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

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+task :pry do
+  prelude = "include Subtle; pa = Parser.new; t = Transform.new;" +
+    "e = Evaluator.new;"
+  system "pry -Ilib -rsubtle -e '#{prelude}; puts \"#{prelude}\"'"
+end
+
+task default: :pry

data/bin/subtle

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'subtle'
+
+Subtle::CLI.new ARGV

data/lib/subtle.rb

@@ -0,0 +1,9 @@
+require "parslet"
+
+require "subtle/parser"
+require "subtle/transform"
+require "subtle/evaluator"
+
+require "subtle/cli"
+
+require "subtle/version"

data/lib/subtle/cli.rb

@@ -0,0 +1,34 @@
+module Subtle
+  class CLI
+    def initialize(argv)
+      repl # Just start the REPL for now
+    end
+
+    def repl
+      require "readline"
+      prompt = "> "
+
+      evaluator = Evaluator.new
+      loop do
+        line = Readline::readline(prompt)
+
+        if line.nil? or line == "exit"
+          puts if line.nil?
+          puts "Bye!"
+          exit 0
+        end
+
+        next if line.empty?
+
+        Readline::HISTORY << line
+
+        begin
+          p evaluator.eval line
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/subtle/evaluator.rb

@@ -0,0 +1,174 @@
+module Subtle
+  class Evaluator
+    def initialize
+      @parser    = Parser.new
+      @transform = Transform.new
+    end
+
+    def eval(string_or_tree)
+      if String === string_or_tree
+        parsed = @parser.parse string_or_tree
+        t = @transform.apply parsed
+      else
+        t = string_or_tree
+      end
+
+      if Hash === t
+        type = t[:type]
+        case type
+        when :monad
+          verb   = t[:verb]
+          adverb = t[:adverb]
+          right  = try_eval t[:right]
+
+          # `^` in Subtle is `**` in Ruby.
+          verb = "**" if verb == "^"
+
+          if adverb
+            if Array === right
+              if right.size < 2
+                ae! t, "Need Array of size atleast 2 for a monadic adverb." +
+                  " Your Array had #{right.size} items."
+              end
+            else
+              ae! t, "Can only apply monadic adverb on Arrays." +
+                " You passed in #{right.class}."
+            end
+            case adverb
+            when "/"
+              right.reduce do |fold, r|
+                eval type: :dyad, verb: verb, left: fold, right: r
+              end
+            end
+          else
+            if Array === right
+            else
+              ae! t, "Can only apply monadic verb on Arrays." +
+                " You passed in #{right.class}."
+            end
+            case verb
+            when "&"
+              [].tap do |ret|
+                right.each_with_index do |r, i|
+                  r.times { ret << i }
+                end
+              end
+            when "~"
+              right.map do |r|
+                r == 0 ? 1 : 0
+              end
+            else
+              nie! "Verb #{verb} without Adverb not implemented as a Monad"
+            end
+          end
+        when :dyad
+          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|
+                eval({ type: :dyad, left: left, verb: verb, right: r })
+              end
+            when "\\:" # Map each over left
+              left.map do |l|
+                eval({ type: :dyad, left: l, verb: verb, right: right })
+              end
+            else
+              nie! t, "Invalid Adverb #{adverb}"
+            end
+          else
+            case verb
+            when "+", "-", "*", "/", "%", "**"
+              if Numeric === left && Numeric === right
+                left.send(verb, right)
+              elsif Array === left && Array === right
+                if left.size != right.size
+                  ae! t, "Size of left array must be the same as the size of" +
+                    " right one, but #{left.size} != #{right.size}."
+                end
+
+                left.zip(right).map do |x, y|
+                  x.send(verb, y)
+                end
+              elsif Array === left && Numeric === right
+                left.map do |l|
+                  l.send(verb, right)
+                end
+              elsif Numeric === left && Array === right
+                right.map do |r|
+                  left.send(verb, r)
+                end
+              else
+                nie! t
+              end
+            when "&", "|"
+              verb = "min" if verb == "&"
+              verb = "max" if verb == "|"
+
+              if Numeric === left && Numeric === right
+                [left, right].send(verb)
+              elsif Array === left && Array === right
+                if left.size != right.size
+                  ae! t, "Size of left array must be the same as the size of" +
+                    " right one, but #{left.size} != #{right.size}."
+                end
+
+                left.zip(right).map do |x, y|
+                  [x, y].send(verb)
+                end
+              elsif Array === left && Numeric === right
+                left.map do |l|
+                  [l, right].send(verb)
+                end
+              elsif Numeric === left && Array === right
+                right.map do |r|
+                  [left, r].send(verb)
+                end
+              else
+                nie! t
+              end
+            else
+              nie! t, "Invalid verb #{verb}."
+            end
+          end
+        when :enumerate
+          last = try_eval t[:last]
+          if Numeric === last
+            (0...last.floor).to_a
+          else
+            nie! t
+          end
+        else
+          nie! t
+        end
+      else
+        t
+      end
+    end
+
+    def try_eval(t)
+      Hash === t ? eval(t) : t
+    end
+
+    def ae!(tree, message = "")
+      raise ArgumentError.new message << "\n" << tree.to_yaml
+    end
+
+    def nie!(tree, message = "")
+      raise NotImplementedError.new message << "\n" << tree.to_yaml
+    end
+  end
+end

data/lib/subtle/parser.rb

@@ -0,0 +1,64 @@
+module Subtle
+  class Parser < Parslet::Parser
+    def initialize
+      @monadic_verbs = %w{+ - *  / % ^ | & ~}
+      @monadic_adverbs = %w{/}
+      @dyadic_verbs = %w{+ - *  / % ^ | &}
+      @dyadic_adverbs = %w{/: \:}
+    end
+
+    rule(:spaces)  { match["\\s"].repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+    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(:array)   { (atom >> spaces?).repeat(2).as(:array) >> spaces? }
+
+    rule :enumerate do
+      (str("!") >> spaces? >> (float | integer).as(:last)).as(:enumerate)
+    end
+
+    rule(:noun)    { enumerate | array | atom }
+
+    rule :monadic_verb do
+      @monadic_verbs.map { |verb| str(verb) }.reduce(:|).as(:verb) >> spaces?
+    end
+
+    rule :monadic_adverb do
+      @monadic_adverbs.map { |adverb| str(adverb) }.reduce(:|).as(:adverb) >>
+      spaces?
+    end
+
+    rule :dyadic_verb do
+      @dyadic_verbs.map { |verb| str(verb) }.reduce(:|).as(:verb) >> spaces?
+    end
+
+    rule :dyadic_adverb do
+      @dyadic_adverbs.map { |adverb| str(adverb) }.reduce(:|).as(:adverb) >>
+      spaces?
+    end
+
+    rule :dyad do
+      (noun.as(:left) >> dyadic_verb >> dyadic_adverb.maybe >>
+       word.as(:right)).as(:dyad)
+    end
+
+    rule :monad do
+      (monadic_verb >> monadic_adverb.maybe >> word.as(:right)).as(:monad)
+    end
+
+    rule :word do
+      dyad | noun | monad
+    end
+
+    rule :sentence do
+      word
+    end
+
+    root :sentence
+  end
+end

data/lib/subtle/transform.rb

@@ -0,0 +1,30 @@
+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 monad: { verb: simple(:verb), right: subtree(:right) } do
+      { type: :monad, verb: verb.to_s, right: right }
+    end
+
+    rule monad: { verb: simple(:verb), adverb: simple(:adverb),
+                  right: subtree(:right) } do
+      { type: :monad, verb: verb.to_s, adverb: adverb.to_s, right: right }
+    end
+
+    rule dyad: { left: subtree(:left), verb: simple(:verb),
+                 right: subtree(:right) } do
+      { type: :dyad, left: left, verb: verb.to_s, right: right }
+    end
+
+    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 }
+    end
+
+    rule enumerate: { last: subtree(:last) } do
+      { type: :enumerate, last: last }
+    end
+  end
+end

data/lib/subtle/version.rb

@@ -0,0 +1,3 @@
+module Subtle
+  VERSION = "0.0.1"
+end

data/spec/examples/project_euler_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Subtle do
+  describe "Examples" 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
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require "bundler/setup"
+
+require "simplecov"
+SimpleCov.start do
+  add_group "Libraries", "/lib"
+end
+
+require "subtle"
+
+RSpec.configure do |config|
+  def e(input, output)
+    it "should evaluate #{input.inspect} to #{output.inspect}" do
+      evaluator = Subtle::Evaluator.new
+      evaluator.eval(input).should eq output
+    end
+  end
+
+  def ae!(input)
+    it "should raise ArgumentError on evaluating #{input.inspect}" do
+      expect do
+        evaluator = Subtle::Evaluator.new
+        evaluator.eval(input).should eq output
+      end.to raise_exception(ArgumentError)
+    end
+  end
+end

data/spec/subtle/evaluator_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe Subtle::Evaluator do
+  describe "Dyads" do
+    describe "Simple Arithmetic" do
+      describe "on Atoms" do
+        e "1 + 1", 2
+        e "1 + 2 - -3 * 8 + 5 % 4", 30
+        e "-1 * 5.0 / 4", -1.25
+      end
+
+      describe "on Arrays" do
+        e "1 1 1 + 2 2 2 * 3 3 3", [7, 7, 7]
+      end
+
+      describe "on Atoms and Arrays" do
+        e "1.1 1 + -2 + 2 2 * 3 % 4 ^ 2 3 + 1 - -1 -1", [5.1, 5]
+      end
+    end
+
+    describe "And/Min (`&`) and Or/Max(`|`)" do
+      describe "on Atoms" do
+        e "1 & 2 - 3", -1
+        e "7 & 8 | 0", 7
+      end
+
+      describe "on Arrays" do
+        e "1 12 & 7 8", [1, 8]
+        e "1 12 | 7 8", [7, 12]
+      end
+
+      describe "on Atoms and Arrays" do
+        e "1 | 7 0 & 8 2 | 8 & 6 7 & 1", [7, 1]
+      end
+    end
+  end
+
+  describe "Enumerate (`!`)" do
+    describe "Precedence" do
+      e "!4", [0, 1, 2, 3]
+      e "1 - !2 + 2", [-1, -2]
+    end
+
+    describe "on Floats" do
+      e "!2.1", [0, 1]
+    end
+  end
+
+  describe "Adverbs" do
+    describe "Map over each right (`/:`)" do
+      e "1 2 3 +/: 5 6", [[6, 7, 8], [7, 8, 9]]
+      e "1 2 3 -/: 0 1", [[1, 2, 3], [0, 1, 2]]
+      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]]
+    end
+
+    describe "Map over each left (`\:`)" do
+      e "1 2 3 +\\: 5 6", [[6, 7, 8], [7, 8, 9]].transpose
+      e "1 2 3 -\\: 0 1", [[1, 2, 3], [0, 1, 2]].transpose
+      e "3 2 3 ^\\: 2 3", [[9, 4, 9], [27, 8, 27]].transpose
+      e "3 2 3 &\\: 2 3", [[2, 2, 2], [3, 2, 3]].transpose
+      e "1 2 3 |\\: 0 3", [[1, 2, 3], [3, 3, 3]].transpose
+    end
+
+    describe "Fold (`/`)" do
+      e "+/1 2 3", 6
+      # +/3 4 => 7; 1 2 + 7 => 8 9; +/8 9 => 17;
+      e "+/1 2 + +/3 4", 17
+      e "^/2 3 4", 4096
+      e "&/1 2 3", 1
+      e "|/1 2 3", 3
+    end
+  end
+
+  describe "Monads" do
+    describe "Where (`&`)" do
+      e "&1 0 1", [0, 2]
+      e "&1 3 2", [0, 1, 1, 1, 2, 2]
+    end
+
+    describe "Not (`~`)" do
+      e "~1 0 -1 1 7 8 0 0", [0, 1, 0, 0, 0, 0, 1, 1]
+    end
+  end
+  describe "Errors" do
+    describe "on Arrays" do
+      ae! "1 2 + 2 3 4"
+      ae! "1 2 | 2 3 4"
+    end
+  end
+end

data/spec/subtle_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Subtle do
+  it "should have a VERSION" do
+    Subtle::VERSION.should be_a String
+  end
+end

data/subtle.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'subtle/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "subtle-lang"
+  gem.version       = Subtle::VERSION
+  gem.authors       = ["Utkarsh Kukreti"]
+  gem.email         = ["utkarshkukreti@gmail.com"]
+  gem.description   = %q{Subtle is a Terse, Array based Programming Language,
+                         heavily inspired by the K Programming Language, and
+                         partly by APL and J.}
+  gem.summary       = %q{Subtle is a Terse, Array based Programming Language,
+                         heavily inspired by the K Programming Language, and
+                         partly by APL and J.}
+  gem.homepage      = "https://github.com/utkarshkukreti/subtle-lang"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "parslet"
+
+  %w{rspec guard-rspec simplecov pry pry-debugger}.each do |name|
+    gem.add_development_dependency name
+  end
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: subtle-lang
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Utkarsh Kukreti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !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."
+email:
+- utkarshkukreti@gmail.com
+executables:
+- subtle
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/subtle
+- lib/subtle.rb
+- lib/subtle/cli.rb
+- lib/subtle/evaluator.rb
+- lib/subtle/parser.rb
+- lib/subtle/transform.rb
+- lib/subtle/version.rb
+- spec/examples/project_euler_spec.rb
+- spec/spec_helper.rb
+- spec/subtle/evaluator_spec.rb
+- spec/subtle_spec.rb
+- subtle.gemspec
+homepage: https://github.com/utkarshkukreti/subtle-lang
+licenses: []
+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.24
+signing_key: 
+specification_version: 3
+summary: Subtle is a Terse, Array based Programming Language, heavily inspired by
+  the K Programming Language, and partly by APL and J.
+test_files:
+- spec/examples/project_euler_spec.rb
+- spec/spec_helper.rb
+- spec/subtle/evaluator_spec.rb
+- spec/subtle_spec.rb
+has_rdoc: