pione 0.1.3 → 0.1.4

data/lib/pione/model/feature-expr.rb

@@ -52,7 +52,7 @@ module Pione::Model
     end
 
     # Expr is a super class for all feature expressions.
-    class Expr < BasicModel
+    class Expr < Callable
       set_pione_model_type TypeFeature
 
       # Return simplified expression.
@@ -865,19 +865,28 @@ module Pione::Model
         end
       end
     end
+
+  #   class FeatureSequence < Sequence
+  #     set_pione_model_type TypeFeature
+  #     set_element_class Feature::Expr
+  #   end
   end
 
   TypeFeature.instance_eval do
     define_pione_method("==", [TypeFeature], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec == other)
+      PioneBoolean.new(rec == other).to_seq
     end
 
     define_pione_method("!=", [TypeFeature], TypeBoolean) do |rec, other|
-      PioneBoolean.not(rec.call_pione_method("==", other))
+      PioneBoolean.not(rec.call_pione_method("==", other)).to_seq
     end
 
     define_pione_method("as_string", [], TypeString) do |rec|
-      PioneString.new(rec.as_string)
+      PioneString.new(rec.as_string).to_seq
+    end
+
+    define_pione_method("str", [], TypeString) do |rec|
+      rec.call_pione_method("as_string")
     end
   end
 end

data/lib/pione/model/float.rb

@@ -1,20 +1,7 @@
 module Pione
   module Model
     # PioneFloat represents float values in PIONE system.
-    class PioneFloat < BasicModel
-      set_pione_model_type TypeFloat
-
-      attr_reader :value
-
-      # Create a float value in PIONE system.
-      #
-      # @param value [Float]
-      #    value in ruby
-      def initialize(value)
-        @value = value
-        super()
-      end
-
+    class PioneFloat < Value
       # @api private
       def textize
         "#PioneFloat{%s}" % @value
@@ -42,43 +29,35 @@ module Pione
       end
     end
 
-    TypeFloat.instance_eval do
-      # Return true if the other equals self.
-      #
-      # @return [PioneBoolean]
-      #   true if the other equals self
-      define_pione_method("==", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value == other.value)
-      end
+    class FloatSequence < OrdinalSequence
+      set_pione_model_type TypeFloat
+      set_element_class PioneFloat
+      set_shortname "FSeq"
 
-      define_pione_method("!=", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
+      def value
+        @value ||= @elements.inject(0.0){|n, elt| n + elt.value}
       end
+    end
 
+    TypeFloat.instance_eval do
       define_pione_method(">", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value > other.value)
-      end
-
-      define_pione_method(">=", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.or(rec.call_pione_method(">", other),
-          rec.call_pione_method("==", other))
+        BooleanSequence.new([PioneBoolean.new(rec.value > other.value)])
       end
 
       define_pione_method("<", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value < other.value)
-      end
-
-      define_pione_method("<=", [TypeFloat], TypeBoolean) do |rec, other|
-        PioneBoolean.or(rec.call_pione_method("<", other),
-          rec.call_pione_method("==", other))
+        BooleanSequence.new([PioneBoolean.new(rec.value < other.value)])
       end
 
       define_pione_method("+", [TypeFloat], TypeFloat) do |rec, other|
-        PioneFloat.new(rec.value + other.value)
+        map2(rec, other) do |rec_elt, other_elt|
+          PioneFloat.new(rec_elt.value + other_elt.value)
+        end
       end
 
       define_pione_method("-", [TypeFloat], TypeFloat) do |rec, other|
-        PioneFloat.new(rec.value - other.value)
+        map2(rec, other) do |rec_elt, other_elt|
+          PioneFloat.new(rec_elt.value - other_elt.value)
+        end
       end
 
       define_pione_method("*", [TypeFloat], TypeFloat) do |rec, other|
@@ -96,11 +75,15 @@ module Pione
       end
 
       define_pione_method("as_string", [], TypeString) do |rec|
-        PioneString.new(rec.value.to_s)
+        sequential_map1(TypeString, rec) do |elt|
+          elt.value.to_s
+        end
       end
 
-      define_pione_method("as_int", [], TypeInteger) do |rec|
-        PioneInteger.new(rec.value.to_i)
+      define_pione_method("as_integer", [], TypeInteger) do |rec|
+        sequential_map1(TypeInteger, rec) do |elt|
+          elt.value.to_i
+        end
       end
 
       define_pione_method("as_float", [], TypeFloat) do |rec|

data/lib/pione/model/integer.rb

@@ -1,20 +1,7 @@
 module Pione
   module Model
     # PioneInteger represents integer value in PIONE system.
-    class PioneInteger < BasicModel
-      set_pione_model_type TypeInteger
-
-      attr_reader :value
-
-      # Create a integer value in PIONE system.
-      #
-      # @param value [Integer]
-      #   value in ruby
-      def initialize(value)
-        @value = value
-        super()
-      end
-
+    class PioneInteger < Value
       # @api private
       def task_id_string
         "Integer<#{@value}>"
@@ -33,6 +20,10 @@ module Pione
         return @value
       end
 
+      def to_seq
+        IntegerSequence.new([self])
+      end
+
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)
@@ -48,88 +39,131 @@ module Pione
 
       # @api private
       def inspect
-        "#<Pione::Model::PioneInteger @value=%s>" % @value.inspect
+        "#<PioneInteger %s>" % @value
       end
 
       # @api private
       alias :to_s :inspect
     end
 
-    TypeInteger.instance_eval do
-      define_pione_method("==", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value == other.value)
-      end
-
-      define_pione_method("!=", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
-      end
+    class IntegerSequence < OrdinalSequence
+      set_pione_model_type TypeInteger
+      set_element_class PioneInteger
+      set_shortname "ISeq"
+    end
 
+    TypeInteger.instance_eval do
       define_pione_method(">", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value > other.value)
+        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
+          rec_elt.value > other_elt.value
+        end
       end
 
       define_pione_method(">=", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.or(rec.call_pione_method(">", other),
-          rec.call_pione_method("==", other))
+        BooleanSequence.new(
+          [PioneBoolean.new(rec.call_pione_method(">", other).value || rec.call_pione_method("==", other).value)]
+        )
       end
 
       define_pione_method("<", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value < other.value)
+        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
+          rec_elt.value < other_elt.value
+        end
       end
 
       define_pione_method("<=", [TypeInteger], TypeBoolean) do |rec, other|
-        PioneBoolean.or(rec.call_pione_method("<", other),
-          rec.call_pione_method("==", other))
+        BooleanSequence.new(
+          [PioneBoolean.new(
+              rec.call_pione_method("<", other).value ||
+              rec.call_pione_method("==", other).value
+          )]
+        )
       end
 
       define_pione_method("+", [TypeInteger], TypeInteger) do |rec, other|
-        PioneInteger.new(rec.value + other.value)
+        sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
+          rec_elt.value + other_elt.value
+        end
       end
 
       define_pione_method("-", [TypeInteger], TypeInteger) do |rec, other|
-        PioneInteger.new(rec.value - other.value)
+        sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
+          rec_elt.value - other_elt.value
+        end
       end
 
       define_pione_method("*", [TypeInteger], TypeInteger) do |rec, other|
-        PioneInteger.new(rec.value * other.value)
+        sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
+          rec_elt.value * other_elt.value
+        end
       end
 
       define_pione_method("%", [TypeInteger], TypeInteger) do |rec, other|
         # TODO: zero division error
-        PioneInteger.new(rec.value % other.value)
+        sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
+          rec_elt.value % other_elt.value
+        end
       end
 
       define_pione_method("/", [TypeInteger], TypeInteger) do |rec, other|
         # TODO: zero division error
-        PioneInteger.new(rec.value / other.value)
+        sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
+          rec_elt.value / other_elt.value
+        end
       end
 
       define_pione_method("as_string", [], TypeString) do |rec|
-        PioneString.new(rec.value.to_s)
+        sequential_map1(TypeString, rec) {|elt| elt.value.to_s}
       end
 
-      define_pione_method("as_int", [], TypeInteger) do |rec|
+      define_pione_method("as_integer", [], TypeInteger) do |rec|
         rec
       end
 
       define_pione_method("as_float", [], TypeFloat) do |rec|
-        PioneFloat.new(rec.value.to_f)
+        sequential_map1(TypeFloat, rec) {|elt| elt.value.to_f}
       end
 
       define_pione_method("next", [], TypeInteger) do |rec|
-        PioneInteger.new(rec.value.next)
+        sequential_map1(TypeInteger, rec) {|elt| elt.value.next}
       end
 
       define_pione_method("prev", [], TypeInteger) do |rec|
-        PioneInteger.new(rec.value.pred)
+        sequential_map1(TypeInteger, rec) {|elt| elt.value.pred}
       end
 
       define_pione_method("even?", [], TypeBoolean) do |rec|
-        PioneBoolean.new(rec.value.even?)
+        sequential_pred1(rec) {|elt| elt.value.even?}
       end
 
       define_pione_method("odd?", [], TypeBoolean) do |rec|
-        PioneBoolean.new(rec.value.odd?)
+        sequential_pred1(rec) {|elt| elt.value.odd?}
+      end
+
+      # upto : *integer -> *integer
+      define_pione_method("upto", [TypeInteger], TypeInteger) do |rec, max|
+        sequential_fold2(TypeInteger, rec, max) do |seq, rec_elt, max_elt|
+          if rec_elt.value < max_elt.value
+            rec_elt.value.upto(max_elt.value).inject(seq) do |_seq, i|
+              _seq.push(PioneInteger.new(i))
+            end
+          else
+            seq.push(rec_elt)
+          end
+        end
+      end
+
+      # downto : *integer -> *integer
+      define_pione_method("downto", [TypeInteger], TypeInteger) do |rec, min|
+        sequential_fold2(TypeInteger, rec, min) do |seq, rec_elt, min_elt|
+          if rec_elt.value > min_elt.value
+            rec_elt.value.downto(min_elt.value).inject(seq) do |_seq, i|
+              _seq.push(PioneInteger.new(i))
+            end
+          else
+            seq.push(rec_elt)
+          end
+        end
       end
     end
   end

data/lib/pione/model/keyed-sequence.rb

@@ -0,0 +1,143 @@
+module Pione
+  module Model
+    # KeyedSequence is a sequence that have key and value pairs.
+    class KeyedSequence < Sequence
+      set_pione_model_type TypeKeyedSequence
+      set_shortname "KeyedSeq"
+
+      class << self
+        def empty(attributes={})
+          new({}, attributes)
+        end
+      end
+
+      # @param elements [Hash{Element => Sequence}]
+      #   sequence elements
+      # @param attribute [Hash]
+      #   sequence attribute
+      def initialize(elements, attribute={})
+        raise ArgumentError.new(elements) unless elements.kind_of?(Hash)
+        @elements = elements
+        @attribute = Hash.new.merge(attribute)
+
+        # fill default value
+        sequence_attribute.each do |name, values|
+          @attribute[name] ||= values.first
+        end
+      end
+
+      def index_type
+        ordinal_sequence_of_element(@elements.keys.first).pione_model_type
+      end
+
+      def element_type
+        ordinal_sequence_of_element(@elements.values.flatten.first).pione_model_type
+      end
+
+      def ordinal_sequence_of_element(elt)
+        case elt
+        when PioneInteger
+          IntegerSequence
+        when PioneString
+          StringSequence
+        when PioneFloat
+          FloatSequence
+        when PioneBoolean
+          BooleanSequence
+        when DataExpr
+          DataExprSequence
+        else
+          raise ArgumentError.new(elt)
+        end
+      end
+
+      # Concatenate another sequence.
+      #
+      # @param other [Sequence]
+      #   other sequence
+      # @return [Sequence]
+      #   a new sequence that have members of self and other
+      def concat(other)
+        raise SequenceAttributeError.new(other) unless @attribute == other.attribute
+        new_elements = (@elements.to_a + other.elements.to_a).inject({}) do |elts, list|
+          key, vals = list
+          elts[key] = (elts[key] ||= []) + vals
+          elts
+        end
+        self.class.new(new_elements, @attribute)
+      end
+
+      # Get the element by the key.
+      #
+      # @param key [Element]
+      #   index key
+      # @return [BasicModel]
+      #   element
+      def get(key)
+        @elements[key] || []
+      end
+
+      # Put the element to the sequecence.
+      #
+      # @param key [Element]
+      #   the key
+      # @param element [Element]
+      #   the element
+      # @return [Sequence]
+      #   a new sequence that have member self and the element.
+      def put(key, element)
+        raise ArgumentError.new(element) unless element.kind_of?(Element)
+        self.class.new(@elements.merge({key => get(key) + [element]}), @attribute)
+      end
+
+      # Iterate each elements.
+      #
+      # @return [Enumerator]
+      #   return an enumerator if the block is not given
+      def each
+        if block_given?
+          @elements.each {|key, val| yield self.class.new({key => val}, @attribute)}
+        else
+          Enumerator.new(self, :each)
+        end
+      end
+
+      def eval(vtable)
+        new_elements = @elements.inject({}) do |elts, key, val|
+          elts[key.eval(vtable)] = val.eval(vtable)
+        end
+        self.class.new(new_elements, @attribute)
+      end
+
+      def include_variable?
+        @elements.any?{|key, value| key.include_variable? or val.include_variable?}
+      end
+
+      def textize
+        inspect
+      end
+
+      def inspect
+        "#<%s [%s] %s>" % [shortname, @elements.map{|key, vals| "%s:(%s)" % [key.textize, vals.map{|val| val.textize}.join("|")]}.join(","), @attribute]
+      end
+    end
+
+    TypeKeyedSequence.instance_eval do
+      define_pione_method("keys", [], :index_type) do |rec|
+        keys = rec.elements.keys
+        rec.ordinal_sequence_of_element(keys.first).new(keys)
+      end
+
+      define_pione_method("values", [], :element_type) do |rec|
+        vals = rec.elements.values.flatten
+        rec.ordinal_sequence_of_element(vals.first).new(vals)
+      end
+
+      define_pione_method("[]", [:index_type], :element_type) do |rec, index|
+        index.elements.map do |index_elt|
+          rec.elements[index_elt]
+        end.flatten.tap{|x| break rec.ordinal_sequence_of_element(x.first).new(x, rec.attribute)}
+      end
+    end
+  end
+end

data/lib/pione/model/list.rb

@@ -3,7 +3,7 @@ module Pione::Model
   class PioneList < BasicModel
     extend Forwardable
 
-    set_pione_model_type TypeList[TypeAny]
+    set_pione_model_type TypeList[TypeSequence]
 
     attr_reader :values
     def_delegators :@values, :[], :size, :empty?
@@ -27,7 +27,7 @@ module Pione::Model
     # @return [TypeList]
     #   the type
     def pione_model_type
-      type = @values.empty? ? TypeAny : @values.first.pione_model_type
+      type = @values.empty? ? TypeSequence : @values.first.pione_model_type
       TypeList.new(type)
     end
 
@@ -69,23 +69,23 @@ module Pione::Model
     # pione method
     #
 
-    define_pione_method("==", [TypeList[TypeAny]], TypeBoolean) do |rec, other|
+    define_pione_method("==", [TypeList[TypeSequence]], TypeBoolean) do |rec, other|
       PioneBoolean.new(rec.values == other.values)
     end
 
-    define_pione_method("!=", [TypeList[TypeAny]], TypeBoolean) do |rec, other|
+    define_pione_method("!=", [TypeList[TypeSequence]], TypeBoolean) do |rec, other|
       PioneBoolean.not(rec.call_pione_method("==", other))
     end
 
-    define_pione_method("+", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+    define_pione_method("+", [TypeList[TypeSequence]], TypeList[TypeSequence]) do |rec, other|
       PioneList.new(rec.values + other.values)
     end
 
-    define_pione_method("-", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+    define_pione_method("-", [TypeList[TypeSequence]], TypeList[TypeSequence]) do |rec, other|
       PioneList.new(rec.values - other.values)
     end
 
-    define_pione_method("*", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+    define_pione_method("*", [TypeList[TypeSequence]], TypeList[TypeSequence]) do |rec, other|
       PioneList.new(rec.values * other.values)
     end
 
@@ -93,12 +93,16 @@ module Pione::Model
       PioneBoolean.new(rec.empty?)
     end
 
-    define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
+    define_pione_method("[]", [TypeInteger], TypeSequence) do |rec, i|
       rec.values[i.value]
     end
 
     define_pione_method("as_string", [], TypeString) do |rec|
       PioneString.new(rec.values.to_s)
     end
+
+    define_pione_method("str", [], TypeString) do |rec|
+      rec.call_pione_method("as_string")
+    end
   end
 end

data/lib/pione/model/message.rb

@@ -36,11 +36,11 @@ module Pione
 
       # Return PIONE model type of the message result according to type interface.
       #
-      # @return [Symbol]
+     # @return [Symbol]
       #   PIONE model type
       def pione_model_type
-        if interface = @receiver.pione_model_type.method_interface[@name.to_s]
-          interface.output
+        if pione_method = @receiver.pione_model_type.find_method(@name, @receiver, *@arguments)
+          pione_method.get_output_type(@receiver)
         else
           raise MethodNotFound.new(@name.to_s, self)
         end
@@ -68,10 +68,14 @@ module Pione
 
       # @api private
       def textize
-        args = [@name, @receiver.textize, @arguments.textize]
+        args = [@name, @receiver.textize, @arguments.map{|arg| arg.textize}.join(",")]
         "message(\"%s\",%s,[%s])" % args
       end
 
+      def inspect
+        '#<Message "%s" %s %s>' % [@name, @receiver.inspect, @arguments.inspect]
+      end
+
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)

data/lib/pione/model/ordinal-sequence.rb

@@ -0,0 +1,75 @@
+module Pione
+  module Model
+    class OrdinalSequence < Sequence
+      set_index_type TypeInteger
+      define_sequence_attribute :separator, " "
+
+      # @param elements [Array<Element>]
+      #   sequence elements
+      # @param attribute [Hash]
+      #   sequence attribute
+      def initialize(elements, attribute={})
+        super(elements, attribute)
+      end
+    end
+
+    TypeOrdinalSequence.instance_eval do
+      define_pione_method("==", [:receiver_type], TypeBoolean) do |rec, other|
+        if rec.elements.size == other.elements.size
+          rec.elements.size.times.all? do |i|
+            rec.elements[i].value == other.elements[i].value
+          end.tap {|x| break BooleanSequence.new([PioneBoolean.new(x)])}
+        else
+          BooleanSequence.new([PioneBoolean.new(false)])
+        end
+      end
+
+      define_pione_method("nth", [TypeInteger], :receiver_type) do |rec, index|
+        map1(index) do |elt|
+          elt.value == 0 ? rec : rec.elements[elt.value-1]
+        end
+      end
+
+      define_pione_method("[]", [:index_type], :receiver_type) do |rec, index|
+        rec.call_pione_method("nth", index)
+      end
+
+      define_pione_method("reverse", [], :receiver_type) do |rec|
+        rec.class.new(rec.elements.reverse, rec.attribute)
+      end
+
+      define_pione_method("head", [], :receiver_type) do |rec|
+        rec.class.new([rec.elements[0]], rec.attribute)
+      end
+
+      define_pione_method("tail", [], :receiver_type) do |rec|
+        # NOTE: #tail should fail when the sequence length is less than 1
+        rec.class.new(rec.elements[1..-1], rec.attribute)
+      end
+
+      define_pione_method("last", [], :receiver_type) do |rec|
+        rec.class.new([rec.elements[-1]], rec.attribute)
+      end
+
+      define_pione_method("init", [], :receiver_type) do |rec|
+        # NOTE: #init should fail when the sequence length is less than 1
+        rec.class.new(rec.elements[0..-2], rec.attribute)
+      end
+
+      define_pione_method("type", [], TypeString) do |rec|
+        case rec
+        when StringSequence
+          "string"
+        when IntegerSequence
+          "integer"
+        when FloatSequence
+          "float"
+        when BooleanSequence
+          "boolean"
+        else
+          "undefined"
+        end.tap {|x| break PioneString.new(x).to_seq}
+      end
+    end
+  end
+end

data/lib/pione/model/package.rb

@@ -1,9 +1,8 @@
 module Pione
   module Model
     # Package is a PIONE model class for rule package.
-    class Package < BasicModel
+    class Package < Element
       attr_reader :name
-      set_pione_model_type TypePackage
 
       # Create a package with name.
       #
@@ -48,5 +47,10 @@ module Pione
         @value.hash
       end
     end
+
+    class PackageSequence < Sequence
+      set_pione_model_type TypePackage
+      set_element_class Package
+    end
   end
 end