loxxy 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7274fd2d139354b984962f9317cae890344e528540f2f157772e7395cdfd7d33
-  data.tar.gz: c1b38a4dfcb441c00604926cbaf397ab555624270ca647448d9cc4d4f463f500
+  metadata.gz: e689f37b8b4893aff00f320707982cc1b09c17258abee50d0ae82f2d9d9d04db
+  data.tar.gz: 57aa5e505c245cabd8f4e583a6300dbd5071b9ba580228103c4f9972c7679174
 SHA512:
-  metadata.gz: 27d5de6532213d1a995f86da84ccbd41a11b5f85c305e57a62f64637ad17852e622685e4261b1c62deb31c924bb8f8c29c4edd97e9776fabf7e0d06e5c302534
-  data.tar.gz: dab4a9e391c120c159a63e316f90065faf1415b54c9aa4c6f349f6be8e95de1289a2478f395e6b9e19b2e6f09482ae4db49a70e0d5d857eb5475cecad0590c69
+  metadata.gz: 9336292545bd83f18d8f1be0a820717dcbe33cbb3b912697ea3e5245b726a5d79810ca6613c07017aef9d766670008bf49f59f6948922f18433db4a0df94f41e
+  data.tar.gz: 149d09683e80f1d36a1939cfa13faefb1fc2bdae3b096bbde34d8824f67a305627018229e453b7b9655c78ae45b815726535a307125d238f6399df2c3d0f1aec

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.0.13] - 2021-01-10
+- The interpreter can evaluate directly simple literals.
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_exprStmt` to support the evaluation of literals.
+- File `README.md` added one more example.
+- File `parser_spec.rb` Updated the tests to reflect the change in the AST.
+- File `interpreter_spec.rb` Added a test for literal expression.
+
+## Fixed
+- File `loxxy.rb`: shorthand method `lox_true` referenced the ... false object (oops).
+
 ## [0.0.12] - 2021-01-09
 - Initial interpreter capable of evaluating a tiny subset of Lox language.
 

data/README.md

@@ -6,17 +6,52 @@
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
 a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
-## Purpose of this project:
+### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
-  (from the scanner, parser, code generation).
+  (from the scanner, parser, an interpreter).
 - The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
-## Current status
-The project is still in inception and the interpreter is being implemented...
-Currently it can execute a very limited subset of __Lox__ language.
+### Current status
+The project is still in inception and the interpreter is being implemented...  
+Currently it can execute a tiny subset of __Lox__ language.
 
-The __loxxy__ gem also a parser class `RawPaser` that can, in principle, any valid Lox input.
+The __loxxy__ gem also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
+
+## What's the fuss about Lox?
+... Nothing...  
+Bob Nystrom designed a language __simple__ enough so that he could present 
+two implementations (an interpreter, then a compiler) in one single book.
+
+Although __Lox__ is fairly simple, it is far from a toy language:
+- Dynamically typed,
+- Provides datatypes such as booleans, number, strings,
+- Supports arithmetic operations (+, -, *, / ) and comparison ( >, >= , <, <=)
+- Implements equality operators (==, !=) and the logical connectors `and` and `or`.
+- Control flow statements `if`, `for` and `while`
+- Functions and closures
+- Object-orientation (classes, methods, inheritance).
+
+In other words, __Lox__ contains interesting features expected from most general-purpose 
+languages.
+
+### What's missing in Lox?
+__Lox__ was constrained by design and therefore was not aimed to be a language used in real-world applications.
+Here are some missing parts to make it a _practical_ language:
+- Collections (arrays, maps, ...)
+- Modules (importing stuff from other packages/files)
+- Error handling (e.g. exceptions)  
+- Support for concurrency (e.g. threads, coroutines)
+
+Also a decent standard library for IO, networking,... is lacking. 
+
+For sure, the language has shortcomings but on the other hand, it exhibits the essential features 
+to cover in an introduction to language implementation.
+
+That's already fun... and if all this gives you the inspiration for creating your own
+language, that might be even funnier... 
+
+Last point: what's makes __Lox__ interesting is the fact that there are implementations in many [languages](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
 ## Hello world example
 ```ruby
@@ -28,7 +63,21 @@ lox_program = <<LOX_END
 LOX_END
 
 lox = Loxxy::Interpreter.new
-lox.evaluate(lox_program) # => Hello, world!
+lox.evaluate(lox_program) # Output: Hello, world!
+```
+
+## Retrieving the result from a Lox program
+The __Loxxy__ interpreter returns the value of the last evaluated expression. 
+
+```ruby
+require 'loxxy'
+
+lox = Loxxy::Interpreter.new
+
+lox_program = '12.34; // A fractional number'
+result = lox.evaluate(lox_program) # => Loxxy::Datatype::Number
+
+puts result.value # Output: 12.34
 ```
 
 ## Example using RawParser class
@@ -108,7 +157,6 @@ Or install it yourself as:
 TODO: Write usage instructions here
 
 ## Other Lox implementations in Ruby
-An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
 For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
 There are other Ruby-based projects as well:  

data/lib/loxxy.rb

@@ -7,13 +7,13 @@ require_relative 'loxxy/front_end/raw_parser'
 # Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
   class Error < StandardError; end
-  
+
   # Shorthand method. Returns the sole object that represents
   # a Lox false literal.
   # @return [Loxxy::Datatype::False]
   def self.lox_false
     Datatype::False.instance
-  end  
+  end
 
   # Shorthand method. Returns the sole object that represents
   # a Lox nil literal.
@@ -21,11 +21,11 @@ module Loxxy
   def self.lox_nil
     Datatype::Nil.instance
   end
-  
+
   # Shorthand method. Returns the sole object that represents
   # a Lox true literal.
   # @return [Loxxy::Datatype::True]
   def self.lox_true
-    Datatype::False.instance
-  end  
+    Datatype::True.instance
+  end
 end

data/lib/loxxy/ast/ast_builder.rb

@@ -124,13 +124,18 @@ module Loxxy
       #####################################
 
       # rule('program' => 'EOF').as 'null_program'
-      def reduce_null_program(_production, range, _tokens, _theChildren)
+      def reduce_null_program(_production, _range, _tokens, _theChildren)
         Ast::LoxNoopExpr.new(tokens[0].position)
       end
 
       # rule('program' => 'declaration_plus EOF').as ''
       def reduce_lox_program(_production, range, tokens, theChildren)
-        return_first_child(range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren) # Discard the semicolon
+      end
+
+      # rule('exprStmt' => 'expression SEMICOLON')
+      def reduce_exprStmt(_production, range, tokens, theChildren)
+      return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
       # rule('printStmt' => 'PRINT expression SEMICOLON')

data/lib/loxxy/back_end/engine.rb

@@ -25,6 +25,7 @@ module Loxxy
       # Given an abstract syntax parse tree visitor, luanch the visit
       # and execute the visit events in the output stream.
       # @param aVisitor [AST::ASTVisitor]
+      # @return [Loxxy::Datatype::BuiltinDatatype]
       def execute(aVisitor)
         aVisitor.subscribe(self)
         aVisitor.start

data/lib/loxxy/front_end/grammar.rb

@@ -58,7 +58,7 @@ module Loxxy
       rule('statement' => 'whileStmt')
       rule('statement' => 'block')
 
-      rule('exprStmt' => 'expression SEMICOLON')
+      rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
       rule('forControl' => 'forInitialization forTest forUpdate')

data/lib/loxxy/interpreter.rb

@@ -19,8 +19,10 @@ module Loxxy
       @config = theOptions
     end
 
-    # Evaluate the given Lox program
+    # Evaluate the given Lox program.
+    # Return the result of the last executed expression (if any)
     # @param lox_input [String] Lox program to evaluate
+    # @return [Loxxy::Datatype::BuiltinDatatype]
     def evaluate(lox_input)
       # Front-end scans, parses the input and blurps an AST...
       parser = FrontEnd::Parser.new

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.12'
+  VERSION = '0.0.13'
 end

data/spec/front_end/parser_spec.rb

@@ -64,7 +64,7 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = ptree.root.subnodes[0]
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +72,7 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = ptree.root.subnodes[0]
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +81,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root.subnodes[0]
+            leaf = ptree.root
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::Number)
             expect(leaf.literal.value).to eq(source.to_f)
@@ -96,7 +96,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root.subnodes[0]
+            leaf = ptree.root
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::LXString)
             expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
@@ -106,7 +106,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = ptree.root.subnodes[0]
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -131,10 +131,7 @@ LOX_END
         it 'should parse the addition of two number literals' do
           input = '123 + 456;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -144,10 +141,7 @@ LOX_END
         it 'should parse the subtraction of two number literals' do
           input = '4 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -157,10 +151,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -173,10 +164,7 @@ LOX_END
         it 'should parse the division of two number literals' do
           input = '8 / 2;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -186,10 +174,7 @@ LOX_END
         it 'should parse the product of two number literals' do
           input = '12.34 * 0.3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:*)
           expect(expr.operands[0].literal.value).to eq(12.34)
@@ -199,10 +184,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -215,10 +197,7 @@ LOX_END
         it 'should parse combination of terms and factors' do
           input = '5 + 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -233,10 +212,7 @@ LOX_END
         it 'should parse the concatenation of two string literals' do
           input = '"Lo" + "ve";'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -249,10 +225,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(predicate.to_sym)
           expect(expr.operands[0].literal.value).to eq(3)
@@ -266,10 +239,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            parent = ptree.root
-            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-            expect(parent.symbol.name).to eq('exprStmt')
-            expr = parent.subnodes[0]
+            expr = ptree.root
             expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operator).to eq(predicate.to_sym)
             expect(expr.operands[0].literal.value).to eq(3)
@@ -280,10 +250,7 @@ LOX_END
         it 'should parse combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:==)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -299,10 +266,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            parent = ptree.root
-            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-            expect(parent.symbol.name).to eq('exprStmt')
-            expr = parent.subnodes[0]
+            expr = ptree.root
             expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operator).to eq(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -319,10 +283,7 @@ LOX_END
         it 'should parse a combinations of logical expressions' do
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -28,6 +28,11 @@ module Loxxy
     context 'Evaluating Lox code:' do
       let(:hello_world) { 'print "Hello, world!";' }
 
+      it 'should evaluate core data types' do
+        result = subject.evaluate('true; // Not false')
+        expect(result).to be_kind_of(Loxxy::Datatype::True)
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-09 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley