pione 0.2.2 → 0.3.0

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

@@ -0,0 +1,228 @@
+module Pione
+  module Lang
+    # ExprParser is a set of parser atoms for PIONE expressions.
+    module ExprParser
+      include Parslet
+
+      # +expr+ matches all expressions in PIONE document.
+      #
+      # @example
+      #   "abc"[0]
+      # @example
+      #   'abc'.as_string
+      # @example
+      #   1 + 1
+      # @example
+      #   (1 + 1).next
+      # @example
+      #   ("abc" + "def")[1]
+      # @example
+      #   true
+      # @example
+      #   '*.txt'.as_string
+      rule(:expr) {
+        (expr_operator_application | reverse_message_sending | expr_element).as(:expr)
+      }
+
+      def expr!(msg=nil)
+        expr.or_error(msg || "it should be an expression")
+      end
+
+      # +reverse_message_sending+ matches reverse message sending.
+      rule(:reverse_message_sending) {
+        expr_prepositional_messages.as(:reverse_messages) >> pad? >> expr.as(:receiver)
+      }
+
+      # +expr_messages+ matches prepositional messages.
+      rule(:expr_prepositional_messages) { (pad? >> reverse_message).repeat(1) }
+
+      # +expr_messages+ matches postpositional messages.
+      rule(:expr_postpositional_messages) {
+        (pad? >> (index | message | parameter_set.as(:postpositional_parameter_set))).repeat(1)
+      }
+
+      # +expr_element+ matches simple expressions.
+      #
+      # @example
+      #   true
+      # @example
+      #   (1 + 1)
+      # @example
+      #   ("abc".index(1, 1))
+      rule(:expr_element) {
+        expr_basic_element.as(:receiver) >> expr_postpositional_messages.as(:messages) |
+        expr_basic_element
+      }
+
+      # +expr_element+ matches simple expressions.
+      #
+      # @example
+      #   true
+      # @example
+      #   (1 + 1)
+      # @example
+      #   ("abc".index(1, 1))
+      rule(:expr_basic_element) { atomic_expr | enclosed_expr }
+
+      # +atomic_expr+ matches atomic expressions.
+      rule(:atomic_expr) {
+        boolean | float | integer | string | ticket_expr | data_expr | package_expr | rule_expr |
+        feature | parameter_set | variable
+      }
+
+      # +enlosed_expr+ matches expressions enclosed by parens.
+      rule(:enclosed_expr) { lparen >> expr >> rparen! }
+
+      # +expr_operator+ matches expression operators.
+      #
+      # @example
+      #   :=, ==, !=, >=, >, <=, <, &&, ||, +, -, *, /, %, or, and
+      # rule(:expr_operator) {
+      #   equals >> equals >> greater_than |
+      #   equals >> equals |
+      #   exclamation >> equals |
+      #   less_than >> equals |
+      #   less_than |
+      #   greater_than >> greater_than >> greater_than |
+      #   greater_than >> equals |
+      #   greater_than |
+      #   ampersand >> ampersand |
+      #   vbar >> vbar |
+      #   plus |
+      #   minus |
+      #   asterisk |
+      #   slash |
+      #   percent |
+      #   keyword_or |
+      #   keyword_and |
+      #   atmark |
+      #   vbar
+      # }
+
+      rule(:expr_operator_1) {
+        plus |
+        minus |
+        asterisk |
+        slash |
+        percent |
+        (atmark >> dot).absent? >> atmark |
+        (vbar >> vbar).absent? >> vbar |
+        keyword_or |
+        keyword_and |
+        (colon >> colon | colon >> equals).absent? >> colon
+      }
+
+      rule(:expr_operator_2) {
+        equals >> equals >> equals |
+        exclamation >> equals >> equals |
+        equals >> equals >> asterisk |
+        equals >> equals >> greater_than |
+        equals >> equals |
+        exclamation >> equals |
+        (less_than >> minus).absent? >> less_than >> equals |
+        (less_than >> minus).absent? >> less_than |
+        greater_than >> greater_than >> greater_than |
+        greater_than >> equals |
+        greater_than |
+        (ampersand >> ampersand).absent? >> ampersand |
+        ampersand >> ampersand |
+        vbar >> vbar
+      }
+
+      # +expr_operator_application+ matches operator application.
+      #
+      # @example
+      #   X + X
+      rule(:expr_operator_application) {
+        expr_operator_application_2 |
+        expr_operator_application_1
+      }
+
+      rule(:expr_operator_application_1) {
+        ( expr_element.as(:left) >>
+          padded?(expr_operator_1.as(:operator)) >>
+          ((expr_operator_application_1 | expr_element).as(:right) |
+            syntax_error("right hand side of the operator application should be expr", [:expr]))
+        ).as(:expr_operator_application)
+      }
+
+      rule(:expr_operator_application_2) {
+        ((expr_operator_application_1 | expr_element).as(:left) >>
+          padded?(expr_operator_2.as(:operator)) >>
+          expr!("right hand side of the operator application should be expr").as(:right)
+        ).as(:expr_operator_application)
+      }
+
+      # +message+ matches message sending.
+      #
+      # @example message with no arguments
+      #   .as_string
+      # @example message with arguments
+      #   .params("-w")
+      rule(:message) {
+        small_message
+      }
+
+      #rule(:capital_message) {
+      #  (padded?(dot) >> capital_identifier.as(:message_name) >> message_parameters.maybe).as(:message)
+      #}
+
+      rule(:small_message) {
+        (padded?(dot) >> small_identifier.as(:message_name) >> message_parameters.maybe).as(:message)
+      }
+
+      # +message+ matches reverse message sending.
+      #
+      # @example message with no arguments
+      #   as_string ::
+      # @example message with arguments
+      #   params("-w") ::
+      rule(:reverse_message) {
+        (identifier.as(:message_name) >> message_parameters.maybe >> pad? >> reverse_message_operator).as(:message)
+      }
+
+      # +message_parameters+ matches message parameters.
+      #
+      # @example
+      #   ("-w")
+      # @example
+      #   (true, false)
+      rule(:message_parameters) {
+        lparen >> padded?(message_parameters_elements.maybe.as(:message_parameters)) >> rparen!
+      }
+
+      # +message_parameters_elements+ matches message parameters.
+      #
+      # @example
+      #   true
+      # @example
+      #   true, true, true
+      rule(:message_parameters_elements) { expr >> (padded?(comma) >> expr!).repeat }
+
+      #
+      # INDEX
+      #
+
+      # +index+ matches object index.
+      #
+      # @example
+      #   [1]
+      #   [1,1]
+      #   [1,2,3]
+      #   ["a"]
+      #   ["a", "b", "c"]
+      # @example
+      #   [Var: 1]
+      rule(:index) { lsbracket >> padded?(index_arguments!.as(:index)) >> rsbracket! }
+
+      # +index_arguments+ matches arguments of object index.
+      #
+      # @example
+      #   1
+      #   1, 1
+      #   1, 2, 3
+      rule(:index_arguments) { expr.repeat(1,1) >> (padded?(comma) >> expr!).repeat }
+      rule(:index_arguments!) { index_arguments.or_error("it should be index arguments") }
+    end
+  end
+end

data/lib/pione/{transformer → lang}/expr-transformer.rb

@@ -1,54 +1,66 @@
 module Pione
-  module Transformer
+  module Lang
     # ExprTransformer is a transformer for syntax tree of expressions.
     module ExprTransformer
-      include TransformerModule
+      include Util::ParsletTransformerModule
 
-      # Transform +:expr_operator_application+ as Model::Message
+      # Transform +expr_operator_application+ into +Lang::Message+.
       rule(:expr_operator_application =>
            { :left => simple(:left),
              :operator => simple(:operator),
              :right => simple(:right) }) {
-        Model::Message.new(operator.to_s, left, right)
+        Lang::Message.new(operator.to_s, left, [right]).tap do |msg|
+          line, col = left.line_and_column
+          msg.set_source_position(package_name, filename, line, col)
+        end
       }
 
       # Extract the content of +:expr+.
       rule(:expr => simple(:obj)) { obj }
 
-      # Transform receiver and messages as Model::Message.
+      # Transform receiver and messages as Lang::Message.
       rule({ :receiver => simple(:receiver),
              :messages => sequence(:messages) }) {
         messages.inject(receiver) do |rec, msg|
-          Model::Message.new(msg.name, rec, *msg.parameters)
+          Lang::Message.new(msg.name.to_s, rec, msg.parameters).tap do |x|
+            line, col = receiver.line_and_column
+            x.set_source_position(package_name, filename, line, col)
+          end
         end
       }
 
-      # Transform receiver and reverse message as Model::Message.
+      # Transform receiver and reverse message as Lang::Message.
       rule({ :receiver => simple(:receiver),
              :reverse_messages => sequence(:messages) }) {
         messages.reverse.inject(receiver) do |obj, msg|
-          Model::Message.new(msg.name, obj, *msg.parameters)
+          Lang::Message.new(msg.name.to_s, obj, msg.parameters).tap do |x|
+            line, col = msg.line_and_column
+            x.set_source_position(package_name, filename, line, col)
+          end
         end
       }
 
-      # Transform receiver and indexes as Model::Message.
+      # Transform receiver and indexes as Lang::Message.
       rule({ :receiver => simple(:receiver),
              :indexes => sequence(:indexes) }) {
         indexes.inject(receiver) do |rec, msg|
-          Model::Message.new("[]", rec, *msg.parameters)
+          Lang::Message.new("[]", rec, msg.parameters).tap do |x|
+            line, col = msg.line_and_column
+            x.set_source_position(package_name, filename, line, col)
+          end
         end
       }
 
       # Transform +:message+ with no parameters as OpenStruct.
       rule(:message => {:message_name => simple(:name)}) {
-        OpenStruct.new(name: name)
+        OpenStruct.new(name: name, parameters: [])
       }
 
       # Transform +:message+ with no parameters as OpenStruct.
       rule(:message =>
         { :message_name => simple(:name),
           :message_parameters => nil }) {
-        OpenStruct.new(name: name)
+        OpenStruct.new(name: name, parameters: [])
       }
 
       # Transform +:message+ with parameters as OpenStruct.
@@ -62,18 +74,19 @@ module Pione
       rule(:message =>
         { :message_name => simple(:name),
           :message_parameters => simple(:arg) }) {
-        OpenStruct.new(name: name, parameters: arg)
+        OpenStruct.new(name: name, parameters: [arg])
       }
 
       # data null
       rule(:data_null => simple(:obj)) {
-        Model::DataExprNull.instance.to_seq
+        Lang::DataExprSequence.of(Lang::DataExprNull.instance)
       }
 
-      # Extract the content of +:rule_expr+.
+
+      # Extract the content of +rule_expr+.
       rule(:rule_expr => simple(:rule)) { rule }
 
-      # Extract the content of +:rule_expr+ and set the package.
+      # Extract the content of +rule_expr+ and set the package.
       rule(:rule_expr => {
           :package => simple(:package),
           :expr => simple(:expr)
@@ -81,39 +94,14 @@ module Pione
         expr.set_package_expr(package)
       }
 
-      # Transform +:parameters+ as emtpy parameters.
-      rule(:parameters => nil) { Parameters.new({}) }
-
-      # Transform +:parameters+ as emtpy parameters.
-      rule(:parameters => simple(:elt)) {
-        Parameters.new({elt.key => elt.value})
-      }
-
-      # Transform +:parameters+ as parameters.
-      rule(:parameters => sequence(:list)) {
-        elts = Hash[*list.map{|elt| [elt.key, elt.value]}.flatten(1)]
-        Parameters.new(elts)
-      }
-
-      # Transform +:parameters_element+ as key and value pair.
-      rule(:parameters_element => {
-          :key => simple(:key),
-          :value => simple(:value)
-        }) {
-        var = Variable.new(key.str).tap do |x|
-          x.set_line_and_column(key.line_and_column)
-        end
-        OpenStruct.new(key: var, value: value)
-      }
-
       # Transform +:index+ as name and parameters structure.
       rule(:index => sequence(:args)) {
         OpenStruct.new(name: "[]", parameters: args)
       }
 
-      # Transform +:postpositional_parameters+ as parameters structure.
-      rule(:postpositional_parameters => simple(:parameters)) {
-        OpenStruct.new(name: "params", parameters: parameters)
+      # Transform +postpositional_parameter_set+ as parameters structure.
+      rule(:postpositional_parameter_set => simple(:parameter_set)) {
+        OpenStruct.new(name: "param", parameters: [parameter_set])
       }
     end
   end

data/lib/pione/lang/expr.rb

@@ -0,0 +1,70 @@
+module Pione
+  module Lang
+    # Expr is a base class for all PIONE expressions.
+    class Expr < StructX
+      include Util::Positionable
+      immutable true
+
+      class << self
+        attr_reader :pione_type
+
+        # Set pione model type of the model.
+        def pione_type(type=nil)
+          if type
+            @pione_type = type
+            Type.table[type.name][:sequence_class] = self
+          else
+            @pione_type
+          end
+        end
+
+        def inherited(subclass)
+          if @pione_type
+            subclass.pione_type(@pione_type)
+          end
+        end
+      end
+
+      forward :class, :pione_type
+
+      def eval(env)
+        return self
+      end
+
+      def eval!(env)
+        return self
+      end
+
+      # Convert to text string.
+      def textize
+        args = to_h.map do |key, val|
+          "%s: %s" % [key, val.kind_of?(Piece) ? val.textize : val.to_s]
+        end.join(", ")
+        "#%s{%s}" % [piece_classes.first.piece_type_name, args]
+      end
+
+      def to_s
+        textize
+      end
+    end
+
+    module Callable
+      # Call the pione method.
+      def call_pione_method(env, name, args)
+        # check arguments
+        raise ArgumentError.new(args) unless args.is_a?(Array)
+
+        if pione_method = pione_type.find_method(env, name, self, args)
+          # evaluate arguments if the method type is immediate
+          if pione_method.method_type == :immediate
+            args = args.map {|arg| arg.eval(env)}
+          end
+          # call it
+          pione_method.call(env, self, args)
+        else
+          raise MethodNotFound.new(name, self, args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,425 @@
+# -*- coding: utf-8 -*-
+
+module Pione
+  module Lang
+    class FeaturePiece < Piece
+      piece_type_name "Feature"
+      member :name
+
+      class << self
+        def feature_type(val = nil)
+          val ? @feature_type = val : @feature_type
+        end
+      end
+
+      forward :class, :feature_type
+    end
+
+    #
+    # special features
+    #
+
+    # SpecialFeature is a class for empty feature and boundless feature.
+    class SpecialFeature < FeaturePiece
+      class << self
+        def symbol(sym=nil)
+          sym ? @symbol = sym : sym
+        end
+      end
+
+      feature_type :both
+      forward :class, :symbol
+
+      def textize
+        symbol
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) and symbol == other.symbol
+       end
+      alias :eql? :==
+    end
+
+    # EmptyFeature is a special feature that represents there are no features.
+    # This means workers have no specific abilities in provider expression and
+    # tasks have no specific requests in request expression.
+    class EmptyFeature < SpecialFeature
+      symbol "*"
+    end
+
+    # AlmightyFeature is a special feature that represents whole features. This
+    # means that workers have almighty ability in provider expression and tasks
+    # have almighty ability request in request expression.
+    class AlmightyFeature < SpecialFeature
+      symbol "**"
+    end
+
+    #
+    # simple features
+    #
+
+    # SimpleFeature is a feature that consists prefix and name.
+    class SimpleFeature < FeaturePiece
+      class << self
+        # Return the operator symbol.
+        def prefix(val = nil)
+          val ? @prefix = val : @prefix
+        end
+      end
+
+      forward :class, :prefix
+
+      def textize
+        "%s%s" % [prefix, name]
+      end
+    end
+
+    # PossibleFeature is a provider feature that represents workers' possible
+    # ability.
+    class PossibleFeature < SimpleFeature
+      prefix "^"
+      feature_type :provider
+    end
+
+    # RestrictiveFeature is a provider feature that represents workers'
+    # restrictive ability.
+    class RestrictiveFeature < SimpleFeature
+      prefix "!"
+      feature_type :provider
+    end
+
+    # RequisiteFeature is a request feature that represents tasks' requisite
+    # of ability.
+    class RequisiteFeature < SimpleFeature
+      prefix "+"
+      feature_type :request
+    end
+
+    # BlockingFeature is a request feature that represents tasks' nature
+    # of blocking workers have the feature name execute the task.
+    class BlockingFeature < SimpleFeature
+      prefix "-"
+      feature_type :request
+    end
+
+    # PreferredFeature is a request feature that represents the task is
+    # processed by workers prior to other tasks.
+    class PreferredFeature < SimpleFeature
+      prefix "?"
+      feature_type :request
+    end
+
+    #
+    # complex feature
+    #
+
+    # ComplexFeatureMethod
+    module ComplexFeatureMethod
+      def feature_type
+        pieces.inject(:both) {|t, piece| t == :both ? piece.feature_type : t}
+      end
+    end
+
+    #
+    # compound feature
+    #
+
+    # CompoundFeature represents conjunction of feature pieces.
+    class CompoundFeature < FeaturePiece
+      class << self
+        def build(piece1, piece2)
+          # unify features if they are same
+          return piece1 if piece1 == piece2
+
+          # append if either feature is compound
+          return piece1.add(piece2) if piece1.is_a?(CompoundFeature)
+          return piece2.add(piece1) if piece2.is_a?(CompoundFeature)
+
+          # create new compound feature
+          new(pieces: Set.new([piece1, piece2]))
+        end
+      end
+
+      member :pieces, :default => Set.new
+
+      def add(piece)
+        if piece.is_a?(CompoundFeature)
+          set(pieces: pieces + piece.pieces)
+        else
+          set(pieces: pieces + Set.new([piece]))
+        end
+      end
+    end
+
+    #
+    # sequence
+    #
+
+    # FeatureSequence represents disjunction of feature pieces.
+    class FeatureSequence < OrdinalSequence
+      pione_type TypeFeature
+      piece_class EmptyFeature
+      piece_class AlmightyFeature
+      piece_class PossibleFeature
+      piece_class RestrictiveFeature
+      piece_class RequisiteFeature
+      piece_class BlockingFeature
+      piece_class PreferredFeature
+
+      class << self
+        def of(*args)
+          args.each {|arg| raise ArgumentError(arg) unless arg.is_a?(FeaturePiece)}
+          args.size > 0 ? new(args) : new([EmptyFeature.new])
+        end
+      end
+
+      include ComplexFeatureMethod
+
+      def concat(other)
+        acceptable = feature_type.nil? or feature_type == :both
+        other_acceptable = other.feature_type.nil? or other.feature_type == :both
+        if feature_type == other.feature_type or acceptable or other_acceptable
+          super(other)
+        else
+          raise SequenceAttributeError.new(other)
+        end
+      end
+
+      # Return true if the feature accepts other feature.
+      def match(other)
+        provider_pieces = pieces
+        request_pieces = other.pieces
+
+        if feature_type == :request or other.feature_type == :provider
+          provider_pieces = other.pieces
+          request_pieces = pieces
+        end
+
+        provider_pieces = [EmptyFeature.new] if provider_pieces.empty?
+        request_pieces = [EmptyFeature.new] if request_pieces.empty?
+
+        provider_pieces.any? do |provider_piece|
+          request_pieces.any? do |request_piece|
+            _match(provider_piece, request_piece)
+          end
+        end
+      end
+
+      # This alias is for RINDA's template matcher.
+      alias :"===" :match
+
+      def _match(provider_piece, request_piece)
+        # apply eliminations
+        _provider_piece, _request_piece = Eliminator.new(provider_piece, request_piece).eliminate
+
+        # features are matched if both pieces are empty
+        return true if _provider_piece.is_a?(EmptyFeature) and _request_piece.is_a?(EmptyFeature)
+
+        # feature are unmatched if peaces are not elminated
+        return false if provider_piece == _provider_piece and request_piece == _request_piece
+
+        # next
+        return _match(_provider_piece, _request_piece)
+      end
+    end
+
+    #
+    # feature operations
+    #
+
+    class Eliminator
+      OPERATIONS = [
+        :eliminate_requisite_feature,
+        :eliminate_requisite_feature_by_almighty_feature,
+        :eliminate_blocking_feature,
+        :eliminate_preferred_feature,
+        :eliminate_possible_feature,
+        :eliminate_almighty_feature
+      ]
+
+      def initialize(provider_piece, request_piece)
+        @provider_piece = provider_piece
+        @request_piece = request_piece
+      end
+
+      def eliminate
+        OPERATIONS.inject([@provider_piece, @request_piece]) do |(ppiece, rpiece), elim|
+          result, _ppiece, _rpiece = __send__(elim, ppiece, rpiece)
+          result ? [_ppiece, _rpiece] : [ppiece, rpiece]
+        end
+      end
+
+      # Eliminate a requisite feature from the request pieces. This is for the
+      # case that requisite feature is satisfied by possible feature or
+      # restrictive feature.
+      #
+      # Rule:
+      # - (^X & Γ <- +X & Δ) -> Γ & Δ
+      # - (!X & Γ <- +X & Δ) -> Γ & Δ
+      def eliminate_requisite_feature(provider_piece, request_piece)
+        ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
+        rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]
+
+        rpieces.each do |rpiece|
+          # requisite feature is target
+          next unless rpiece.kind_of?(RequisiteFeature)
+
+          ppieces.each do |ppiece|
+            next unless ppiece.kind_of?(PossibleFeature) || ppiece.kind_of?(RestrictiveFeature)
+            next unless ppiece.name == rpiece.name
+
+            # eliminate only if Γ dosen't include same symbol feature
+            next if ppieces.any? {|piece| ppiece.name == piece.name && not(piece.kind_of?(ppiece.class))}
+
+            # eliminate only if Δ dosen't include same symbol feature
+            next if rpieces.any? {|piece| rpiece.name == piece.name && not(piece.kind_of?(rpiece.class))}
+
+            # eliminate
+            return true, rebuild_feature(ppieces - [ppiece]), rebuild_feature(rpieces - [rpiece])
+          end
+        end
+
+        return false
+      end
+
+      # Eliminate request features by almighty feature.
+      #
+      # Rule:
+      # - (** <- +X & Δ) -> (** <- Δ)
+      def eliminate_requisite_feature_by_almighty_feature(provider_piece, request_piece)
+        ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
+        rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]
+
+        rpieces.each do |rpiece|
+          # requisite feature is target
+          next unless rpiece.kind_of?(RequisiteFeature)
+
+          ppieces.each do |ppiece|
+            next unless ppiece.kind_of?(AlmightyFeature)
+
+            # eliminate
+            return true, provider_piece, rebuild_feature(rpieces - [rpiece])
+          end
+        end
+
+        return false
+      end
+
+      # Elimiate a blocking feature.
+      #
+      # Rule:
+      # - (Γ <- -X & Δ) -> Γ & Δ
+      def eliminate_blocking_feature(provider_piece, request_piece)
+        ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
+        rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]
+
+        rpieces.each do |rpiece|
+          next unless rpiece.kind_of?(BlockingFeature)
+
+          # eliminate only if Γ dosen't include almighty features
+          next if ppieces.any? {|ppiece| ppiece.is_a?(AlmightyFeature)}
+
+          # eliminate only if Γ dosen't include same name features
+          next if ppieces.any? {|ppiece| ppiece.name == rpiece.name && not(ppiece.kind_of?(rpiece.class))}
+
+          # eliminate only if Δ dosen't include same name features
+          next if rpieces.any? {|piece| rpiece.name == piece.name && not(piece.kind_of?(rpiece.class))}
+
+          # eliminate
+          return true, provider_piece, rebuild_feature(rpieces - [rpiece])
+        end
+
+        return false
+      end
+
+      # Eliminate a preferred feature.
+      #
+      # Rule:
+      # - (Γ <- ?X & Δ) -> (Γ <- Δ)
+      def eliminate_preferred_feature(provider_piece, request_piece)
+        ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
+        rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]
+
+        if rpieces.any? {|e| e.kind_of?(PreferredFeature)}
+          _request = rebuild_feature(rpieces.reject {|rpiece| rpiece.kind_of?(PreferredFeature)})
+          return true, provider_piece, _request
+        end
+
+        return false
+      end
+
+      # Eliminate a possible feature.
+      #
+      # Rule:
+      # - (^X & Γ <- Δ) -> (Γ <- Δ)
+      def eliminate_possible_feature(provider_piece, request_piece)
+        ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
+        rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]
+
+        ppieces.each do |ppiece|
+          next unless ppiece.kind_of?(PossibleFeature)
+
+          # eliminate only if Γ dosen't include same symbol feature
+          next if ppieces.any? {|piece| ppiece.name == piece.name && not(piece.kind_of?(ppiece.class))}
+
+          # eliminate only if Δ dosen't include same symbol feature
+          next if rpieces.any? {|rpiece| ppiece.name == rpiece.name && not(rpiece.kind_of?(ppiece.class))}
+
+          # eliminate
+          return true, rebuild_feature(ppieces - [ppiece]), request_piece
+        end
+
+        return false
+      end
+
+      # Eliminate almighty feature.
+      #
+      # Rule:
+      # - (** <- *) -> (* <- *)
+      # - (** <- **) -> (* <- *)
+      def eliminate_almighty_feature(provider_piece, request_piece)
+        pclass = provider_piece.class
+        rclass = request_piece.class
+
+        if pclass == AlmightyFeature and (rclass == AlmightyFeature or rclass == EmptyFeature)
+          return true, EmptyFeature.new, EmptyFeature.new
+        end
+
+        return false
+      end
+
+      private
+
+      def rebuild_feature(pieces)
+        case pieces.size
+        when 0
+          EmptyFeature.new
+        when 1
+          pieces.first
+        else
+          CompoundFeature.new(pieces: pieces)
+        end
+      end
+    end
+
+    TypeFeature.instance_eval do
+      # Build a compound feature.
+      define_pione_method("&", [TypeFeature], TypeFeature) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          CompoundFeature.build(rec_piece, other_piece)
+        end
+      end
+
+      # Return true if the request feature accepts the provider feature.
+      define_pione_method("match", [TypeFeature], TypeBoolean) do |env, rec, other|
+        raise ArgumentError.new(rec) if rec.feature_type == :request
+        BooleanSequence.of(rec.match(other))
+      end
+
+      # Return string format of the feature.
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        PioneString.of(rec.textize)
+      end
+    end
+  end
+end