skeem 0.0.23 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46a43c0a96d793c7f042976ec034e9e261fe8198
-  data.tar.gz: 381a4e60b09bc4ffe797dce9ed62a40b53ec1225
+  metadata.gz: e1f6bf0ae4407a85eb404c02c2497964744c26b2
+  data.tar.gz: f66450bf98cb129a7e40499bf589ef6454760c12
 SHA512:
-  metadata.gz: e7dc6aa941a1e5fc4940b4d35df274ac08cf3064990dd033af703d3e72afc59f7abfd19249c24574162fdac5e72fb74425e54303780df215764fb800d19b4cb6
-  data.tar.gz: a716f8595373f25da0796eb58c07f53d47bb83db183fe0d969226ff3216993198f5c9a47cb6bea7e3e578e539eb1760c9effbf8426483b59fcd34058be5c362a
+  metadata.gz: f07d638db941e45c54717ba99addfdb627ba9c76ace292905bb3fa3687888a42a633f51cc9dc6975d058f6995782e56f9a7439cc8e0a0086c1a4ba93be84040a
+  data.tar.gz: 03b924927a3cf1e08780de16743403ab17ca68646e17f1f1b36bcfc58f3478cf403d09c2cf0626306f83dc60e6b06c4a9df57502500ca246361bbcc641833bc7

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.0.24] - 2018-11-08
+Many internal refactoring, augmented spec files base, initial quasiquotation implementation.  
+
+### Added
+- File `primitive_builder.rb` implementation of standard: `string->length`
+- File `datum_dsl.rb` to implement an internal DSL for building literal data elements.
+- Files `tokenizer.rb`, `grammar.rb`, `class SExprBuilder` Added support for quasiquotation: (quasiquote foo) or `foo and unquoting
+
+### Changed
+- File `README.md` udpated to reflect currently implemented features.
+
 ## [0.0.23] - 2018-10-24
 ### Added
 - File `primitive_builder.rb` implementation of: standard `or`, `string->symbol`, `number->string`, `string-append` procedures.

data/README.md

@@ -40,11 +40,6 @@ Here are a few pointers for the Scheme programming language:
 - [The Scheme Programming Language, 4th Edition](https://www.scheme.com/tspl4/) by Kent Dybvig. An 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
 
-## Other similar Ruby projects
-__Skeem__ isn't the sole implementation of the Scheme language in Ruby.  
-Here are a few other ones:  
-- [Heist gem](https://rubygems.org/gems/heist) -- Probably one of best Scheme implementation in Ruby. Really worth a try. Alas, the [project](https://github.com/jcoglan/heist) seems to be dormant for several years.
-
 ## Usage
 
 ### Example 1 (Variable definition)
@@ -120,6 +115,7 @@ Here are a few other ones:
 - Of the number hierarchy:  
   `real` (e.g. 2.718, 6.671e-11),  
   `integer` (42, -3)
+- Lists (quoted) : '(1 two "three")
 - Strings: `"Hello, world."`
 - Identifiers (symbols): `really-cool-procedure`
 - Vectors: `#(1 2 "three")`
@@ -127,6 +123,7 @@ Here are a few other ones:
 ### Scheme Expressions
 - Constant literals
 - Quotations
+- Quasiquotation (without unquote-splicing)
 - Variable references
 - Procedure calls
 - Lambda expressions
@@ -173,7 +170,7 @@ This section lists the implemented standard procedures
 * `list?`, `null?`, `list`, `length`
 
 #### String procedures
-* `string?`, `string-append`, `string->symbol`,
+* `string?`, `string-append`, `string-length`, `string->symbol`,
 
 #### Symbol procedures
 * `symbol?`
@@ -193,6 +190,14 @@ Roadmap:
 - 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.
 
+## Other Scheme implementation in Ruby
+__Skeem__ isn't the sole implementation of the Scheme language in Ruby.  
+Here are a few other ones:  
+- [Heist gem](https://rubygems.org/gems/heist) -- Probably one of best Scheme implementation in Ruby. Really worth a try. Alas, the [project](https://github.com/jcoglan/heist) seems to be dormant for several years.
+- [Schemerald gem](https://rubygems.org/gems/schemerald). The last commit for the [project](https://github.com/vntzy/schemerald) is October 2017.
+
+- [rubic gem](https://rubygems.org/gems/rubic). The last commit for the [project](https://github.com/notozeki/rubic) is June 2015.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/famished-tiger/Skeem.

data/lib/skeem/datum_dsl.rb

@@ -0,0 +1,139 @@
+require_relative 'skm_simple_datum'
+require_relative 'skm_compound_datum'
+
+module Skeem
+  # Mixin module that provides factory methods that ease the conversion of
+  # Ruby literals into SkmSimpleDatum or SkmCompoundDatum objects.
+  module DatumDSL
+    def boolean(aBoolean)
+      return aBoolean if aBoolean.kind_of?(SkmBoolean)
+
+      result = case aBoolean
+        when TrueClass, FalseClass
+          SkmBoolean.create(aBoolean)
+        when /^#t(?:rue)?|true$/
+          SkmBoolean.create(true)
+        when /^#f(?:alse)?|false$/
+          SkmBoolean.create(false)
+        else
+          raise StandardError, aBoolean.inspect
+      end
+    end
+
+    def integer(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmInteger)
+
+      result = case aLiteral
+        when Integer
+          SkmInteger.create(aLiteral)
+        when /^[+-]?\d+$/
+          SkmInteger.create(aLiteral.to_i)
+        else
+          raise StandardError, aLiteral.inspect
+      end
+    end
+
+    def real(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmReal)
+
+      result = case aLiteral
+        when Numeric
+          SkmReal.create(aLiteral)
+        when /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+          SkmReal.create(aLiteral.to_f)
+        else
+          raise StandardError, aLiteral.inspect
+      end
+    end
+
+    def string(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmString)
+
+      result = case aLiteral
+        when String
+          SkmString.create(aLiteral)
+        else
+          SkmString.create(aLiteral.to_s)
+      end
+    end
+
+    def identifier(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmIdentifier)
+
+      result = case aLiteral
+        when String
+          SkmIdentifier.create(aLiteral)
+        when SkmString
+          SkmIdentifier.create(aLiteral.value)
+        else
+          raise StandardError, aLiteral.inspect
+      end
+    end
+
+    alias symbol identifier
+
+    def list(aLiteral)
+      result = case aLiteral
+        when Array
+          SkmList.new(to_datum(aLiteral))
+        when SkmList
+          SkmList.new(to_datum(aLiteral.members))
+        else
+          SkmList.new([to_datum(aLiteral)])
+        end
+
+      result
+    end
+    
+    def vector(aLiteral)
+      result = case aLiteral
+        when Array
+          SkmVector.new(to_datum(aLiteral))
+        when SkmVector
+          SkmVector.new(to_datum(aLiteral.members))
+        else
+          SkmVector.new([to_datum(aLiteral)])
+        end
+
+      result
+    end    
+
+    def to_datum(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmSimpleDatum)
+      return list(aLiteral.members) if aLiteral.kind_of?(SkmList)
+      return vector(aLiteral.members) if aLiteral.kind_of?(SkmVector)
+
+      result = case aLiteral
+        when Array
+          aLiteral.map { |elem| to_datum(elem) }
+        when Integer
+          SkmInteger.create(aLiteral)
+        when Float
+          SkmReal.create(aLiteral)
+        when TrueClass, FalseClass
+          SkmBoolean.create(aLiteral)
+        when String
+          parse_literal(aLiteral)
+        else
+          raise StandardError, aLiteral.inspect
+        end
+    end
+
+    private
+
+    def parse_literal(aLiteral)
+      if aLiteral =~ /^#t(?:rue)?|true$/
+        boolean(aLiteral)
+      elsif aLiteral =~ /^#f(?:alse)?|false$/
+        boolean(aLiteral)
+      elsif aLiteral =~ /^[+-]?\d+$/
+        integer(aLiteral)
+      elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+        real(aLiteral)
+      else
+        string(aLiteral)
+      end
+    end
+
+  end # module
+end # module

data/lib/skeem/element_visitor.rb

@@ -0,0 +1,91 @@
+module Skeem
+  class SkmElementVisitor
+    # Link to the root element to visit
+    attr_reader(:root)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+
+    attr_reader(:runtime)
+
+    # Build a visitor for the given root.
+    # @param aRoot [SkmElement] the parse tree to visit.
+    def initialize(aRoot)
+      raise StandardError if aRoot.nil?
+      @root = aRoot
+      @subscribers = []
+    end
+
+    # Add a subscriber for the visit event notifications.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to begin the visit of the root.
+    def start(aRuntime)
+      @runtime = aRuntime
+      root.accept(self)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given simple datum object.
+    # @param aTerminal [SkmTerminal] the terminal to visit.
+    def visit_simple_datum(aSimpleDatum)
+      broadcast(:before_simple_datum, aSimpleDatum)
+      broadcast(:after_simple_datum, aSimpleDatum)
+    end
+
+    def visit_compound_datum(aCompoundDatum)
+      broadcast(:before_compound_datum, aCompoundDatum)
+      traverse_children(aCompoundDatum)
+      broadcast(:after_compound_datum, aCompoundDatum)
+    end
+
+
+
+=begin
+   # Visit event. The visitor is about to visit the given non terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def visit_nonterminal(aNonTerminalNode)
+      if @traversal == :post_order
+        broadcast(:before_non_terminal, aNonTerminalNode)
+        traverse_subnodes(aNonTerminalNode)
+      else
+        traverse_subnodes(aNonTerminalNode)
+        broadcast(:before_non_terminal, aNonTerminalNode)
+      end
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+=end
+
+    private
+
+    def traverse_children(aParent)
+      children = aParent.children
+      broadcast(:before_children, aParent, children)
+
+      # Let's proceed with the visit of children
+      children.each { |a_child| a_child.accept(self) }
+
+      broadcast(:after_children, aParent, children)
+    end
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |subscr|
+        next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+        subscr.send(msg, runtime, *args)
+      end
+    end
+  end # class
+end # module

data/lib/skeem/grammar.rb

@@ -9,8 +9,8 @@ module Skeem
   # Names of grammar elements are based on the R7RS documentation
   builder = Rley::Syntax::GrammarBuilder.new do
     # Delimiters, separators...
-    add_terminals('APOSTROPHE') #, 'BACKQUOTE')
-    add_terminals('LPAREN', 'RPAREN')
+    add_terminals('APOSTROPHE', 'COMMA', 'COMMA_AT_SIGN')
+    add_terminals('GRAVE_ACCENT', 'LPAREN', 'RPAREN')
     add_terminals('PERIOD')
     add_terminals('VECTOR_BEGIN')
 
@@ -20,7 +20,8 @@ module Skeem
 
     # Keywords...
     add_terminals('DEFINE', 'IF', 'LAMBDA')
-    add_terminals('QUOTE')
+    add_terminals('QUOTE', 'QUASIQUOTE', 'UNQUOTE')
+    add_terminals('UNQUOTE-SPLICING')
 
     rule('program' => 'cmd_or_def_plus').as 'main'
     rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
@@ -29,15 +30,16 @@ module Skeem
     rule 'cmd_or_def' => 'definition'
     rule 'command' => 'expression'
     rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN').as 'definition'
-    rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'    
+    rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
     rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     rule 'expression' =>  'literal'
     rule 'expression' =>  'procedure_call'
     rule 'expression' =>  'lambda_expression'
     rule 'expression' =>  'conditional'
+    rule 'expression' =>  'derived_expression'
     rule 'literal' => 'quotation'
     rule 'literal' => 'self-evaluating'
-    rule('quotation' => 'APOSTROPHE datum').as 'quotation_abbrev'
+    rule('quotation' => 'APOSTROPHE datum').as 'quotation_short'
     rule('quotation' => 'LPAREN QUOTE datum RPAREN').as 'quotation'
     rule 'self-evaluating' => 'BOOLEAN'
     rule 'self-evaluating' => 'number'
@@ -47,7 +49,7 @@ module Skeem
     rule 'datum' => 'compound_datum'
     rule 'simple_datum' => 'BOOLEAN'
     rule 'simple_datum' => 'number'
-    rule 'simple_datum' => 'STRING_LIT' 
+    rule 'simple_datum' => 'STRING_LIT'
     rule 'simple_datum' => 'symbol'
     rule 'compound_datum' => 'list'
     rule 'compound_datum' => 'vector'
@@ -55,7 +57,7 @@ module Skeem
     rule 'list' => 'LPAREN datum_plus PERIOD datum RPAREN'
     rule('vector' => 'VECTOR_BEGIN datum_star RPAREN').as 'vector'
     rule('datum_plus' => 'datum_plus datum').as 'multiple_datums'
-    rule('datum_plus' => 'datum').as 'last_datum'    
+    rule('datum_plus' => 'datum').as 'last_datum'
     rule('datum_star' => 'datum_star datum').as 'datum_star'
     rule('datum_star' => []).as 'no_datum_yet'
     rule 'symbol' => 'IDENTIFIER'
@@ -66,7 +68,7 @@ module Skeem
     rule 'operator' => 'expression'
     rule 'operand' => 'expression'
     rule('def_formals' => 'identifier_star').as 'def_formals'
-    rule('def_formals' => 'identifier_star PERIOD IDENTIFIER').as 'pair_formals'    
+    rule('def_formals' => 'identifier_star PERIOD IDENTIFIER').as 'pair_formals'
     rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
     rule('formals' => 'LPAREN identifier_star RPAREN').as 'fixed_arity_formals'
     rule('formals' => 'IDENTIFIER').as 'variadic_formals'
@@ -88,6 +90,27 @@ module Skeem
     rule 'alternate' => []
     rule 'number' => 'INTEGER'
     rule 'number' => 'REAL'
+    rule 'derived_expression' => 'quasiquotation'
+    rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'
+    rule('quasiquotation' => 'GRAVE_ACCENT qq_template').as 'quasiquotation_short'
+    rule 'qq_template' => 'simple_datum'
+    rule 'qq_template' => 'list_qq_template'
+    rule 'qq_template' => 'vector_qq_template'
+    rule 'qq_template' => 'unquotation'
+    rule('list_qq_template' => 'LPAREN qq_template_or_splice_star RPAREN').as 'list_qq'
+    rule 'list_qq_template' => 'LPAREN qq_template_or_splice_plus PERIOD qq_template RPAREN'
+    rule 'list_qq_template' => 'GRAVE_ACCENT qq_template'
+    rule('vector_qq_template' => 'VECTOR_BEGIN qq_template_or_splice_star RPAREN').as 'vector_qq'
+    rule('unquotation' => 'COMMA qq_template').as 'unquotation_short'
+    rule 'unquotation' => 'LPAREN UNQUOTE qq_template RPAREN'
+    rule('qq_template_or_splice_star' => 'qq_template_or_splice_star qq_template_or_splice').as 'multiple_template_splice'
+    rule('qq_template_or_splice_star' => []).as 'no_template_splice_yet'
+    rule 'qq_template_or_splice_plus' => 'qq_template_or_splice_plus qq_template_or_splice'
+    rule 'qq_template_or_splice_plus' => 'qq_template_or_splice'
+    rule 'qq_template_or_splice' => 'qq_template'
+    rule 'qq_template_or_splice' => 'splicing_unquotation'
+    rule 'splicing_unquotation' => 'COMMA_AT_SIGN qq_template'
+    rule 'splicing_unquotation' => 'LPAREN UNQUOTE-SPLICING qq_template RPAREN'
   end
 
   # And now build the grammar and make it accessible via a global constant

data/lib/skeem/interpreter.rb

@@ -22,7 +22,7 @@ module Skeem
       # require 'debug' if mode.nil?
       return @ptree.root.evaluate(runtime)
     end
-    
+
     def fetch(anIdentifier)
       runtime.environment.fetch(anIdentifier)
     end