rus3 0.1.0

data/lib/rus3/procedure/predicate.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Rus3::Procedure
+
+  module Predicate
+
+    include Rus3::EmptyList
+
+    # Returns true if the arguemnt represents a list structure.
+    # Note that an empty list is a list.
+    def list?(obj)
+      obj.instance_of?(Array)
+    end
+
+    # :stopdoc:
+
+    # Equivalence predicates:
+    #
+    # In R5RS, three equivalence predicates are defined such as eqv?,
+    # eq? and equal?.
+    #
+    # `equal?` has been defined in Object class and the reference
+    # manual says that this method must not re-defined.  So,
+    # `equal?` is not defined here.
+
+    # :startdoc:
+
+    def eqv?(obj1, obj2)
+      obj1 == obj2
+    end
+
+    def eq?(obj1, obj2)
+      obj1.equal?(obj2)
+    end
+
+    # :stopdoc:
+
+    # Value types:
+    #
+    # R5RS says "no objects satiscies more than one of the following
+    # predicates".  That is, Scheme has 9 value types at least.
+    #
+    # Most of them have suitable types in Ruby built-in classes.  Rus3
+    # provides some classes for the rest of them.
+    #
+    #   boolean? ---> FalseClass or TrueClass
+    #   pair? ------> Rus3::Pair
+    #   symbol? ----> Symbol
+    #   number? ----> Numeric
+    #   char? ------> Rus3::Char
+    #   string? ----> String
+    #   vector? ----> Array
+    #   port? ------> Rus3::Port
+    #   procedure? -> Proc
+
+    # :startdoc:
+
+    def boolean?(obj)
+      obj.instance_of?(FalseClass) or obj.instance_of?(TrueClass)
+    end
+
+    def pair?(obj)
+      obj.instance_of?(Array) or obj.instance_of?(Rus3::Pair)
+    end
+
+    def symbol?(obj)
+      obj.is_a?(Symbol) && obj != Rus3::UNDEF
+    end
+
+    def number?(obj)
+      obj.is_a?(Numeric)
+    end
+
+    def char?(obj)
+      false
+    end
+
+    def string?(obj)
+      obj.kind_of?(String)
+    end
+
+    def vector?(obj)
+      false
+    end
+
+    def port?(obj)
+      false
+    end
+
+    def procedure?(obj)
+      obj.instance_of?(Proc)
+    end
+
+    # :startdoc:
+
+    # :stopdoc:
+
+    # Numeric types:
+    #
+    # Scheme has more predicates for number values.
+    #
+    #   complex
+    #   real
+    #   rational
+    #   integer
+    #
+    # R5RS says, "Mathematically, numbers may be arranged into a tower
+    # of subtypes in which each level is a subset of the level above
+    # it:"
+    #
+    # That is, {integer} < {rational} < {real} < {complex}.
+
+    # :startdoc:
+
+    def complex?(num)
+      num.is_a?(Complex) || real?(num)
+    end
+
+    def real?(num)
+      num.is_a?(Float) || rational?(num)
+    end
+
+    def rational?(num)
+      num.is_a?(Rational) || integer?(num)
+    end
+
+    def integer?(num)
+      num.is_a?(Integer)
+    end
+
+    # :stopdoc:
+
+    # Tests a number for a particular property.
+
+    # :startdoc:
+
+    def zero?(z)
+      raise Rus3::NumberRequiredError, z unless number?(z)
+      z.zero?
+    end
+
+    def positive?(r)
+      raise Rus3::RealNumberRequiredError, r unless real?(r)
+      r.positive?
+    end
+
+    def negative?(r)
+      raise Rus3::RealNumberRequiredError, r unless real?(r)
+      r.negative?
+    end
+
+    def odd?(n)
+      raise Rus3::IntegerRequiredError, n unless integer?(n)
+      n.odd?
+    end
+
+    def even?(n)
+      raise Rus3::IntegerRequiredError, n unless integer?(n)
+      n.even?
+    end
+
+    # :stopdoc:
+
+    # Characters:
+    #
+    # ...
+
+    # :startdoc:
+
+    def char_eq?(char1, char2)
+      false
+    end
+
+    def char_lt?(char1, char2)
+      false
+    end
+
+    def char_gt?(char1, char2)
+      false
+    end
+
+    def char_le?(char1, char2)
+      false
+    end
+
+    def char_ge?(char1, char2)
+      false
+    end
+
+    def char_ci_eq?(char1, char2)
+      false
+    end
+
+    def char_ci_lt?(char1, char2)
+      false
+    end
+
+    def char_ci_gt?(char1, char2)
+      false
+    end
+
+    def char_ci_le?(char1, char2)
+      false
+    end
+
+    def char_ci_ge?(char1, char2)
+      false
+    end
+
+    def char_alphabetic?(char)
+      false
+    end
+
+    def char_numeric?(char)
+      false
+    end
+
+    def char_whitespace?(char)
+      false
+    end
+
+    def char_upper_case?(letter)
+      false
+    end
+
+    def char_lower_case?(letter)
+      false
+    end
+
+    # :stopdoc:
+
+    # Strings:
+
+    # :startdoc:
+
+    def check_string(*objs)
+      objs.each { |obj|
+        raise Rus3::StringRequiredError, obj unless string?(obj)
+      }
+    end
+    private :check_string
+
+    def string_eq?(str1, str2)
+      check_string(str1, str2)
+      str1 == str2
+    end
+
+    def string_ci_eq?(str1, str2)
+      check_string(str1, str2)
+      str1.downcase == str2.downcase
+    end
+
+    def string_lt?(str1, str2)
+      check_string(str1, str2)
+      str1 < str2
+    end
+
+    def string_gt?(str1, str2)
+      check_string(str1, str2)
+      str1 > str2
+    end
+
+    def string_le?(str1, str2)
+      check_string(str1, str2)
+      str1 <= str2
+    end
+
+    def string_ge?(str1, str2)
+      check_string(str1, str2)
+      str1 >= str2
+    end
+
+    def string_ci_lt?(str1, str2)
+      check_string(str1, str2)
+      str1.downcase < str2.downcase
+    end
+
+    def string_ci_gt?(str1, str2)
+      check_string(str1, str2)
+      str1.downcase > str2.downcase
+    end
+
+    def string_ci_le?(str1, str2)
+      check_string(str1, str2)
+      str1.downcase <= str2.downcase
+    end
+
+    def string_ci_ge?(str1, str2)
+      check_string(str1, str2)
+      str1.downcase >= str2.downcase
+    end
+
+    # :stopdoc:
+
+    # Ports:
+
+    # :startdoc:
+
+    def input_port?(obj)
+      false
+    end
+
+    def output_port?(obj)
+      false
+    end
+
+  end
+end

data/lib/rus3/procedure/write.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Rus3::Procedure
+  module Write
+
+    include Predicate
+    include Rus3::EmptyList
+
+    def write(obj)
+      print any_to_string(obj)
+      Rus3::UNDEF
+    end
+
+    def display(obj)
+      puts any_to_string(obj)
+      Rus3::UNDEF
+    end
+
+    # :stopdoc:
+
+    private
+
+    TYPES = [
+      :null,                  # empty list
+      :boolean,               # #f or #t
+      :pair,                  # (foo . bar)
+      :symbol,
+      :number,
+      :char,
+      :string,
+      :vector,
+      :port,
+      :procedure,
+    ]
+
+    def private_method(name)
+      m = nil
+      if self.class.private_method_defined?(name)
+        um = self.class.instance_method(name)
+        m = um.bind(self)
+      end
+      m
+    end
+
+    def type(obj)
+      obj_type = nil
+      TYPES.each { |type|
+        predicate_name = "#{type}?".intern
+        next unless respond_to?(predicate_name)
+
+        predicate_prc = method(predicate_name)
+        if predicate_prc.call(obj)
+          obj_type = type
+          break
+        end
+      }
+      obj_type || :undef
+    end
+
+    def any_to_string(obj)
+      prc_name = "#{type(obj)}_to_string".intern
+      prc = private_method(prc_name)
+      prc ? prc.call(obj) : obj.to_s
+    end
+
+    def null_to_string(obj)
+      "()"
+    end
+
+    def boolean_to_string(obj)
+      obj ? "#t" : "#f"
+    end
+
+    def pair_to_string(obj)
+      if null?(obj)
+        # ()
+        null_to_string(obj)
+      elsif list?(obj)
+        # (1 2 3 4)
+        result = obj.map {|e| any_to_string(e) }
+        "(#{result.join(' ')})"
+      else
+        # (1 2 3 . 4)
+        # ==> (1 . (2 . (3 . 4)))
+        result = any_to_string(obj.car)
+        cp = obj.cdr
+
+        while pair?(cp)
+          result += " "
+          result += any_to_string(cp.car)
+          cp = cp.cdr
+        end
+
+        result += " . "
+        result += any_to_string(cp)
+        "(#{result})"
+      end
+    end
+
+    def symbol_to_string(obj)
+      ":#{obj}"
+    end
+
+    def number_to_string(obj)
+      obj.to_s
+    end
+
+    def char_to_string(obj)
+      # TODO:
+    end
+
+    def string_to_string(obj)
+      "\"#{obj}\""
+    end
+
+    def vector_to_string(obj)
+      # TODO:
+    end
+
+    def port_to_string(obj)
+      # TODO:
+    end
+
+    def procedure_to_string(obj)
+      # TODO:
+    end
+
+    # :startdoc:
+  end
+end

data/lib/rus3/repl.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  # Provides a very simple Read Eval Print Loop mechanism of Rus3.
+  #
+  # Features:
+  #
+  #   Each evaluated value is recorded into the value history.
+  #
+  #     _, _last_value       : retrieves the last evaluated value
+  #     _his(n), _history(n) : retrieves the n-th value in the
+  #     history.
+  #     _his, _history       : prints all values in the history
+  #
+  # Short usage:
+  #
+  #   require "rus3"
+  #   Rus3::Repl.start
+
+  class Repl
+
+    # Indicates the version of the Repl class.
+    VERSION = "0.1.0"
+
+    class << self
+
+      # Starts REPL.
+      def start(verbose: false)
+        repl = Repl.new(verbose: verbose)
+        repl.loop
+      end
+
+    end
+
+    # Hods major component names of the REPL.
+    COMPONENTS = {
+      :parser => Parser::DEFAULT_PARSER,
+      :evaluator => Evaluator,
+      :printer => nil,
+    }
+
+    # Prompt for input.
+    PROMPT = "Rus3> "
+
+    # A message to print at exitting.
+    FAREWELL_MESSAGE = "Bye!"
+
+    @@value_history = []        # :nodoc:
+
+    attr_accessor :verbose      # :nodoc:
+
+    def initialize(verbose: false)
+      COMPONENTS.each { |name, klass|
+        instance_variable_set("@#{name}", klass.nil? ? self : klass.new)
+      }
+
+      @prompt = PROMPT
+      @parser.prompt = PROMPT unless @parser.nil?
+
+      @verbose = verbose
+      @evaluator.verbose = verbose
+      @printer.verbose = verbose
+
+      define_constants
+      define_help_feature
+      define_history_feature
+      define_load_feature
+
+      greeting
+    end
+
+    def loop
+      msg = Kernel.loop {               # LOOP
+        begin
+          exp = @parser.read(STDIN)     # READ
+        rescue SchemeSyntaxError => e
+          puts "ERROR: %s" % e
+          next
+        end
+        break FAREWELL_MESSAGE if exp.nil?
+
+        begin
+          value = @evaluator.eval(exp)  # EVAL
+        rescue SyntaxError, StandardError => e
+          puts "ERROR: %s" % e
+          next
+        end
+
+        history_push(value)
+
+        @printer.print(value)              # PRINT
+      }
+      puts "#{msg}" unless msg.nil?
+    end
+
+    # Shows the greeting message.
+    def greeting
+      puts "A simple REPL for Rus3:"
+      puts "- Rus3 version: #{Rus3::VERSION}"
+      puts "  - REPL version: #{VERSION}"
+      COMPONENTS.keys.each { |comp_name|
+        Kernel.print "    - "
+        print_version(comp_name)
+      }
+    end
+
+    # :stopdoc:
+
+    protected
+
+    require "readline"
+
+    def read(io = STDIN)
+      Readline::readline(@prompt, true)
+    end
+
+    def eval(exp)
+      exp
+    end
+
+    def print(obj)
+      prefix = "==> "
+      prefix += "[#{obj.class}]: " if @verbose
+      Kernel.print prefix
+      pp obj
+    end
+
+    private
+
+    def define_constants        # :nodoc:
+      return if @evaluator.nil?
+
+      r = @evaluator.binding.receiver
+
+      r.instance_eval {
+        self.class.const_set(:RUS3_VERSION, "#{VERSION}")
+      }
+    end
+
+    def define_help_feature     # :nodoc:
+      return if @evaluator.nil?
+
+      r = @evaluator.binding.receiver
+
+      r.instance_eval {
+        def _help
+          puts <<HELP
+A simple REPL for Rus3.
+
+FEATURES:
+
+  History of evaluated values:
+    - `_last_value` : refers the last evaluated value (short: `_`)
+    - `_history(n)` : refers the n-th value in the history (short: `_his(n)`)
+    - `_history`    : prints all entries in the history (short: `_his`)
+
+  Help:
+    - `_help` : prints this message
+HELP
+        end
+      }
+    end
+
+    def define_history_feature  # :nodoc:
+      return if @evaluator.nil?
+
+      r = @evaluator.binding.receiver
+
+      r.instance_variable_set(:@value_history, @@value_history)
+      r.instance_eval {
+
+        def _last_value
+          @value_history[-1]
+        end
+        alias :_ :_last_value
+
+        def _history(arg = nil)
+          if arg.nil?
+            @value_history.each_with_index { |value, i|
+              Kernel.print "#{i}: "
+              display(value)
+            }
+            UNDEF
+          else
+            num = arg.to_i
+            if (0...@value_history.size).cover?(num)
+              @value_history[num]
+            else
+              raise OutOfRangeError, num
+            end
+          end
+        end
+        alias :_his :_history
+
+      }
+    end
+
+    def define_load_feature
+      return if @evaluator.nil?
+
+      r = @evaluator.binding.receiver
+
+      r.instance_variable_set(:@scm_parser, Parser::SchemeParser.new)
+      r.instance_eval {
+        def load_scm(path)
+          raise Rus3::CannotFindFileError, path unless FileTest.exist?(path)
+          scm_source = nil
+          File.open(path, "r") {|f| scm_source = f.readlines(chomp: true)}
+          s_exp = scm_source.join(" ")
+          r_exp = @scm_parser.parse(s_exp)
+          self.binding.eval(r_exp)
+        end
+      }
+    end
+
+    def print_version(comp_name)
+      component = instance_variable_get("@#{comp_name}")
+      if component.nil? or component == self
+        puts "using built-in #{comp_name.upcase}"
+      else
+        puts "#{component.version}"
+      end
+    end
+
+    def history_push(value)
+      prev_value = @@value_history[-1]
+      if prev_value != value and UNDEF != value
+        @@value_history << value if prev_value != value
+      end
+    end
+
+    # :startdoc:
+
+  end
+end