skeem 0.2.14 → 0.2.18

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+dist: trusty
+
+before_install:
+  - gem update --system
+  - gem install bundler  
+
+script:
+  - bundle exec rake
+  
+rvm:
+  - 2.6.3
+  - 2.5.5
+  - 2.4.6
+  - 2.3.8
+  - jruby-9.1.9.0
+  
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+
+# whitelist
+branches:
+  only:
+    - master

data/CHANGELOG.md

@@ -1,5 +1,39 @@
+## [0.2.18] - 2021-08-29
+- Minor refactoring for Rley 0.8.03
+- Code restyling to please rubocop 1.19.1.
+
+### Changed
+- File `.rubocop.yml` updated with newer Rubocop cops
+- File `grammar.rb`: Calling `Rley::grammar_builder`, replace `LET*` token by `LET_STAR`
+- Other files changed to get rid of Rubocop offences
+
+## [0.2.17] - 2020-05-09
+- Updated `.rubocop.yml` file. 
+- Code restyling to please rubocop 0.8.0. 
+
+## [0.2.16] - 2019-08-18
+- Code refactoring to use string frozen magic comments (as a consequence, srl_ruby runs only on Rubies 2.3 or newer).  
+- Code restyling to please rubocop 0.7.40. 
+
+## [0.2.15] - 2019-07-02
+- Added a basic command-line and console interface for Skeem interpreter.
+- Added procedures: `display!`, `newline`, `make-list`
+
+### Added
+- `bin/skeem` The CLI and REPL console implementation for Skeem 
+- `bin/cubic.skm`: A sample defining a procedure that computes the cube of a number.
+- `bin/hello-world.skm`: The initiatic programming example
+
+### Changed
+- File `primitive_builder.rb` Implementation of primitive procedures `newline`, `make-list`
+- File `base.skm` Added implementation of `newline` procedure.
+- File `README.md` vastly reorganized and introducing the new command line.
+
+### Removed
+- Bundler-generated files `bin/console`, `bin/setup`
+
 ## [0.2.14] - 2019-06-29
-- Added derived expression ´do´ as an imperative iteration form. 
+- Added derived expression `do` as an imperative iteration form. 
 - Added procedures: `vector-set!`
 
 ### Added

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

data/README.md

@@ -26,23 +26,74 @@ Or install it yourself as:
     $ gem install skeem
 
 
-The __Skeem__ project has started recently and at this stage, the gem supports  a small Scheme subset.
+The __Skeem__ project is WIP and currently the gem supports a subset of the __Scheme__ language.  
+If you're not familiar to Scheme, the section [About Scheme](#about-scheme) contains a number of interesting pointers.
 
-## About Scheme
 
-The Scheme programming language is a Lisp dialect that supports multiple paradigms, including functional programming and imperative programming.
+## Usage
+Once the gem is installed, the `skeem` executable can be used.
+It allows to run the interpreter from a REPL console or from the command line.
+Another way to interact with the Skeem interpreter is to embed it in your Ruby code.
 
-### Resources on Scheme  
-Here are a few pointers for the Scheme programming language:  
-- Wikipedia article on [Scheme](https://en.m.wikipedia.org/wiki/Scheme_\(programming_language\))
-- Latest official Scheme standard: [R7RS](https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/R7RSHomePage.md)
-#### Online tutorials and books:
-- [The Scheme Programming Language, 4th Edition](https://www.scheme.com/tspl4/) by Kent Dybvig. A complete, introductory textbook on Scheme based on the older R5RS standard.
-- [Teach Yourself Scheme in Fixnum Days](http://ds26gte.github.io/tyscheme/index.html) by Dorai Sitaram
-- [Yet Another Scheme Tutorial](http://www.shido.info/lisp/idx_scm_e.html) by Shido Takafumi
-- [An Introduction to Scheme and its Implementation](http://www.cs.utexas.edu/ftp/garbage/cs345/schintro-v14/schintro_toc.html) by Paul R. Wilson
+### Launching a REPL session
+To start a REPL (Read-Eval-Print-Loop) session, just type:
+```
+  skeem
+```
 
-## Usage
+Skeem displays a greeting, a prompt and then waits for your input:
+```
+Welcome to Skeem 0.2.16.
+>
+```
+
+Now that we know that `Skeem` is well alive, let's kick it...
+We begin with the ritual 'Hello world' example, by typing after the __>__ prompt:
+```
+(display "Hello, world")
+```
+
+Skeem then replies:
+```
+Hello, world
+Skeem::SkmUndefined
+```
+
+This works as expected except, maybe, for the last line. It can be easily explained if one knows
+that the return value of the `display` procedure is undefined in standard Scheme.  
+Internally Skeem, implements such undefined result as a `Skeem::Undefined`instance.
+
+To give some taste of things, here is an excerpt from a REPL session:
+```
+> (+ 4 (* 5 6))
+34
+> (define x 6)
+6
+> (+ (* 5 x x) (* 4 x) 3)
+207
+> (/ 21 5)
+21/5
+> (/ 21.0 5)
+21/5
+```
+
+#### Terminating a REPL session
+To exit a REPL session, call the `exit` procedure as follows:
+```
+(exit)
+```
+
+### Running a Skeem file
+To run a Scheme file:
+
+```
+  skeem path/to/some-file.skm
+```
+
+By the way, the `/bin` folder of the `skeem` gem contains a couple of Skeem sample files.
+
+## Embed Skeem in your Ruby app
+This is the third way for Rubyists to interact with Skeem by integrating it directly in their Ruby code.
 
 ### Example 1 (Variable definition)
 
@@ -195,6 +246,51 @@ Here are a few pointers for the Scheme programming language:
 - Iteration (`do`)
 - Control procedures
 
+### Standard library
+This section lists the procedures following closely the official [Revised7 Report on the Algorithmic Language](https://bitbucket.org/cowan/r7rs/src/draft-10/rnrs/r7rs.pdf) standard.
+
+#### Equivalence predicates
+* `eqv?`, `equal?`
+
+#### Boolean procedures
+* `boolean?`, `boolean=?`, `and`, `or`,  `not`
+
+#### Character procedures
+* `char?` `char->integer`, `char=?`, `char<?`, `char>?`,`char<=?`, `char>=?`
+
+#### Numerical operations
+* Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`,  
+`exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`, `=`, `square`, `number->string`
+* Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`,  
+ `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,  
+`truncate-remainder`, `quotient`, `remainder`, `modulo`, `gcd`, `lcm`, `numerator`,  
+`denominator`, `floor`, `ceiling`, `truncate`, `round`
+* Integer-level: `even?`, `odd?`, `integer->char`
+
+#### List procedures
+* `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  
+`cons`,  `make-list`, `length`, `list`, `list-copy`, `list->vector`, `reverse`,  
+`set-car!`, `set-cdr!`, `assq`, `assv`
+
+#### String procedures
+* `string?`, `string=?`, `string`, `make-string`, `string-append`, `string-length`, `string->symbol`
+
+#### Symbol procedures
+* `symbol?`, `symbol=?`, `symbol->string`
+
+#### Vector procedures
+* `vector?`, `make-vector`, `vector`, `vector-length`, `vector-set!`, `vector->list`
+
+#### Control procedures
+* `procedure?`, `apply`, `map`
+
+#### Input/output procedures
+* `display`, `newline`
+
+#### Non-standard procedures
+* `assert`
+
+
 ### Standard syntactic forms
 #### define  
 __Purpose:__ Create a new variable and bind an expression/value to it.  
@@ -254,56 +350,29 @@ __Purpose:__ Define one or more variable local to the block.
 __Syntax:__   
 * (let* (<binding_spec\*\>) <body\>)
 
-### Standard library
-This section lists the implemented standard procedures
-
-#### Equivalence predicates
-* `eqv?`, `equal?`
-
-#### Boolean procedures
-* `boolean?`, `boolean=?`, `and`, `or`,  `not`
-
-#### Character procedures
-* `char?` `char->integer`, `char=?`, `char<?`, `char>?`,`char<=?`, `char>=?`
-
-#### Numerical operations
-* Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
-`=`, `square`, `number->string`
-* Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`,  `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
-  `truncate-remainder`, `quotient`, `remainder`, `modulo`, `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `truncate`, `round`
-* Integer-level: `even?`, `odd?`, `integer->char`
-
-#### List procedures
-* `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list-copy`, `list->vector`, `reverse`,  `set-car!`, `set-cdr!`
- , `assq`, `assv`
-
-#### String procedures
-* `string?`, `string=?`, `string`, `make-string`, `string-append`, `string-length`, `string->symbol`
 
-#### Symbol procedures
-* `symbol?`, `symbol=?`, `symbol->string`
-
-#### Vector procedures
-* `vector?`, `make-vector`, `vector`, `vector-length`, `vector-set!`, `vector->list`
-
-#### Control procedures
-* `procedure?`, `apply`, `map`
-
-#### Input/output procedures
-* `newline`
-
-#### Special procedures
-* `assert`
-
-Roadmap:
-- Extend language support
-- Implement REPL
+## Roadmap
 - Implement an equivalent of [lis.py](http://www.norvig.com/lispy.html)
 - Implement an equivalent of [lispy](http://norvig.com/lispy2.html)
 - Make it pass the test suite
 - Extend the language in order to support [Minikanren](https://github.com/TheReasonedSchemer2ndEd/CodeFromTheReasonedSchemer2ndEd)
 - Make it pass all examples from the [Reasoned Schemer](https://mitpress.mit.edu/books/reasoned-schemer-second-edition) book.
 
+## About Scheme
+
+The Scheme programming language is a Lisp dialect that supports multiple paradigms, including functional programming and imperative programming.
+
+### Resources on Scheme  
+Here are a few pointers for the Scheme programming language:  
+- Wikipedia article on [Scheme](https://en.m.wikipedia.org/wiki/Scheme_\(programming_language\))
+- Latest official Scheme standard: [R7RS](https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/R7RSHomePage.md)
+#### Online tutorials and books:
+- [The Scheme Programming Language, 4th Edition](https://www.scheme.com/tspl4/) by Kent Dybvig. A complete, introductory textbook on Scheme based on the older R5RS standard.
+- [Teach Yourself Scheme in Fixnum Days](http://ds26gte.github.io/tyscheme/index.html) by Dorai Sitaram
+- [Yet Another Scheme Tutorial](http://www.shido.info/lisp/idx_scm_e.html) by Shido Takafumi
+- [An Introduction to Scheme and its Implementation](http://www.cs.utexas.edu/ftp/garbage/cs345/schintro-v14/schintro_toc.html) by Paul R. Wilson
+
+
 ## Other Scheme implementations in Ruby
 __Skeem__ isn't the sole implementation of the Scheme language in Ruby.  
 Here are a few other ones:  

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/appveyor.yml

@@ -1,17 +1,16 @@
 version: '{build}'
-max_jobs: 3
+max_jobs: 5
 environment:
   matrix:
+  - Ruby_version: 26-x64  
   - Ruby_version: 25-x64
   - Ruby_version: 24-x64
   - Ruby_version: 23-x64
+  - Ruby_version: 26  
   - Ruby_version: 25
   - Ruby_version: 24
   - Ruby_version: 23
 
-# These are failing
-#  - Ruby_version: 26
-#  - Ruby_version: 26-x64
 
 install:
   - set PATH=C:\Ruby%Ruby_version%\bin;%PATH%

data/bin/cubic.skm

@@ -0,0 +1,4 @@
+(define cubic 
+  (lambda (x)
+    (* x x x)))
+(cubic 3) ; => 27

data/bin/hello-world.skm

@@ -0,0 +1 @@
+(display "Hello, world")

data/bin/skeem

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'skeem'
+
+class SkeemREPL
+  attr_reader :interpreter
+
+  def initialize
+    @interpreter = Skeem::Interpreter.new
+  end
+
+  def run_session
+    puts "Welcome to Skeem #{Skeem::VERSION}."
+    loop do
+      print '> '
+      input = gets.chomp.strip
+      break if %w[(quit) (exit)].include?(input)
+
+      process_input(input)
+    end
+  end
+
+  def run_file(aFilename)
+    if File.exist?(aFilename)
+      valid_fname = aFilename
+    elsif File.extname(aFilename).empty? # Retry by adding extension...
+      if File.exist?("#{aFilename}.skm")
+        valid_fname = "#{aFilename}.skm"
+      elsif File.exist?("#{aFilename}.scm")
+        valid_fname = "#{aFilename}.scm"
+      else
+        valid_fname = nil
+      end
+    end
+
+    raise ScriptError, "No such file -- #{aFilename}" unless valid_fname
+
+    source_code = File.read(valid_fname)
+    process_input(source_code)
+  end
+
+  def process_input(input)
+    begin
+      ptree = interpreter.parse(input)
+    rescue StandardError => e
+      $stderr.puts e.message
+      return
+    end
+
+    raw_result = ptree.root.evaluate(interpreter.runtime)
+    result = raw_result.kind_of?(Skeem::SkmPair) ? raw_result.last : raw_result
+    if result.kind_of?(Skeem::SkmUndefined)
+      puts "\n#{result.class}"
+    elsif result.respond_to?(:value)
+      puts result.value
+    else
+      puts result.inspect
+    end
+  end
+end # class
+
+########################################
+# Entry point
+########################################
+djinn = SkeemREPL.new
+
+if ARGV.empty?
+  djinn.run_session
+else
+  djinn.run_file(ARGV[0])
+end

data/lib/skeem/datum_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'skm_simple_datum'
 require_relative 'skm_compound_datum'
 require_relative 'skm_pair'
@@ -9,7 +11,7 @@ module Skeem
     def boolean(aBoolean)
       return aBoolean if aBoolean.kind_of?(SkmBoolean)
 
-      result = case aBoolean
+      case aBoolean
         when TrueClass, FalseClass
           SkmBoolean.create(aBoolean)
         when /^#t(?:rue)?|true$/
@@ -24,7 +26,7 @@ module Skeem
     def integer(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmInteger)
 
-      result = case aLiteral
+      case aLiteral
         when Integer
           SkmInteger.create(aLiteral)
         when /^[+-]?\d+$/
@@ -37,7 +39,7 @@ module Skeem
     def rational(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmRational)
 
-      result = case aLiteral
+      case aLiteral
         when Rational
           SkmRational.create(aLiteral)
         when /^[+-]?\d+\/\d+$/
@@ -50,7 +52,7 @@ module Skeem
     def real(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmReal)
 
-      result = case aLiteral
+      case aLiteral
         when Numeric
           SkmReal.create(aLiteral)
         when /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
@@ -63,7 +65,7 @@ module Skeem
     def char(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmChar)
 
-      result = case aLiteral
+      case aLiteral
         when Numeric
           SkmChar.create_from_int(aLiteral)
         when String
@@ -80,7 +82,7 @@ module Skeem
     def string(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmString)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmString.create(aLiteral)
         when SkmIdentifier
@@ -93,7 +95,7 @@ module Skeem
     def identifier(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmIdentifier)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmIdentifier.create(aLiteral)
         when SkmString
@@ -106,7 +108,7 @@ module Skeem
     alias symbol identifier
 
     def list(aLiteral)
-      result = case aLiteral
+      case aLiteral
         when Array
           SkmPair.create_from_a(to_datum(aLiteral))
         when SkmPair
@@ -114,12 +116,10 @@ module Skeem
         else
           SkmPair.new(to_datum(aLiteral), SkmEmptyList.instance)
         end
-
-      result
     end
 
     def vector(aLiteral)
-      result = case aLiteral
+      case aLiteral
         when Array
           SkmVector.new(to_datum(aLiteral))
         when SkmVector
@@ -127,8 +127,6 @@ module Skeem
         else
           SkmVector.new([to_datum(aLiteral)])
         end
-
-      result
     end
 
     # Conversion from Ruby object value to Skeem datum
@@ -137,7 +135,7 @@ module Skeem
       return vector(aLiteral.members) if aLiteral.kind_of?(SkmVector)
       return aLiteral if aLiteral.kind_of?(Primitive::PrimitiveProcedure)
 
-      result = case aLiteral
+      case aLiteral
         when Array
           aLiteral.map { |elem| to_datum(elem) }
         when Integer
@@ -150,33 +148,45 @@ module Skeem
           SkmBoolean.create(aLiteral)
         when String
           parse_literal(aLiteral)
-        when SkmPair  # Special case: not a PORO literal
+        when SkmPair # Special case: not a PORO literal
           # One assumes that a Skeem list contains only Skeem datum objects
           SkmPair.create_from_a(aLiteral.to_a)
         when SkmUndefined
           aLiteral
         else
           raise StandardError, aLiteral.inspect
-        end
+      end
     end
 
     private
 
     def parse_literal(aLiteral)
-      if aLiteral =~ /^#t(?:rue)?|true$/
-        boolean(aLiteral)
-      elsif aLiteral =~ /^#f(?:alse)?|false$/
-        boolean(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+\/\d+$/
-        rational(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+$/
-        integer(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
-        real(aLiteral)
-      else
-        string(aLiteral)
+      # if aLiteral =~ /^#t(?:rue)?|true$/
+        # boolean(aLiteral)
+      # elsif aLiteral =~ /^#f(?:alse)?|false$/
+        # boolean(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+\/\d+$/
+        # rational(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+$/
+        # integer(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+        # real(aLiteral)
+      # else
+        # string(aLiteral)
+      # end
+
+      case aLiteral
+        when /^#t(?:rue)?|true$/, /^#f(?:alse)?|false$/
+          boolean(aLiteral)
+        when /^[+-]?\d+\/\d+$/
+          rational(aLiteral)
+        when /^[+-]?\d+$/
+          integer(aLiteral)
+        when /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+          real(aLiteral)
+        else
+          string(aLiteral)
       end
     end
-
   end # module
-end # module
+end # module