pione 0.1.4 → 0.2.0

data/lib/pione/model/block.rb

@@ -157,7 +157,7 @@ module Pione
     #     rule Test2
     #   end
     #   #=> ConditionalBlock.new(
-    #         BinaryOperator::Equals.new(Variable.new('X'), 'a'),
+    #         Message.new("==", Variable.new('X'), StringSequence.new([PioneString.new("a")])),
     #         { true => [CallRule.new('Test1')],
     #           :else => [CallRule.new('Test2')] })
     # @example

data/lib/pione/model/boolean.rb

@@ -60,11 +60,6 @@ module Pione
         @value = value
       end
 
-      # @api private
-      def task_id_string
-        "Boolean<#{@value}>"
-      end
-
       # @api private
       def textize
         @value.to_s
@@ -86,14 +81,6 @@ module Pione
         @value == false
       end
 
-      # Return ruby's boolean value.
-      #
-      # @return [Boolean]
-      #   ruby's boolean value
-      def to_ruby
-        return @value
-      end
-
       def to_seq
         BooleanSequence.new([self])
       end
@@ -131,49 +118,49 @@ module Pione
     #
 
     TypeBoolean.instance_eval do
-      define_pione_method("and", [TypeBoolean], TypeBoolean) do |rec, other|
+      define_pione_method("and", [TypeBoolean], TypeBoolean) do |vtable, rec, 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|
+      define_pione_method("or", [TypeBoolean], TypeBoolean) do |vtable, rec, 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|
+      define_pione_method("as_integer", [], TypeInteger) do |vtable, rec|
         sequential_map1(TypeInteger, rec) {|rec| rec.value ? 1 : 0}
       end
 
-      define_pione_method("as_float", [], TypeFloat) do |rec|
+      define_pione_method("as_float", [], TypeFloat) do |vtable, rec|
         sequential_map1(TypeFloat, rec) {|rec| rec.value ? 1.0 : 0.0}
       end
 
-      define_pione_method("as_string", [], TypeString) do |rec|
+      define_pione_method("as_string", [], TypeString) do |vtable, rec|
         sequential_map1(TypeString, rec) {|rec| rec.value.to_s}
       end
 
-      define_pione_method("as_data_expr", [], TypeDataExpr) do |rec|
+      define_pione_method("as_data_expr", [], TypeDataExpr) do |vtable, rec|
         sequential_map1(TypeDataExpr, rec) {|rec| rec.value.to_s}
       end
 
-      define_pione_method("not", [], TypeBoolean) do |rec|
+      define_pione_method("not", [], TypeBoolean) do |vtable, rec|
         sequential_map1(TypeBoolean, rec) do |elt|
           not(elt.value)
         end
       end
 
-      define_pione_method("every?", [], TypeBoolean) do |rec|
+      define_pione_method("every?", [], TypeBoolean) do |vtable, rec|
         PioneBoolean.new(not(rec.elements.include?(PioneBoolean.false))).to_seq
       end
 
-      define_pione_method("any?", [], TypeBoolean) do |rec|
+      define_pione_method("any?", [], TypeBoolean) do |vtable, rec|
         PioneBoolean.new(rec.elements.include?(PioneBoolean.true)).to_seq
       end
 
-      define_pione_method("one?", [], TypeBoolean) do |rec|
+      define_pione_method("one?", [], TypeBoolean) do |vtable, rec|
         PioneBoolean.new(rec.elements.select{|elt| elt == PioneBoolean.true}.size == 1).to_seq
       end
     end

data/lib/pione/model/constraints.rb

@@ -11,6 +11,8 @@ module Pione
         end
       end
 
+      attr_reader :exprs
+
       # @param exprs [Array<BasicModel>]
       #   constraint expressions
       def initialize(exprs)
@@ -29,6 +31,16 @@ module Pione
           res.kind_of?(BooleanSequence) and res.value
         end
       end
+
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @exprs == other.exprs
+      end
+      alias :eql? :"=="
+
+      def hash
+        @exprs.hash
+      end
     end
   end
 end

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

@@ -122,11 +122,6 @@ module Pione
         VariableTable.check_include_variable(name)
       end
 
-      # @api private
-      def task_id_string
-        "DataExpr<#{name}, [%s]>" % exceptions.map{|exc| exc.task_id_string}.join(",")
-      end
-
       # @api private
       def textize
         "data_expr(\"#{name}\", [%s])" % [
@@ -412,127 +407,125 @@ module Pione
 
       forward! Proc.new{@elements.first}, :match, :name
 
-      # Return true if the sequence accepts nonexistence matching. This is
-      # determined that it includes null expression.
       def accept_nonexistence?
-        @elements.any?{|elt| elt.accept_nonexistence?}
+        @elements.first.accept_nonexistence?
       end
     end
 
     TypeDataExpr.instance_eval do
-      define_pione_method("==", [TypeDataExpr], TypeBoolean) do |rec, other|
+      define_pione_method("==", [TypeDataExpr], TypeBoolean) do |vtable, rec, other|
         PioneBoolean.new(rec == other).to_seq
       end
 
-      define_pione_method("[]", [TypeInteger], TypeString) do |rec, index|
+      define_pione_method("[]", [TypeInteger], TypeString) do |vtable, rec, index|
         sequential_map2(TypeString, rec, index) do |rec_elt, index_elt|
           rec_elt.matched_data[index_elt.value]
         end.set_separator(DataExpr::SEPARATOR)
       end
 
-      define_pione_method("all", [], TypeDataExpr) do |rec|
+      define_pione_method("all", [], TypeDataExpr) do |vtable, rec|
         rec.set_all
       end
 
-      define_pione_method("all?", [], TypeBoolean) do |rec|
+      define_pione_method("all?", [], TypeBoolean) do |vtable, rec|
         rec.all?
       end
 
-      define_pione_method("each", [], TypeDataExpr) do |rec|
+      define_pione_method("each", [], TypeDataExpr) do |vtable, rec|
         rec.set_each
       end
 
-      define_pione_method("each?", [], TypeBoolean) do |rec|
+      define_pione_method("each?", [], TypeBoolean) do |vtable, rec|
         rec.each?
       end
 
-      define_pione_method("stdout", [], TypeDataExpr) do |rec|
+      define_pione_method("stdout", [], TypeDataExpr) do |vtable, rec|
         rec.set_stdout
       end
 
-      define_pione_method("stdout?", [], TypeBoolean) do |rec|
+      define_pione_method("stdout?", [], TypeBoolean) do |vtable, rec|
         rec.stdout?
       end
 
-      define_pione_method("stderr", [], TypeDataExpr) do |rec|
+      define_pione_method("stderr", [], TypeDataExpr) do |vtable, rec|
         rec.set_stderr
       end
 
-      define_pione_method("stderr?", [], TypeBoolean) do |rec|
+      define_pione_method("stderr?", [], TypeBoolean) do |vtable, rec|
         rec.stderr?
       end
 
-      define_pione_method("neglect", [], TypeDataExpr) do |rec|
+      define_pione_method("neglect", [], TypeDataExpr) do |vtable, rec|
         rec.set_neglect
       end
 
-      define_pione_method("neglect?", [], TypeBoolean) do |rec|
+      define_pione_method("neglect?", [], TypeBoolean) do |vtable, rec|
         rec.neglect?
       end
 
-      define_pione_method("care", [], TypeDataExpr) do |rec|
+      define_pione_method("care", [], TypeDataExpr) do |vtable, rec|
         rec.set_care
       end
 
-      define_pione_method("care?", [], TypeBoolean) do |rec|
+      define_pione_method("care?", [], TypeBoolean) do |vtable, rec|
         rec.care?
       end
 
-      define_pione_method("write", [], TypeDataExpr) do |rec|
+      define_pione_method("write", [], TypeDataExpr) do |vtable, rec|
         rec.set_write
       end
 
-      define_pione_method("write?", [], TypeBoolean) do |rec|
+      define_pione_method("write?", [], TypeBoolean) do |vtable, rec|
         rec.write?
       end
 
-      define_pione_method("remove", [], TypeDataExpr) do |rec|
+      define_pione_method("remove", [], TypeDataExpr) do |vtable, rec|
         rec.set_remove
       end
 
-      define_pione_method("remove?", [], TypeBoolean) do |rec|
+      define_pione_method("remove?", [], TypeBoolean) do |vtable, rec|
         rec.remove?
       end
 
-      define_pione_method("touch", [], TypeDataExpr) do |rec|
+      define_pione_method("touch", [], TypeDataExpr) do |vtable, rec|
         rec.set_touch
       end
 
-      define_pione_method("touch?", [], TypeBoolean) do |rec|
+      define_pione_method("touch?", [], TypeBoolean) do |vtable, rec|
         rec.touch?
       end
 
-      define_pione_method("except", [TypeDataExpr], TypeDataExpr) do |rec, target|
+      define_pione_method("except", [TypeDataExpr], TypeDataExpr) do |vtable, rec, target|
         map2(rec, target) do |rec_elt, target_elt|
           rec_elt.except(target_elt)
         end
       end
 
-      define_pione_method("exceptions", [], TypeDataExpr) do |rec|
+      define_pione_method("exceptions", [], TypeDataExpr) do |vtable, rec|
         rec.elements.map do |elt|
           elt.exceptions
         end.flatten.tap{|x| break DataExprSequence.new(x)}
       end
 
-      define_pione_method("or", [TypeDataExpr], TypeDataExpr) do |rec, other|
+      define_pione_method("or", [TypeDataExpr], TypeDataExpr) do |vtable, rec, other|
         map2(rec, other) do |rec_elt, other_elt|
           DataExprOr.new([rec_elt, other_elt])
         end
       end
 
-      define_pione_method("match", [TypeString], TypeString) do |rec, name|
+      define_pione_method("match", [TypeString], TypeString) do |vtable, rec, name|
         rec.match(name.value).to_a.inject(StringSequence.empty) do |seq, matched|
           seq.push(PioneString.new(matched))
         end
       end
 
-      define_pione_method("match?", [TypeString], TypeBoolean) do |rec, name|
+      define_pione_method("match?", [TypeString], TypeBoolean) do |vtable, rec, name|
         sequential_map2(TypeBoolean, rec, name) do |rec_elt, name_elt|
           not(rec_elt.match(name_elt.value).nil?)
         end
       end
 
-      define_pione_method("as_string", [], TypeString) do |rec|
+      define_pione_method("as_string", [], TypeString) do |vtable, rec|
         sequential_map1(TypeString, rec) do |rec_elt|
           case rec_elt
           when DataExprNull
@@ -545,8 +538,10 @@ module Pione
         end.set_separator(DataExpr::SEPARATOR)
       end
 
-      define_pione_method("accept_nonexistence?", [], TypeBoolean) do |rec|
-        PioneBoolean.new(rec.accept_nonexistence?).to_seq
+      define_pione_method("accept_nonexistence?", [], TypeBoolean) do |vtable, rec|
+        TypeBoolean.map1(rec) do |elt|
+          PioneBoolean.new(elt.accept_nonexistence?)
+        end
       end
     end
   end

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

@@ -84,11 +84,6 @@ module Pione::Model
 
     # SpecialFeature is a class for empty feature and boundless feature.
     class SpecialFeature < Expr
-      # @api private
-      def task_id_string
-        "Feature::SpecialFeature<#{symbol}>"
-      end
-
       # @api private
       def textize
         symbol
@@ -192,11 +187,6 @@ module Pione::Model
         super()
       end
 
-      # @api private
-      def task_id_string
-        "Feature::UnaryOperator<#{self.operator},#{@symbol}>"
-      end
-
       # @api private
       def textize
         "%s%s" % [self.operator, @symbol]
@@ -361,13 +351,6 @@ module Pione::Model
         return @elements.first.empty?
       end
 
-      # @api private
-      def task_id_string
-        "Feature::Connective<#{self.class.name},[%s]>" % [
-          @elements.map{|elt| elt.task_id_string}.join(",")
-        ]
-      end
-
       # @api private
       def textize
         "#{self.class.name}(%s)" % @elements.map{|elt| elt.textize}.join(",")
@@ -873,20 +856,20 @@ module Pione::Model
   end
 
   TypeFeature.instance_eval do
-    define_pione_method("==", [TypeFeature], TypeBoolean) do |rec, other|
+    define_pione_method("==", [TypeFeature], TypeBoolean) do |vtable, rec, other|
       PioneBoolean.new(rec == other).to_seq
     end
 
-    define_pione_method("!=", [TypeFeature], TypeBoolean) do |rec, other|
-      PioneBoolean.not(rec.call_pione_method("==", other)).to_seq
+    define_pione_method("!=", [TypeFeature], TypeBoolean) do |vtable, rec, other|
+      PioneBoolean.not(rec.call_pione_method(vtable, "==", other)).to_seq
     end
 
-    define_pione_method("as_string", [], TypeString) do |rec|
+    define_pione_method("as_string", [], TypeString) do |vtable, rec|
       PioneString.new(rec.as_string).to_seq
     end
 
-    define_pione_method("str", [], TypeString) do |rec|
-      rec.call_pione_method("as_string")
+    define_pione_method("str", [], TypeString) do |vtable, rec|
+      rec.call_pione_method(vtable, "as_string")
     end
   end
 end

data/lib/pione/model/float.rb

@@ -7,14 +7,6 @@ module Pione
         "#PioneFloat{%s}" % @value
       end
 
-      # Return ruby's value.
-      #
-      # @return [Float]
-      #   ruby's value
-      def to_ruby
-        return @value
-      end
-
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)
@@ -40,55 +32,74 @@ module Pione
     end
 
     TypeFloat.instance_eval do
-      define_pione_method(">", [TypeFloat], TypeBoolean) do |rec, other|
+      define_pione_method(">", [TypeFloat], TypeBoolean) do |vtable, rec, other|
         BooleanSequence.new([PioneBoolean.new(rec.value > other.value)])
       end
 
-      define_pione_method("<", [TypeFloat], TypeBoolean) do |rec, other|
+      define_pione_method("<", [TypeFloat], TypeBoolean) do |vtable, rec, other|
         BooleanSequence.new([PioneBoolean.new(rec.value < other.value)])
       end
 
-      define_pione_method("+", [TypeFloat], TypeFloat) do |rec, other|
+      define_pione_method("+", [TypeFloat], TypeFloat) do |vtable, rec, other|
         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|
+      define_pione_method("-", [TypeFloat], TypeFloat) do |vtable, rec, other|
         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|
+      define_pione_method("*", [TypeFloat], TypeFloat) do |vtable, rec, other|
         PioneFloat.new(rec.value * other.value)
       end
 
-      define_pione_method("%", [TypeFloat], TypeFloat) do |rec, other|
+      define_pione_method("%", [TypeFloat], TypeFloat) do |vtable, rec, other|
         # TODO: zero division error
         PioneFloat.new(rec.value % other.value)
       end
 
-      define_pione_method("/", [TypeFloat], TypeFloat) do |rec, other|
+      define_pione_method("/", [TypeFloat], TypeFloat) do |vtable, rec, other|
         # TODO: zero division error
         PioneFloat.new(rec.value / other.value)
       end
 
-      define_pione_method("as_string", [], TypeString) do |rec|
+      define_pione_method("as_string", [], TypeString) do |vtable, rec|
         sequential_map1(TypeString, rec) do |elt|
           elt.value.to_s
         end
       end
 
-      define_pione_method("as_integer", [], TypeInteger) do |rec|
+      define_pione_method("as_integer", [], TypeInteger) do |vtable, rec|
         sequential_map1(TypeInteger, rec) do |elt|
           elt.value.to_i
         end
       end
 
-      define_pione_method("as_float", [], TypeFloat) do |rec|
+      define_pione_method("as_float", [], TypeFloat) do |vtable, rec|
         rec
       end
+
+      # sin : float
+      define_pione_method("sin", [], TypeFloat) do |vtable, rec|
+        sequential_map1(TypeFloat, rec) do |elt|
+          Math.sin(elt.value)
+        end
+      end
+
+      # cos : float
+      define_pione_method("cos", [], TypeFloat) do |vtable, rec|
+        sequential_map1(TypeFloat, rec) do |elt|
+          Math.cos(elt.value)
+        end
+      end
+
+      # abs : float
+      define_pione_method("abs", [], TypeFloat) do |vtable, rec|
+        sequential_map1(TypeFloat, rec) {|elt| elt.value.abs}
+      end
     end
   end
 end