pione 0.2.2 → 0.3.0

data/lib/pione/lang/sequence.rb

@@ -0,0 +1,215 @@
+module Pione
+  module Lang
+    # SequenceAttributeError is an exception for attribute mismatching.
+    class SequenceAttributeError < StandardError
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def message
+        "attribute mismatched: %s" % @attribute
+      end
+    end
+
+    # Sequence is a base class for all expressions.
+    class Sequence < Expr
+      include Enumerable         # use iteration
+      include Util::Positionable # Sequence have position in source maybe
+      include Callable           # provides #call_pione_method
+      immutable true
+
+      class << self
+        def inherited(subclass)
+          members.each {|member_name| subclass.member(member_name, default: default_values[member_name])}
+          subclass.immutable true
+          subclass.index_type(index_type)
+        end
+
+        # Get/set piece class.
+        def piece_class(klass)
+          (@piece_classes ||= []) << klass
+        end
+
+        def piece_classes
+          @piece_classes ||= []
+        end
+
+        # Set the index type.
+        def index_type(type=nil)
+          type ? @index_type = type : @index_type
+        end
+      end
+
+      # Make a void sequence.
+      def Sequence.void
+        Sequence.new([])
+      end
+
+      member :pieces, default: []
+      member :distribution, default: :each, values: [:each, :all]
+      member :annotation_type
+
+      forward! :class, :piece_classes, :index_type
+      forward! Proc.new{pieces}, :size, :length, :include?
+
+      # Return true if the sequence is void.
+      #
+      # @return [Boolean]
+      #   true if the sequence is void
+      def void?
+        self.class == Sequence and empty?
+      end
+
+      # Return true if the sequence is assertive about attributes.
+      def assertive?
+        true
+      end
+
+      def attribute
+        members - [:pieces]
+      end
+
+      # Concatenate self and another sequence. If self and another are
+      # assertive, raise +SequenceAttributeError+ exception when the attributes
+      # are different.
+      #
+      # @param other [Sequence]
+      #   other sequence
+      # @return [Sequence]
+      #   a new sequence that have members of self and other
+      def concat(other)
+        if assertive? and other.assertive?
+          raise SequenceAttributeError.new(other) unless attribute == other.attribute
+        end
+        attr = not(other.assertive?) ? @attribute : other.attribute
+        set(pieces: pieces + other.pieces)
+      end
+      alias :+ :concat
+
+      # Push the piece to the sequecence.
+      def push(piece)
+        set(pieces: pieces + [piece])
+      end
+
+      # Iterate each elements.
+      #
+      # @return [Enumerator]
+      #   return an enumerator if the block is not given
+      def each
+        if block_given?
+          pieces.each {|e| yield set(pieces: [e])}
+        else
+          Enumerator.new(self, :each)
+        end
+      end
+
+      def eval(env)
+        set(pieces: pieces.map{|piece| piece.eval(env)})
+      end
+
+      # Update pieces with the data.
+      def update_pieces(data)
+        _pieces = pieces.map do |piece|
+          _data = data.inject({}) do |tbl, (key, val)|
+            tbl.tap {|x| x[key] = val.kind_of?(Proc) ? val.call(piece) : val}
+          end
+          piece.set(_data)
+        end
+        set(pieces: _pieces)
+      end
+
+      # Set the annotation type to the sequence.
+      def set_annotation_type(type)
+        set(annotation_type: type)
+      end
+    end
+
+    TypeSequence.instance_eval do
+      # Provides not-equal method.
+      define_pione_method("!=", [:receiver_type], TypeBoolean) do |env, rec, other|
+        rec.call_pione_method(env, "==", [other]).call_pione_method(env, "not", [])
+      end
+
+      # Concatenate sequences.
+      define_pione_method("|", [:receiver_type], :receiver_type) do |env, rec, other|
+        rec + other
+      end
+
+      # Set "each" into the distribution.
+      define_pione_method("each", [], :receiver_type) do |env, rec|
+        rec.set(distribution: :each)
+      end
+
+      # Return true if the distribution of sequence is "each".
+      define_pione_method("each?", [], TypeBoolean) do |env, rec|
+        BooleanSequence.of(rec.distribution == :each)
+      end
+
+      # Set "all" into the distribution.
+      define_pione_method("all", [], :receiver_type) do |env, rec|
+        rec.set(distribution: :all)
+      end
+
+      # Return true if the distribution of sequence is "all".
+      define_pione_method("all?", [], TypeBoolean) do |env, rec|
+        BooleanSequence.of(rec.distribution == :all)
+      end
+
+      # Return the integer sequence.
+      define_pione_method("i", [], TypeInteger) do |env, rec|
+        rec.call_pione_method(env, "as_integer", [])
+      end
+
+      # Return the float sequence.
+      define_pione_method("f", [], TypeFloat) do |env, rec|
+        rec.call_pione_method(env, "as_float", [])
+      end
+
+      # Return the string sequence.
+      define_pione_method("str", [], TypeString) do |env, rec|
+        rec.call_pione_method(env, "as_string", [])
+      end
+
+      # Return the data expression sequence.
+      define_pione_method("d", [], TypeDataExpr) do |env, rec|
+        rec.call_pione_method(env, "as_data_expr", [])
+      end
+
+      # Return length of the sequence.
+      define_pione_method("length", [], TypeInteger) do |env, rec|
+        IntegerSequence.of(rec.pieces.size)
+      end
+
+      # Alias of #nth.
+      define_pione_method("[]", [:index_type], :receiver_type) do |env, rec, index|
+        rec.call_pione_method(env, "nth", [index])
+      end
+
+      # Return boolean sequence that receiver includes the piece of target.
+      define_pione_method("member?", [:receiver_type], TypeBoolean) do |env, rec, target|
+        BooleanSequence.map(target) {|piece| rec.pieces.include?(piece)}
+      end
+
+      # Return true if the sequence is empty.
+      define_pione_method("empty?", [], TypeBoolean) do |env, rec|
+        BooleanSequence.of(rec.pieces.size == 0)
+      end
+
+      # Create a keyed sequence.
+      define_pione_method(":", [TypeSequence], TypeKeyedSequence) do |env, key, val|
+        key.pieces.map do |key_elt|
+          KeyedSequence.new(pieces: {key.set(pieces: [key_elt]) => val})
+        end.inject{|s1, s2| s1 + s2}
+      end
+
+      # Return PIONE string of the sequence.
+      define_pione_method("textize", [], TypeString) do |env, rec|
+        # convert pieces to strings
+        strings = rec.call_pione_method(env, "as_string", [])
+
+        # join it with separator
+        strings.call_pione_method(env, "join", [StringSequence.of(rec.separator)])
+      end
+    end
+  end
+end

data/lib/pione/lang/string.rb

@@ -0,0 +1,116 @@
+module Pione
+  module Lang
+    # PioneString is a string value in PIONE system.
+    class PioneString < SimplePiece
+      piece_type_name "String"
+
+      # Expand embeded expressions.
+      def eval(env)
+        set(value: Util::EmbededExprExpander.expand(env, value))
+      end
+    end
+
+    class StringSequence < OrdinalSequence
+      pione_type TypeString
+      piece_class PioneString
+
+      # Return a string that is joined pieces string.
+      def value
+        @__value__ ||= pieces.map{|piece| piece.value}.join
+      end
+    end
+
+    TypeString.instance_eval do
+      # Concatenate strings.
+      define_pione_method("+", [TypeString], TypeString) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value + other_piece.value
+        end
+      end
+
+      # Return the receiver as is.
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        rec
+      end
+
+      # Convert to integer.
+      define_pione_method("as_integer", [], TypeInteger) do |env, rec|
+        IntegerSequence.map(rec) {|piece| piece.value.to_i}
+      end
+
+      # Convert to float.
+      define_pione_method("as_float", [], TypeFloat) do |env, rec|
+        FloatSequence.map(rec) {|piece| piece.value.to_f}
+      end
+
+      # Convert to data expression.
+      define_pione_method("as_data_expr", [], TypeDataExpr) do |env, rec|
+        DataExprSequence.map(rec) {|piece| piece.value}
+      end
+
+      # Count characters in the string.
+      define_pione_method("count", [], TypeInteger) do |env, rec|
+        IntegerSequence.map(rec) {|piece| piece.value.size}
+      end
+
+      # Return true if the string includes the target.
+      define_pione_method("include?", [TypeString], TypeBoolean) do |env, rec, target|
+        BooleanSequence.map2(rec, target) do |rec_piece, target_piece|
+          rec_piece.value.include?(target_piece.value)
+        end
+      end
+
+      # Return substring from the position to the length.
+      define_pione_method("substring", [TypeInteger, TypeInteger], TypeString) do |env, rec, nth, len|
+        rec.map3(nth, len) do |rec_piece, nth_piece, len_piece|
+          rec_piece.value[nth_piece.value-1, len_piece.value]
+        end
+      end
+
+      # insert : (pos : integer) -> (other : string) -> string
+      define_pione_method("insert", [TypeInteger, TypeString], TypeString) do |env, rec, pos, other|
+        rec.map3(pos, other) do |rec_piece, pos_piece, other_piece|
+          rec_piece.value.clone.insert(pos_piece.value-1, other_piece.value)
+        end
+      end
+
+      # join : string
+      define_pione_method("join", [], TypeString) do |env, rec|
+        rec.call_pione_method(env, "join", [StringSequence.of(rec.separator)])
+      end
+
+      # join : (sep : string) -> string
+      define_pione_method("join", [TypeString], TypeString) do |env, rec, sep|
+        rec.map_by(sep) do |sep_piece|
+          rec.pieces.map{|piece| piece.value}.join(sep_piece.value)
+        end
+      end
+
+      # author : string
+      # FIXME
+      define_pione_method("author", [], TypeString) do |env, rec|
+        rec.set_annotation_type(:author)
+      end
+
+      define_pione_method("PackageName", [], TypeString) do |env, rec|
+        rec.set_annotation_type("PackageName")
+      end
+
+      define_pione_method("Editor", [], TypeString) do |env, rec|
+        rec.set_annotation_type("Editor")
+      end
+
+      define_pione_method("Tag", [], TypeString) do |env, rec|
+        rec.set_annotation_type("Tag")
+      end
+
+      define_pione_method("ScenarioName", [], TypeString) do |env, rec|
+        rec.set_annotation_type("ScenarioName")
+      end
+
+      define_pione_method("ParamSet", [], TypeString) do |env, rec|
+        rec.set_annotation_type("ParamSet")
+      end
+    end
+  end
+end

data/lib/pione/lang/ticket-expr.rb

@@ -0,0 +1,48 @@
+module Pione
+  module Lang
+    # TicketExpr is a ticket expression as alternative input or output
+    # conditions of rules for serial processing.
+    #
+    # @example Serial process of rule A and B by tickets in PIONE flow rule
+    #   Rule Main
+    #     input '*.in'
+    #     output '*.out'
+    #   Flow
+    #     rule A ==> <T>
+    #     <T> ==> rule B
+    #   End
+    class TicketExpr < Piece
+      piece_type_name "TicketExpr"
+      member :name
+
+      # Convert to text string.
+      def textize
+        "<%s>" % name
+      end
+    end
+
+    # TicketExprSequence is a ordinal sequence of ticket expressions.
+    class TicketExprSequence < OrdinalSequence
+      pione_type TypeTicketExpr
+      piece_class TicketExpr
+
+      # Return ticket names of all elements in the sequence.
+      def names
+        pieces.map {|piece| piece.name}
+      end
+    end
+
+    TypeTicketExpr.instance_eval do
+      # Update ticket condition of the other by adding receiver tickets
+      define_pione_method("==>", [TypeRuleExpr], TypeRuleExpr) do |env, rec, other|
+        other.map do |piece|
+          piece.set(input_tickets: piece.input_tickets + rec)
+        end
+      end
+
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        StringSequence.map(rec) {|piece| piece.textize}
+      end
+    end
+  end
+end

data/lib/pione/{model → lang}/type.rb

@@ -1,34 +1,21 @@
 module Pione
-  module Model
+  module Lang
     # Type is a class for type expression of PIONE model objects.
-    class Type < System::PioneObject
-      @table = Hamster.hash
+    class Type < StructX
+      @table = Hash.new
 
       class << self
-        def put(name, value)
-          @table = @table.put(name, value)
-        end
-
-        def get(name)
-          @table.get(name)
-        end
+        attr_reader :table
       end
 
-      attr_reader :name
-      attr_reader :parent_type
-      attr_reader :pione_method
+      member :name
+      member :parent_type
+      member :pione_method, default: lambda { Hash.new }
 
       # Create a type for PIONE model object.
-      #
-      # @param name [Symbol]
-      #   type name
-      # @param parent_type [Type]
-      #   parent type
-      def initialize(name, parent_type=nil)
-        @name = name
-        @parent_type = parent_type
-        @pione_method = Hamster.hash
-        Type.put(name, self)
+      def initialize(*args)
+        super(*args)
+        Type.table[name] = {parent: parent_type}
       end
 
       # Return true if the type or the pione model object matches.
@@ -38,7 +25,7 @@ module Pione
       # @return [Boolean]
       #   true if it matches, or false
       def match(target)
-        target_type = target.pione_model_type
+        target_type = target.pione_type
         while target_type do
           return true if self == target_type
           target_type = target_type.parent_type
@@ -47,42 +34,37 @@ module Pione
       end
 
       # Find named method.
-      #
-      # @param name [String]
-      #   method name
-      # @param rec [Callable]
-      #   receiver
-      # @param args [Array<BasicModel>]
-      #   arguments
-      # @return [void]
-      def find_method(name, rec, *args)
-        name = name.to_s
-        if @pione_method.has_key?(name)
-          @pione_method[name].each do |pione_method|
-            if pione_method.validate_inputs(rec, *args)
-              return pione_method
+      def find_method(env, name, rec, args)
+        # find a suitable method
+        if pione_method.has_key?(name)
+          group = pione_method[name].group_by{|m| m.method_type}
+
+          # exist deferred methods
+          if group.has_key?(:deferred)
+            if m = group[:deferred].find {|m| m.validate_inputs(rec, args)}
+              return m
             end
           end
-        else
-          return @parent_type ? @parent_type.find_method(name, rec, *args) : nil
+
+          # try immediate methods
+          _args = args.map {|arg| arg.eval(env)} # FIXME : should be replaced by type inference
+          return group[:immediate].find {|m| m.validate_inputs(rec, _args)}
+        end
+
+        # find from parent type
+        if parent_type
+          return parent_type.find_method(env, name, rec, args)
         end
       end
 
-      # Define PIONE model object methods.
-      #
-      # @param name [Symbol]
-      #   method name
-      # @param inputs [Array<Type>]
-      #   input types of the method
-      # @param output [Type]
-      #   output type of the method
-      # @param [Proc] b
-      # @return [void]
+      # Define PIONE methods. Arguments are evaluated immediately.
       def define_pione_method(name, inputs, output, &b)
-        name = name.to_s
-        method = PioneMethod.new(name, inputs, output, b)
-        list = @pione_method.fetch(name, Hamster.list)
-        @pione_method = @pione_method.put(name, list.cons(method))
+        (pione_method[name] ||= []) << PioneMethod.new(:immediate, name, inputs, output, b)
+      end
+
+      # Define PIONE methods. Arguments are non-evaluated.
+      def define_deferred_pione_method(name, inputs, output, &b)
+        (pione_method[name] ||= []) << PioneMethod.new(:deferred, name, inputs, output, b)
       end
 
       # Return true if the data has the type.
@@ -90,85 +72,70 @@ module Pione
       # @return [void]
       def check(data)
         unless match(data)
-          raise PioneModelTypeError.new(data, self)
+          raise PioneTypeError.new(data, self)
         end
       end
 
-      def type_to_class(type)
-        case type
-        when TypeString
-          StringSequence
-        when TypeInteger
-          IntegerSequence
-        when TypeFloat
-          FloatSequence
-        when TypeBoolean
-          BooleanSequence
-        when TypeDataExpr
-          DataExprSequence
-        when TypeTicketExpr
-          TicketExprSequence
-        end
+      def sequence_class
+        Type.table[self.name][:sequence_class]
       end
 
       def map1(seq, &b)
-        seq_class = type_to_class(self)
-        seq_class.new(seq.elements.map{|elt| b.call(elt)}, seq.attribute)
+        sequence_class.of(seq.pieces.map{|elt| b.call(elt)}, seq.attribute)
       end
 
       def map2(seq1, seq2, &b)
-        seq_class = type_to_class(self)
-        seq1.elements.map do |elt1|
-          seq2.elements.map do |elt2|
+        seq1.pieces.map do |elt1|
+          seq2.pieces.map do |elt2|
             b.call(elt1, elt2)
           end
-        end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
+        end.flatten.tap {|x| break sequence_class.new(x, seq1.attribute)}
       end
 
       def sequential_map1(type, seq1, &b)
         seq_class = type_to_class(type)
-        seq1.elements.map do |elt1|
-          seq_class.element_class.new(b.call(elt1))
+        seq1.pieces.map do |elt1|
+          seq_class.piece_class.new(b.call(elt1))
         end.tap {|x| break seq_class.new(x, seq1.attribute)}
       end
 
       def sequential_map2(type, seq1, seq2, &b)
         seq_class = type_to_class(type)
-        seq1.elements.map do |elt1|
-          seq2.elements.map do |elt2|
-            seq_class.element_class.new(b.call(elt1, elt2))
+        seq1.pieces.map do |elt1|
+          seq2.pieces.map do |elt2|
+            seq_class.piece_class.new(b.call(elt1, elt2))
           end
-        end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
+        end.flatten.tap {|x| break seq1.set(x, seq1.attribute)}
       end
 
       def sequential_map3(type, seq1, seq2, seq3, &b)
         seq_class = type_to_class(type)
-        seq1.elements.map do |elt1|
-          seq2.elements.map do |elt2|
-            seq3.elements.map do |elt3|
-              seq_class.element_class.new(b.call(elt1, elt2, elt3))
+        seq1.pieces.map do |elt1|
+          seq2.pieces.map do |elt2|
+            seq3.pieces.map do |elt3|
+              seq_class.piece_class.new(b.call(elt1, elt2, elt3))
             end
           end
         end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
       end
 
       def fold1(val, seq1, &b)
-        seq1.elements.inject(val) do |obj, elt1|
+        seq1.pieces.inject(val) do |obj, elt1|
           b.call(obj, elt1)
         end
       end
 
       def sequential_fold1(type, seq1, &b)
         seq_class = type_to_class(type)
-        seq1.elements.inject(seq_class.new([], seq1.attribute)) do |obj, elt1|
+        seq1.pieces.inject(seq_class.new([], seq1.attribute)) do |obj, elt1|
           b.call(elt1, obj)
         end
       end
 
       def sequential_fold2(type, seq1, seq2, &b)
         seq_class = type_to_class(type)
-        seq1.elements.inject(seq_class.new([], seq1.attribute)) do |obj1, elt1|
-          seq2.elements.inject(obj1) do |obj2, elt2|
+        seq1.pieces.inject(seq_class.new([], seq1.attribute)) do |obj1, elt1|
+          seq2.pieces.inject(obj1) do |obj2, elt2|
             b.call(obj2, elt1, elt2)
           end
         end
@@ -176,7 +143,7 @@ module Pione
 
       def sequential_pred1(seq1, &b)
         method1 = seq1.every? ? :all? : :any?
-        seq1.elements.send(method1) do |elt1|
+        seq1.pieces.send(method1) do |elt1|
           PioneBoolean.new(b.call(elt1))
         end.tap {|x| break BooleanSequence.new(x)}
       end
@@ -184,18 +151,25 @@ module Pione
       def sequential_pred2(seq1, seq2, &b)
         method1 = seq1.every? ? :all? : :any?
         method2 = seq2.every? ? :all? : :any?
-        seq1.elements.send(method1) do |elt1|
-          seq2.elements.send(method2) do |elt2|
+        seq1.pieces.send(method1) do |elt1|
+          seq2.pieces.send(method2) do |elt2|
             b.call(elt1, elt2)
           end
         end.tap {|x| break BooleanSequence.new([PioneBoolean.new(x)])}
       end
 
       def to_s
-        "#<Type %s>" % @name
+        "#<Type %s>" % name
+      end
+
+      def inspect
+        "#<Type %s>" % name
       end
     end
 
+    # TypeVariable is a type for variable names.
+    TypeVariable = Type.new("variable")
+
     # TypeSequence is a type for sequence of something.
     TypeSequence = Type.new("sequence")
 
@@ -226,15 +200,12 @@ module Pione
     # rule expression type for PIONE system
     TypeRuleExpr = Type.new("rule-expr", TypeOrdinalSequence)
 
-    # parameters type for PIONE system
-    TypeParameters = Type.new("parameters", TypeOrdinalSequence)
+    # parameter set type for PIONE system
+    TypeParameterSet = Type.new("parameter-set", TypeOrdinalSequence)
 
     # assignment type for PIONE system
     TypeAssignment = Type.new("assignment", TypeOrdinalSequence)
 
-    # variable table type for PIONE system
-    TypeVariableTable = Type.new("variable-table", TypeOrdinalSequence)
-
     # package type for PIONE system
     TypePackageExpr = Type.new("package-expr", TypeOrdinalSequence)