sbyc 0.1.3 → 0.1.4

data/lib/sbyc.rb

@@ -1,7 +1,7 @@
 module SByC
 
   # Version
-  VERSION = "0.1.3".freeze
+  VERSION = "0.1.4".freeze
   
   # Provides tools around functional source code trees.
   module CodeTree
@@ -14,9 +14,5 @@ module SByC
   end # module CodeTree
   
 end # module SByC
-
-CodeTree = ::SByC::CodeTree
 require 'sbyc/codetree'
-
-TypeSystem = ::SByC::TypeSystem
 require 'sbyc/type_system'

data/lib/sbyc/codetree.rb

@@ -1,81 +1,83 @@
-module CodeTree
-  
-  # Operator names
-  OPERATOR_NAMES = {
-    :'?' => :varref,
-    :[]  => :get,
-    :[]= => :set,
-    :**  => :exponentiation,
-    :~   => :complement,
-    :==  => :eq,
-    #:!=  => :neq,
-    :-@  => :unary_minus,
-    :+@  => :unary_plus,
-    :-   => :minus,
-    :+   => :plus,
-    :*   => :times,
-    :/   => :divide,
-    :%   => :modulo,
-    :=~  => :match,
-    :=== => :matches?,
-    :&   => :and,
-    :|   => :or,
-    :>   => :gt,
-    :>=  => :gte,
-    :<=  => :lte,
-    :<   => :lt,
-    :>>  => :right_shift,
-    :<<  => :left_shift,
-    :'^' => :exclusive,
-    :<=> => :compare
-  }
-  REVERSE_OPERATOR_NAMES = Hash[*OPERATOR_NAMES.to_a.collect{|c| c.reverse}.flatten]
-  
-  # Parses some code or block
-  def parse(code = nil, options = nil, &block)
-    code, options = nil, code if code.kind_of?(Hash) and options.nil?
-    ProcParser::parse(code, options || {}, &block)
-  end
-  module_function :parse
-  
-  # Alias for _parse_
-  def expr(code = nil, options = nil, &block)
-    parse(code, options || {}, &block)
-  end
-  module_function :expr
-  
-  # Factors a CodeTree::Matcher instance
-  def matcher(code = nil, &block)
-    CodeTree::Matcher.new(parse(code, &block))
-  end
-  module_function :matcher
-  
-  # Factors a rewriter instance
-  def rewriter(&definition)
-    CodeTree::Rewriting::Rewriter.new(&definition)
-  end
-  module_function :rewriter
-  
-  # Factors a producer instance
-  def producer(default_rules = true, &definition)
-    CodeTree::Producing::Producer.new(default_rules, &definition)
-  end
-  module_function :producer
-  
-  # Converts an argument to an parse tree (an ASTNode instance)
-  def coerce(arg)
-    case arg
-      when AstNode
-        arg
-      when Proc, String
-        CodeTree::parse(arg)
-      else
-        raise "Unable to coerce #{arg.inspect} to a CodeTree::AstNode"
+module SByC
+  module CodeTree
+
+    # Operator names
+    OPERATOR_NAMES = {
+      :'?' => :varref,
+      :[]  => :get,
+      :[]= => :set,
+      :**  => :exponentiation,
+      :~   => :complement,
+      :==  => :eq,
+      #:!=  => :neq,
+      :-@  => :unary_minus,
+      :+@  => :unary_plus,
+      :-   => :minus,
+      :+   => :plus,
+      :*   => :times,
+      :/   => :divide,
+      :%   => :modulo,
+      :=~  => :match,
+      :=== => :matches?,
+      :&   => :and,
+      :|   => :or,
+      :>   => :gt,
+      :>=  => :gte,
+      :<=  => :lte,
+      :<   => :lt,
+      :>>  => :right_shift,
+      :<<  => :left_shift,
+      :'^' => :exclusive,
+      :<=> => :compare
+    }
+    REVERSE_OPERATOR_NAMES = Hash[*OPERATOR_NAMES.to_a.collect{|c| c.reverse}.flatten]
+
+    # Parses some code or block
+    def parse(code = nil, options = nil, &block)
+      code, options = nil, code if code.kind_of?(Hash) and options.nil?
+      ProcParser::parse(code, options || {}, &block)
     end
-  end
-  module_function :coerce
-  
-end # module CodeTree
+    module_function :parse
+
+    # Alias for _parse_
+    def expr(code = nil, options = nil, &block)
+      parse(code, options || {}, &block)
+    end
+    module_function :expr
+
+    # Factors a CodeTree::Matcher instance
+    def matcher(code = nil, &block)
+      CodeTree::Matcher.new(parse(code, &block))
+    end
+    module_function :matcher
+
+    # Factors a rewriter instance
+    def rewriter(&definition)
+      CodeTree::Rewriting::Rewriter.new(&definition)
+    end
+    module_function :rewriter
+
+    # Factors a producer instance
+    def producer(default_rules = true, &definition)
+      CodeTree::Producing::Producer.new(default_rules, &definition)
+    end
+    module_function :producer
+
+    # Converts an argument to an parse tree (an ASTNode instance)
+    def coerce(arg)
+      case arg
+        when AstNode
+          arg
+        when Proc, String
+          CodeTree::parse(arg)
+        else
+          raise "Unable to coerce #{arg.inspect} to a CodeTree::AstNode"
+      end
+    end
+    module_function :coerce
+
+  end # module CodeTree
+end # module SByC
 require 'sbyc/codetree/ast_node'
 require 'sbyc/codetree/proc_parser'
 require 'sbyc/codetree/eval'

data/lib/sbyc/codetree/ast_node.rb

@@ -1,140 +1,142 @@
-module CodeTree
-  class AstNode
+module SByC
+  module CodeTree
+    class AstNode
     
-    # Name of the method call
-    attr_accessor :name
-    alias :function :name
+      # Name of the method call
+      attr_accessor :name
+      alias :function :name
 
-    # Children nodes
-    attr_reader :children
-    alias :args :children
+      # Children nodes
+      attr_reader :children
+      alias :args :children
 
-    # Operator found by type checking
-    attr_reader :operator
+      # Operator found by type checking
+      attr_reader :operator
     
-    # Creates an ASTNode instance
-    def initialize(name, children)
-      @name, @children = name, children
-    end
+      # Creates an ASTNode instance
+      def initialize(name, children)
+        @name, @children = name, children
+      end
     
-    # Delegated to the children array
-    def [](*args, &block)
-      children.[](*args, &block)
-    end
+      # Delegated to the children array
+      def [](*args, &block)
+        children.[](*args, &block)
+      end
     
-    # Recursively finds the first literal.
-    def literal
-      leaf? ? children[0] : children[0].literal
-    end
+      # Recursively finds the first literal.
+      def literal
+        leaf? ? children[0] : children[0].literal
+      end
   
-    # Returns false
-    def leaf?
-      (name == :_)
-    end
+      # Returns false
+      def leaf?
+        (name == :_)
+      end
   
-    # Negation of leaf?
-    def branch?
-      not(leaf?)
-    end
+      # Negation of leaf?
+      def branch?
+        not(leaf?)
+      end
   
-    # Yields block with each child in turn  
-    def each(&block)
-      children.each(&block)
-    end
+      # Yields block with each child in turn  
+      def each(&block)
+        children.each(&block)
+      end
     
-    # Makes a depth-first-search visit of the AST
-    def visit(&block)
-      yield(self, leaf? ? children : children.collect{|c| c.respond_to?(:visit) ? c.visit(&block) : c})
-    end
+      # Makes a depth-first-search visit of the AST
+      def visit(&block)
+        yield(self, leaf? ? children : children.collect{|c| c.respond_to?(:visit) ? c.visit(&block) : c})
+      end
     
-    # Renames some nodes, given a name2name map.
-    def rename!(map = nil, &block)
-      map = CodeTree::Name2X::Delegate.coerce(map || block)
-      visit{|node, collected|
-        newname = map.name2name(node.name)
-        node.send(:name=, newname) if newname
-        nil
-      }
-      self
-    end
+      # Renames some nodes, given a name2name map.
+      def rename!(map = nil, &block)
+        map = CodeTree::Name2X::Delegate.coerce(map || block)
+        visit{|node, collected|
+          newname = map.name2name(node.name)
+          node.send(:name=, newname) if newname
+          nil
+        }
+        self
+      end
     
-    # Inject code through module mapped to function names
-    def code_inject!(map = nil, &block)
-      map = CodeTree::Name2X::Delegate.coerce(map || block)
-      visit{|node, collected| 
-        ext = map.name2module(node.function)
-        node.extend(ext) if ext
-        nil
-      }
-      self
-    end
+      # Inject code through module mapped to function names
+      def code_inject!(map = nil, &block)
+        map = CodeTree::Name2X::Delegate.coerce(map || block)
+        visit{|node, collected| 
+          ext = map.name2module(node.function)
+          node.extend(ext) if ext
+          nil
+        }
+        self
+      end
     
-    # Create class instances
-    def digest(map = nil, &block)
-      map = CodeTree::Name2X::Delegate.coerce(map || block)
-      visit{|node, collected| 
-        if node.leaf?
-          node.literal
-        else
-          ext = map.name2class(node.function)
-          raise "Unexpected node function: #{node.function}" unless ext
-          ext.new(*collected)
-        end
-      }
-    end
+      # Create class instances
+      def digest(map = nil, &block)
+        map = CodeTree::Name2X::Delegate.coerce(map || block)
+        visit{|node, collected| 
+          if node.leaf?
+            node.literal
+          else
+            ext = map.name2class(node.function)
+            raise "Unexpected node function: #{node.function}" unless ext
+            ext.new(*collected)
+          end
+        }
+      end
     
-    # Inspection
-    def inspect
-      "(#{name} #{children.collect{|c| c.inspect}.join(', ')})"
-    end
+      # Inspection
+      def inspect
+        "(#{name} #{children.collect{|c| c.inspect}.join(', ')})"
+      end
     
-    # Returns a short string representation
-    def to_s
-      case function
-        when :'_'
-          literal.inspect
-        when :'?'
-          literal.to_s
-        else
-          "(#{name} #{children.collect{|c| c.to_s}.join(', ')})"
+      # Returns a short string representation
+      def to_s
+        case function
+          when :'_'
+            literal.inspect
+          when :'?'
+            literal.to_s
+          else
+            "(#{name} #{children.collect{|c| c.to_s}.join(', ')})"
+        end
       end
-    end
     
-    # Returns an array version of this ast
-    def to_a
-      visit{|node, collected| [node.name, collected]}
-    end
+      # Returns an array version of this ast
+      def to_a
+        visit{|node, collected| [node.name, collected]}
+      end
     
-    # Checks tree equality with another node 
-    def ==(other)
-      return false unless other.kind_of?(AstNode)
-      return false unless (function == other.function)
-      return false unless args.size == other.args.size
-      return false unless args.zip(other.args).all?{|v1, v2| v1 == v2}
-      true
-    end
+      # Checks tree equality with another node 
+      def ==(other)
+        return false unless other.kind_of?(AstNode)
+        return false unless (function == other.function)
+        return false unless args.size == other.args.size
+        return false unless args.zip(other.args).all?{|v1, v2| v1 == v2}
+        true
+      end
     
-    # Coercion
-    def self.coerce(arg)
-      case arg
-        when AstNode
-          arg
-        when Array
-          name, children = arg
-          if name.kind_of?(Symbol) and children.kind_of?(Array)
-            if name == :_ and children.size == 1
-              AstNode.new(:_, children)
+      # Coercion
+      def self.coerce(arg)
+        case arg
+          when AstNode
+            arg
+          when Array
+            name, children = arg
+            if name.kind_of?(Symbol) and children.kind_of?(Array)
+              if name == :_ and children.size == 1
+                AstNode.new(:_, children)
+              else
+                AstNode.new(name, children.collect{|c| AstNode.coerce(c)})
+              end
             else
-              AstNode.new(name, children.collect{|c| AstNode.coerce(c)})
+              AstNode.new(:_, [ arg ])
             end
           else
             AstNode.new(:_, [ arg ])
-          end
-        else
-          AstNode.new(:_, [ arg ])
+        end
       end
-    end
     
-    private :name=
-  end # module AstNode
-end # module CodeTree
+      private :name=
+    end # module AstNode
+  end # module CodeTree
+end # module SByC

data/lib/sbyc/codetree/eval/ast_node_ext.rb

@@ -1,38 +1,40 @@
-module CodeTree
-  class AstNode
+module SByC
+  module CodeTree
+    class AstNode
     
-    # Generates the code of an object evaluation
-    def object_compile(scope_object = "scope", scope_method = :[])
-      CodeTree::ObjectEval.object_compile(self, scope_object, scope_method)
-    end
+      # Generates the code of an object evaluation
+      def object_compile(scope_object = "scope", scope_method = :[])
+        CodeTree::ObjectEval.object_compile(self, scope_object, scope_method)
+      end
     
-    # Generates a lambda function for object evaluation
-    def object_proc(scope_method = :[])
-      CodeTree::ObjectEval.object_proc(self, scope_method)
-    end
+      # Generates a lambda function for object evaluation
+      def object_proc(scope_method = :[])
+        CodeTree::ObjectEval.object_proc(self, scope_method)
+      end
     
-    # Executes object evaluation of this ast
-    def object_eval(scope = {}, scope_method = :[])
-      CodeTree::ObjectEval.object_eval(self, scope)
-    end
-    alias :call :object_eval
-    alias :eval :object_eval
+      # Executes object evaluation of this ast
+      def object_eval(scope = {}, scope_method = :[])
+        CodeTree::ObjectEval.object_eval(self, scope)
+      end
+      alias :call :object_eval
+      alias :eval :object_eval
     
-    # Generates the code of an functional evaluation
-    def functional_compile(receiver_object = "receiver", scope_object = "scope", scope_method = :[])
-      CodeTree::FunctionalEval.functional_compile(self, receiver_object, scope_object, scope_method)
-    end
+      # Generates the code of an functional evaluation
+      def functional_compile(receiver_object = "receiver", scope_object = "scope", scope_method = :[])
+        CodeTree::FunctionalEval.functional_compile(self, receiver_object, scope_object, scope_method)
+      end
     
-    # Generates a lambda function for functional evaluation
-    def functional_proc(scope_method = :[])
-      CodeTree::FunctionalEval.functional_proc(self, scope_method)
-    end
+      # Generates a lambda function for functional evaluation
+      def functional_proc(scope_method = :[])
+        CodeTree::FunctionalEval.functional_proc(self, scope_method)
+      end
     
-    # Executes functional evaluation of this ast
-    def functional_eval(master_object, scope = {}, scope_method = :[]) 
-      CodeTree::FunctionalEval.functional_eval(self, master_object, scope)
-    end
-    alias :apply :functional_eval
+      # Executes functional evaluation of this ast
+      def functional_eval(master_object, scope = {}, scope_method = :[]) 
+        CodeTree::FunctionalEval.functional_eval(self, master_object, scope)
+      end
+      alias :apply :functional_eval
     
-  end # class AstNode
-end # module CodeTree
+    end # class AstNode
+  end # module CodeTree
+end # module SByC