rus3 0.1.2 → 0.2.0

data/lib/rus3/procedure/utils.rb

@@ -1,27 +1,31 @@
 # frozen_string_literal: true
 
-module Rus3::Procedure
-  module Utils
+module Rus3
+  module Procedure
 
-    def check_pair(pair)        # :nodoc:
-      if !pair.instance_of?(Rus3::Pair) and !pair.instance_of?(Array)
-        raise Rus3::PairRequiredError, pair
+    module Utils
+
+      def check_pair(pair)        # :nodoc:
+        if !pair.instance_of?(Rus3::Pair) and !pair.instance_of?(Array)
+          raise Rus3::PairRequiredError, pair
+        end
       end
-    end
 
-    def check_list(lst)         # :nodoc:
-      raise Rus3::ListRequiredError, lst unless list?(lst)
-    end
+      def check_list(lst)         # :nodoc:
+        raise Rus3::ListRequiredError, lst unless list?(lst)
+      end
 
-    def check_vector(obj)       # :nodoc:
-      raise Rus3::VectorRequiredError, obj unless vector?(obj)
-    end
+      def check_vector(obj)       # :nodoc:
+        raise Rus3::VectorRequiredError, obj unless vector?(obj)
+      end
 
-    # To make sure the number is less than its upper limit.  When k
-    # greater than or equal to limit, raises ExceedUpperLimitError.
+      # To make sure the number is less than its upper limit.  When k
+      # greater than or equal to limit, raises ExceedUpperLimitError.
+
+      def check_upper_limit(k, limit)
+        raise Rus3::ExceedUpperLimitError.new(k, limit) if k >= limit
+      end
 
-    def check_upper_limit(k, limit)
-      raise Rus3::ExceedUpperLimitError.new(k, limit) if k >= limit
     end
 
   end

data/lib/rus3/procedure/vector.rb

@@ -1,98 +1,101 @@
 # frozen_string_literal: true
 
-module Rus3::Procedure
+module Rus3
+  module Procedure
 
-  # Provides procedures to operate a vector.
+    # Provides procedures to operate a vector.
 
-  module Vector
+    module Vector
 
-    include Utils
-    include List
-    include Predicate
-    include Rus3::EmptyList
+      include Utils
+      include List
+      include Predicate
+      include Rus3::EmptyList
 
-    UNDEF = Rus3::UNDEF
+      UNDEF = Rus3::UNDEF
 
-    #   - procedure (R5RS/R7RS): (make-vector k) or (make-vector k fill)
+      #   - procedure (R5RS/R7RS): (make-vector k) or (make-vector k fill)
 
-    def make_vector(k, fill = UNDEF)
-      Rus3::Vector.new(k, fill)
-    end
+      def make_vector(k, fill = UNDEF)
+        Rus3::Vector.new(k, fill)
+      end
 
-    #   - library procedure (R5RS/R7RS): (vector obj ...)
+      #   - library procedure (R5RS/R7RS): (vector obj ...)
 
-    def vector(*objs)
-      Rus3::Vector.vector(*objs)
-    end
+      def vector(*objs)
+        Rus3::Vector.vector(*objs)
+      end
 
-    #   - procedure (R5RS/R7RS): (vector-length vector)
+      #   - procedure (R5RS/R7RS): (vector-length vector)
 
-    def vector_length(vec)
-      check_vector(vec)
-      vec.length
-    end
+      def vector_length(vec)
+        check_vector(vec)
+        vec.length
+      end
 
-    #   - procedure (R5RS/R7RS): (vector-ref vector, k)
+      #   - procedure (R5RS/R7RS): (vector-ref vector, k)
 
-    def vector_ref(vec, k)
-      check_vector(vec)
-      check_upper_limit(k, vec.length)
-      vec.ref(k)
-    end
+      def vector_ref(vec, k)
+        check_vector(vec)
+        check_upper_limit(k, vec.length)
+        vec.ref(k)
+      end
 
-    #   - procedure (R5RS/R7RS): (vector-set! vector k obj)
+      #   - procedure (R5RS/R7RS): (vector-set! vector k obj)
 
-    def vector_set!(vec, k, obj)
-      check_vector(vec)
-      Rus3::Vector.vector_set!(vec, k, obj)
-    end
+      def vector_set!(vec, k, obj)
+        check_vector(vec)
+        Rus3::Vector.vector_set!(vec, k, obj)
+      end
 
-    #   - library procedure (R5RS): (vector->list vector)
-    #   - procedure (R7RS):
-    #       (vector->list vector)
-    #       (vector->list vector start)
-    #       (vector->list vector start end)
+      #   - library procedure (R5RS): (vector->list vector)
+      #   - procedure (R7RS):
+      #       (vector->list vector)
+      #       (vector->list vector start)
+      #       (vector->list vector start end)
 
-    def vector_to_list(vec, start_index = 0, end_index = -1)
-      end_index = vec.length if end_index == -1
+      def vector_to_list(vec, start_index = 0, end_index = -1)
+        end_index = vec.length if end_index == -1
 
-      check_vector(vec)
-      check_limits(start_index, end_index, vec.length)
+        check_vector(vec)
+        check_limits(start_index, end_index, vec.length)
 
-      list(*vec.ref(start_index...end_index))
-    end
+        list(*vec.ref(start_index...end_index))
+      end
 
-    #   - library procedure (R5RS): (list->vector list)
-    #   - procedre (R7RS): (list->vector list)
+      #   - library procedure (R5RS): (list->vector list)
+      #   - procedre (R7RS): (list->vector list)
 
-    def list_to_vector(lst)
-      Rus3::Vector.list_to_vector(lst)
-    end
+      def list_to_vector(lst)
+        Rus3::Vector.list_to_vector(lst)
+      end
 
-    #   - library procedure (R5RS): (vector-fill! vector fill)
-    #   - procedure (R7RS): (vector-fill! vector fill start end)
+      #   - library procedure (R5RS): (vector-fill! vector fill)
+      #   - procedure (R7RS): (vector-fill! vector fill start end)
 
-    def vector_fill!(vec, fill, start_index = 0, end_index = -1)
-      end_index = vec.length if end_index == -1
+      def vector_fill!(vec, fill, start_index = 0, end_index = -1)
+        end_index = vec.length if end_index == -1
 
-      check_vector(vec)
-      check_limits(start_index, end_index, vec.length)
+        check_vector(vec)
+        check_limits(start_index, end_index, vec.length)
 
-      start_index.upto(end_index - 1) {|i| vec.set!(i, fill)}
-    end
+        start_index.upto(end_index - 1) {|i| vec.set!(i, fill)}
+      end
 
-    # :stopdoc:
+      # :stopdoc:
 
-    private
+      private
 
-    # Makes sure that start_index < end_index <= limit.
-    def check_limits(start_index, end_index, limit)
-      check_upper_limit(start_index, limit)
-      check_upper_limit(start_index, end_index)
-      check_upper_limit(end_index, limit + 1)
-    end
+      # Makes sure that start_index < end_index <= limit.
+      def check_limits(start_index, end_index, limit)
+        check_upper_limit(start_index, limit)
+        check_upper_limit(start_index, end_index)
+        check_upper_limit(end_index, limit + 1)
+      end
 
-    # :startdoc:
+      # :startdoc:
+
+    end
 
   end
 end

data/lib/rus3/procedure/write.rb

@@ -1,130 +1,134 @@
 # frozen_string_literal: true
 
-module Rus3::Procedure
-  module Write
+module Rus3
+  module Procedure
 
-    include Predicate
-    include Rus3::EmptyList
+    module Write
 
-    def write(obj)
-      print any_to_string(obj)
-      Rus3::UNDEF
-    end
-
-    def display(obj)
-      puts any_to_string(obj)
-      Rus3::UNDEF
-    end
+      include Predicate
+      include Rus3::EmptyList
 
-    # :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)
+      def write(obj)
+        print any_to_string(obj)
+        Rus3::UNDEF
       end
-      m
-    end
 
-    def type(obj)
-      obj_type = nil
-      TYPES.each { |type|
-        predicate_name = "#{type}?".intern
-        next unless respond_to?(predicate_name)
+      def display(obj)
+        puts any_to_string(obj)
+        Rus3::UNDEF
+      end
 
-        predicate_prc = method(predicate_name)
-        if predicate_prc.call(obj)
-          obj_type = type
-          break
+      # :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
-      }
-      obj_type || :undef
-    end
+        m
+      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 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 null_to_string(obj)
-      "()"
-    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 boolean_to_string(obj)
-      obj ? "#t" : "#f"
-    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
+      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
 
-        result += " . "
-        result += any_to_string(cp)
-        "(#{result})"
+      def symbol_to_string(obj)
+        ":#{obj}"
       end
-    end
 
-    def symbol_to_string(obj)
-      ":#{obj}"
-    end
+      def number_to_string(obj)
+        obj.to_s
+      end
 
-    def number_to_string(obj)
-      obj.to_s
-    end
+      def char_to_string(obj)
+        # TODO:
+      end
 
-    def char_to_string(obj)
-      # TODO:
-    end
+      def string_to_string(obj)
+        "\"#{obj}\""
+      end
 
-    def string_to_string(obj)
-      "\"#{obj}\""
-    end
+      def vector_to_string(obj)
+        # TODO:
+      end
 
-    def vector_to_string(obj)
-      # TODO:
-    end
+      def port_to_string(obj)
+        # TODO:
+      end
 
-    def port_to_string(obj)
-      # TODO:
-    end
+      def procedure_to_string(obj)
+        # TODO:
+      end
 
-    def procedure_to_string(obj)
-      # TODO:
+      # :startdoc:
     end
 
-    # :startdoc:
   end
 end