pione 0.1.3 → 0.1.4

data/lib/pione/model/basic-model.rb

@@ -13,8 +13,8 @@ module Pione
       # @api private
       def message
         args = [
-          @type.type_string,
-          @obj.pione_model_type.type_string,
+          @type.name,
+          @obj.pione_model_type.name,
           @obj.line,
           @obj.column
         ]
@@ -39,267 +39,95 @@ module Pione
 
       # @api private
       def message
-        str = nil
-        begin
-          str = @obj.call_pione_method("as_string")
-        rescue => e
-          str = @obj.to_s
-        end
-        "method \"%s\" is not found in %s" % [@name, str]
+        "PIONE method \"%s\" is not found in %s" % [@name, @obj.inspect]
       end
     end
 
-    # Type is a class for type expression of PIONE model objects.
-    class Type < System::PioneObject
-      attr_reader :type_string
-      attr_reader :method_interface
-      attr_reader :method_body
-
-      # Creates a type for PIONE model object.
-      # @param [Symbol] type_string
-      #   PIONE model type
-      def initialize(type_string)
-        @type_string = type_string
-        @method_interface = {}
-        @method_body = {}
-      end
-
-      # Return true if the type or the pione model object matches.
-      # @param [Type, BasicModel] other
-      #   type or object for match test target
-      # @return [Boolean]
-      #   true if it matches, or false
-      def match(other)
-        case other
-        when Type
-          other == TypeAny || @type_string == other.type_string
-        when BasicModel
-          match(other.pione_model_type)
-        when nil
-          # do nothing
-        else
-          raise ArgumentError.new(other)
-        end
-      end
-
-      # Defines PIONE model object methods.
-      # @param [String] name
-      #   method name
-      # @param [Array<Type>] inputs
-      #   input types of the method
-      # @param [Type] output
-      #   output type of the method
-      # @param [Proc] b
-      # @return [void]
-      def define_pione_method(name, inputs, output, &b)
-        raise ArgumentError.new(inputs) unless inputs.kind_of?(Array)
-        raise ArgumentError.new(inputs) unless inputs.all?{|input|
-          input.kind_of?(Type)
-        }
-        raise ArgumentError.new(output) unless output.kind_of?(Type)
-        @method_interface[name] = PioneMethodInterface.new(inputs, output)
-        @method_body[name] = b
-      end
-
-      # Returns true if the data has the type.
-      # @return [void]
-      def check(data)
-        unless match(data.pione_model_type)
-          raise PioneModelTypeError.new(data, self)
-        end
-      end
-
-      # @api private
-      def to_s
-        "#<Type %s>" % @type_string
-      end
-
-      # @api private
-      def ==(other)
-        @type_string == other.type_string
-      end
-
-      # @api private
-      def hash
-        @type_string.hash
-      end
-    end
-
-    class VariableType
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    # TypeList represetnts list type of element type.
-    class TypeList < Type
-      attr_reader :element_type
-
-      # @api private
-      @table = {}
-
+    # BasicModel is a class for pione model object.
+    class BasicModel < Pione::PioneObject
       class << self
-        def [](type)
-          if @table.has_key?(type)
-            return @table[type]
-          else
-            t = new(type)
-            @table[type] = t
-            return t
-          end
+        # Return true if the object is atomic.
+        #
+        # @return [Boolean]
+        #   true if the object is atom, or false.
+        def atomic?
+          @atomic ||= true
         end
-      end
 
-      def initialize(element_type)
-        @element_type = element_type
-        super("[%s]" % [element_type.type_string])
+        def set_atomic(b)
+          @atomic = b
+        end
       end
 
-      def match(other)
-        return false unless other.kind_of?(TypeList)
-        @element_type.match(other.element_type)
-      end
+      forward :class, :atomic?
 
-      def method_body
-        if self == self.class[TypeAny]
-          @method_body
-        else
-          self.class[TypeAny].method_body
-        end
+      # Creates a model object.
+      def initialize(&b)
+        instance_eval(&b) if block_given?
       end
 
-      def method_interface
-        if self == self.class[TypeAny]
-          @method_interface
-        else
-          self.class[TypeAny].method_interface
-        end
+      # Evaluates the model object in the variable table.
+      # @param [VariableTable] vtable
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluated object
+      def eval(vtable=VariableTable.new)
+        return self
       end
-    end
 
-    # PioneMethodInterface represents type of PIONE object's methods.
-    class PioneMethodInterface < Pione::PioneObject
-      attr_reader :inputs
-      attr_reader :output
-
-      # Creates an interface for a pione method.
-      # @param [Array<Type>] inputs
-      #   inputs type definition
-      # @param [Type] output
-      #   ouutput type definition
-      def initialize(inputs, output)
-        @inputs = inputs
-        @output = output
+      # Returns true if the object has pione variables.
+      # @return [Boolean]
+      #   true if the object has pione variables, or false
+      def include_variable?
+        false
       end
 
-      # Validates inputs data types for the method.
+      # Returns rule definition document path.
       # @return [void]
-      def validate_inputs(*args)
-        @inputs.each_with_index do |input, i|
-          unless input.match(args[i].pione_model_type)
-            raise PioneModelTypeError.new(args[i], input)
-          end
-        end
+      def set_document_path(path)
+        @__document_path__ = path
       end
 
-      # Validates output data type for the method.
+      # Sets line and column number of the definition.
       # @return [void]
-      def validate_output(value)
-        @output.match(value.pione_model_type)
+      def set_line_and_column(line_and_column)
+        @__line__, @__column__ = line_and_column
       end
-    end
-
-    # boolean type for PIONE system
-    TypeBoolean = Type.new("boolean")
-
-    # integer type for PIONE system
-    TypeInteger = Type.new("integer")
-
-    # float type for PIONE system
-    TypeFloat = Type.new("float")
-
-    # string type for PIONE system
-    TypeString = Type.new("string")
-
-    # data expression type for PIONE system
-    TypeDataExpr = Type.new("data-expr")
-
-    # feature type for PIONE system
-    TypeFeature = Type.new("feature")
-
-    # rule expression type for PIONE system
-    TypeRuleExpr = Type.new("rule-expr")
-
-    # parameters type for PIONE system
-    TypeParameters = Type.new("parameters")
-
-    # assignment type for PIONE system
-    TypeAssignment = Type.new("assignment")
-
-    # variable table type for PIONE system
-    TypeVariableTable = Type.new("variable-table")
 
-    # package type for PIONE system
-    TypePackage = Type.new("package")
-
-    # undefined value type for PIONE system
-    TypeUndefinedValue = Type.new("undefined-value")
-
-    # rule io list type for PIONE system
-    TypeRuleIOList = Type.new("rule-io-list")
-
-    # rule io element type for PIONE system
-    TypeRuleIOElement = Type.new("rule-io-element")
-
-    # ticket expression type
-    TypeTicketExpr = Type.new("ticket-expr")
-
-    # any type for PIONE system
-    TypeAny = Type.new("any")
-
-    def TypeAny.match(other)
-      true
-    end
+      # Returns line number of the model in definition document.
+      # @return [Integer]
+      #   line number
+      def line
+        @__line__
+      end
 
-    TypeAny.instance_eval do
-      define_pione_method("==", [TypeAny], TypeBoolean) do |res, other|
-        if other.pione_model_type == TypeAny && res.name == other.name
-          PioneBoolean.true
-        else
-          raise UnboundVariableError.new(res)
-        end
+      # Returns coloumn number of the model in definition document.
+      # @return [Integer]
+      #   column number
+      def column
+        @__column__
       end
 
-      define_pione_method("!=", [TypeAny], TypeBoolean) do |res, other|
-        PioneBoolean.not(res.call_pione_method("==", other))
+      # Returns itself.
+      # @return [BasicModel]
+      def to_pione
+        self
       end
     end
 
-    # BasicModel is a class for pione model object.
-    class BasicModel < Pione::PioneObject
+    class Callable < BasicModel
       class << self
-        # Sets pione model type of the model.
-        # @param [Symbol] type
+        attr_reader :pione_model_type
+
+        # Set pione model type of the model.
+        #
+        # @param [Type] type
         #   pione model type
         # @return [void]
         def set_pione_model_type(type)
-          raise ArgumentError unless type.kind_of?(Type)
           @pione_model_type = type
         end
 
-        # Returns the pione model type of the model.
-        # @return [Symbol]
-        #   pione model type
-        def pione_model_type
-          @pione_model_type
-        end
-
-        # Defines a pione method.
-        # @return [void]
-        def define_pione_method(*args, &b)
-          @pione_model_type.define_pione_method(*args, &b)
-        end
-
         # @api private
         def inherited(subclass)
           if @pione_model_type
@@ -308,34 +136,23 @@ module Pione
         end
       end
 
+      forward :class, :pione_model_type
+
       # Creates a model object.
       def initialize(&b)
         instance_eval(&b) if block_given?
       end
 
-      # Returns PIONE model type.
-      # @return [Symbol]
-      #   PIONE model type
-      def pione_model_type
-        self.class.pione_model_type
-      end
-
-      # Evaluates the model object in the variable table.
+      # Evaluate the model object in the variable table.
+      #
       # @param [VariableTable] vtable
       #   variable table for evaluation
       # @return [BasicModel]
-      #   evaluated object
+      #   evaluated result
       def eval(vtable=VariableTable.new)
         return self
       end
 
-      # Returns true if the object is atomic.
-      # @return [Boolean]
-      #   true if the object is atom, or false.
-      def atomic?
-        true
-      end
-
       # Returns true if the object has pione variables.
       # @return [Boolean]
       #   true if the object has pione variables, or false
@@ -343,33 +160,8 @@ module Pione
         false
       end
 
-      # Returns rule definition document path.
-      # @return [void]
-      def set_document_path(path)
-        @__document_path__ = path
-      end
-
-      # Sets line and column number of the definition.
-      # @return [void]
-      def set_line_and_column(line_and_column)
-        @__line__, @__column__ = line_and_column
-      end
-
-      # Returns line number of the model in definition document.
-      # @return [Integer]
-      #   line number
-      def line
-        @__line__
-      end
-
-      # Returns coloumn number of the model in definition document.
-      # @return [Integer]
-      #   column number
-      def column
-        @__column__
-      end
-
-      # Calls pione model object method.
+      # Call pione model object method.
+      #
       # @param [String] name
       #   method name
       # @param [Array] args
@@ -377,12 +169,8 @@ module Pione
       # @return [Object]
       #   method's result
       def call_pione_method(name, *args)
-        name = name.to_s
-        if method = pione_model_type.method_interface[name]
-          method.validate_inputs(*args)
-          output = pione_model_type.method_body[name].call(self, *args)
-          pione_model_type.method_interface[name].validate_output(output)
-          return output
+        if pione_method = pione_model_type.find_method(name, self, *args)
+          pione_method.call(self, *args)
         else
           raise MethodNotFound.new(name, self)
         end
@@ -394,5 +182,31 @@ module Pione
         self
       end
     end
+
+    class Element < BasicModel
+      class << self
+        attr_reader :sequence_class
+
+        def set_sequence_class(sequence_class)
+          @sequence_class = sequence_class
+        end
+      end
+
+      forward :class, :sequence_class
+
+      def to_seq
+        sequence_class.new([self])
+      end
+    end
+
+    class Value < Element
+      attr_reader :value
+
+      # @param value [Integer]
+      #   value in ruby
+      def initialize(value)
+        @value = value
+      end
+    end
   end
 end

data/lib/pione/model/binary-operator.rb

@@ -46,7 +46,11 @@ module Pione
 
       # @api private
       def pione_model_type
-        @left.pione_model_type.method_interface[@symbol].output
+        if pione_method = @left.pione_model_type.find_method(@symbol, @left, @right)
+          return pione_method.get_output_type(@left)
+        else
+          raise MethodNotFound.new(@name.to_s, self)
+        end
       end
 
       # Evaluate the application expression and returns application result.

data/lib/pione/model/block.rb

@@ -241,5 +241,22 @@ module Pione
         @condition.hash + @blocks.hash
       end
     end
+
+    # EmptyBlock is no elements block.
+    class EmptyBlock < BasicModel
+      include Singleton
+
+      def eval(vtable)
+        return self
+      end
+
+      def include_variable?
+        false
+      end
+
+      def textize
+        "empty_block()"
+      end
+    end
   end
 end

data/lib/pione/model/boolean.rb

@@ -1,9 +1,7 @@
 module Pione
   module Model
     # PioneBoolean representes truth value in PIONE system.
-    class PioneBoolean < BasicModel
-      set_pione_model_type TypeBoolean
-
+    class PioneBoolean < Value
       # Returns the value in ruby.
       attr_reader :value
 
@@ -58,8 +56,8 @@ module Pione
       # @param value [Boolean]
       #   true or false
       def initialize(value)
+        raise ArgumentError.new(value) unless value == true or value == false
         @value = value
-        super()
       end
 
       # @api private
@@ -96,6 +94,10 @@ module Pione
         return @value
       end
 
+      def to_seq
+        BooleanSequence.new([self])
+      end
+
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)
@@ -109,40 +111,70 @@ module Pione
         @value.hash
       end
 
-      #
-      # pione methods
-      #
-
-      define_pione_method("==", [TypeBoolean], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value == other.value)
+      def inspect
+        "#<PioneBoolean %s>" % @value
       end
+    end
 
-      define_pione_method("!=", [TypeBoolean], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
-      end
+    class BooleanSequence < OrdinalSequence
+      set_pione_model_type TypeBoolean
+      set_element_class PioneBoolean
+      set_shortname "BSeq"
 
-      define_pione_method("&&", [TypeBoolean], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value && other.value)
+      def value
+        @value ||= @elements.inject(true){|b, elt| b and elt.value}
       end
+    end
 
-      define_pione_method("||", [TypeBoolean], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value || other.value)
-      end
+    #
+    # pione methods
+    #
 
+    TypeBoolean.instance_eval do
       define_pione_method("and", [TypeBoolean], TypeBoolean) do |rec, other|
-        rec.call_pione_method("&&", other)
+        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
+          rec_elt.value && other_elt.value
+        end
       end
 
       define_pione_method("or", [TypeBoolean], TypeBoolean) do |rec, other|
-        rec.call_pione_method("||", other)
+        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
+          rec_elt.value || other_elt.value
+        end
+      end
+
+      define_pione_method("as_integer", [], TypeInteger) do |rec|
+        sequential_map1(TypeInteger, rec) {|rec| rec.value ? 1 : 0}
+      end
+
+      define_pione_method("as_float", [], TypeFloat) do |rec|
+        sequential_map1(TypeFloat, rec) {|rec| rec.value ? 1.0 : 0.0}
       end
 
       define_pione_method("as_string", [], TypeString) do |rec|
-        PioneString.new(rec.value.to_s)
+        sequential_map1(TypeString, rec) {|rec| rec.value.to_s}
+      end
+
+      define_pione_method("as_data_expr", [], TypeDataExpr) do |rec|
+        sequential_map1(TypeDataExpr, rec) {|rec| rec.value.to_s}
       end
 
       define_pione_method("not", [], TypeBoolean) do |rec|
-        PioneBoolean.not(rec)
+        sequential_map1(TypeBoolean, rec) do |elt|
+          not(elt.value)
+        end
+      end
+
+      define_pione_method("every?", [], TypeBoolean) do |rec|
+        PioneBoolean.new(not(rec.elements.include?(PioneBoolean.false))).to_seq
+      end
+
+      define_pione_method("any?", [], TypeBoolean) do |rec|
+        PioneBoolean.new(rec.elements.include?(PioneBoolean.true)).to_seq
+      end
+
+      define_pione_method("one?", [], TypeBoolean) do |rec|
+        PioneBoolean.new(rec.elements.select{|elt| elt == PioneBoolean.true}.size == 1).to_seq
       end
     end
   end

data/lib/pione/model/constraints.rb

@@ -0,0 +1,34 @@
+module Pione
+  module Model
+    class Constraints
+      class << self
+        # Return the empty constraints.
+        #
+        # @return [Constraints]
+        #   empty constraints
+        def empty
+          new([])
+        end
+      end
+
+      # @param exprs [Array<BasicModel>]
+      #   constraint expressions
+      def initialize(exprs)
+        @exprs = exprs
+      end
+
+      # Return true if constraints satisfied.
+      #
+      # @param vtable [VariableTable]
+      #   variable table
+      # @return [Boolean]
+      #   true if constraints satisfied
+      def satisfy?(vtable)
+        @exprs.all? do |expr|
+          res = expr.eval(vtable)
+          res.kind_of?(BooleanSequence) and res.value
+        end
+      end
+    end
+  end
+end