alf-core 0.13.0

data/lib/alf-types/alf/types.rb

@@ -0,0 +1,51 @@
+module Alf
+  #
+  # This module defines a namespace for useful datatypes as well as a few typing tools.
+  # Defined types are automatically defined as constants on the Alf module itself.
+  #
+  module Types
+
+    # Returns the (least) common super type of c1 and c2.
+    #
+    # The least common super type is defined as the lowest ancestor shared
+    # between c1 and c2.
+    #
+    # Examples:
+    #
+    #     Types.common_super_type(String, String)  # => String
+    #     Types.common_super_type(Integer, Float)  # => Numeric
+    #     Types.common_super_type(Integer, String) # => Object
+    #
+    # @param [Class] c1 a data type, respresented by a ruby class
+    # @param [Class] c2 a data type, respresented by a ruby class
+    # @return [Class] the least common super type of c1 and c2
+    def common_super_type(c1, c2)
+      if x = (c1 <=> c2)
+        x >= 0 ? c1 : c2
+      else
+        ancestors = [c1, c2].map{|c| c.ancestors.select{|a| a.is_a?(Class)} }
+        (ancestors[0] & ancestors[1]).first
+      end
+    end
+    module_function :common_super_type
+
+    require_relative 'types/boolean'
+    require_relative 'types/size'
+    require_relative 'types/attr_name'
+    require_relative 'types/attr_list'
+    require_relative 'types/heading'
+    require_relative 'types/ordering'
+    require_relative 'types/renaming'
+    require_relative 'types/summarization'
+    require_relative 'types/tuple_expression'
+    require_relative 'types/tuple_computation'
+    require_relative 'types/keys'
+    require_relative 'types/type_check'
+
+    # Install all types on Alf now
+    constants.each do |s|
+      Alf.const_set(s, const_get(s))
+    end
+
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/attr_list.rb

@@ -0,0 +1,154 @@
+module Alf
+  module Types
+    #
+    # An attribute list is an ordered collection of attribute names (see AttrName).
+    #
+    # Example:
+    #
+    #     list = AttrList[:name, :city]
+    #
+    class AttrList
+      extend Domain::Reuse.new(Array)
+      include Support::OrderedSet
+
+      coercions do |c|
+        c.delegate :to_attr_list
+        c.coercion(Hash)  {|v,_| c.coerce(v.keys) }
+        c.coercion(Array) {|v,_| AttrList.new(v.map{|a| AttrName.coerce(a) })}
+        c.coercion(Symbol){|v,_| AttrList.new([v]) }
+      end
+      def self.[](*args); coerce(args); end
+
+      # Splits a tuple in two parts according `allbut`.
+      #
+      # Example:
+      #   list = AttrList.new([:name])
+      #   tuple = {:name => "Jones", :city => "London"}
+      #
+      #   list.split_tuple(tuple)
+      #   # => [{:name => "Jones"}, {:city => "London"}]
+      #
+      #   list.split_tuple(tuple, true)
+      #   # => [{:city => "London"}, {:name => "Jones"}]
+      #
+      # @param [Hash] tuple a tuple to split
+      # @param [Boolean] allbut unknown attributes as first result?
+      # @return [Array<Hash>] an array containing two tuples, according to known
+      #         attributes and `allbut`
+      def split_tuple(tuple, allbut = false)
+        projection, rest = {}, tuple.to_hash.dup
+        each do |a|
+          projection[a] = tuple[a] if tuple.has_key?(a)
+          rest.delete(a)
+        end
+        allbut ? [rest, projection] : [projection, rest]
+      end
+
+      # Projects `tuple` on known (or unknown) attributes.
+      #
+      # Example:
+      #   list = AttrList.new([:name])
+      #   tuple = {:name => "Jones", :city => "London"}
+      #
+      #   list.project_tuple(tuple)
+      #   # => {:name => "Jones"}
+      #
+      #   list.project_tuple(tuple, true)
+      #   # => {:city => "London"}
+      #
+      # @param [Hash] tuple a tuple to project
+      # @param [Boolean] allbut projection?
+      # @return Hash the projected tuple
+      def project_tuple(tuple, allbut = false)
+        split_tuple(tuple, allbut).first
+      end
+
+      # Projects this attribute list on a subset of attributes `attrs`.
+      #
+      # @param [AttrList] attrs a subset of these attributes
+      # @param [Boolean] allbut projection?
+      # @return [AttrList] the projection as an attribute list
+      def project(attrs, allbut = false)
+        allbut ? self - attrs : self & attrs
+      end
+
+      # Shortcut for project(attrs, true)
+      def allbut(attrs)
+        project(attrs, true)
+      end
+
+      # Compares this attribute list with `other` on a set basis.
+      #
+      # @param [AttrList] other another attribute list
+      # @return [Integer] 0 if same set of attribute names, -1 if self is a subset of
+      # other, 1 if a superset, nil otherwise.
+      def <=>(other)
+        return nil unless other.is_a?(AttrList)
+        s1, s2 = to_set, other.to_set
+        if s1==s2              then 0
+        elsif s1.subset?(s2)   then -1
+        elsif s1.superset?(s2) then 1
+        else nil
+        end
+      end
+      alias_method :set_compare, :<=>
+
+      # Returns true if this attribute list captures the same set of attribute names than
+      # `other`.
+      def sameset?(other)
+        c = set_compare(other)
+        c and (c==0)
+      end
+
+      # Returns true if self is a (proper) superset of `other`
+      def superset?(other, proper = false)
+        c = set_compare(other)
+        c and (c >= (proper ? 1 : 0))
+      end
+
+      # Returns true if self is a (proper) subset of `other`
+      def subset?(other, proper = false)
+        c = set_compare(other)
+        c and (c <= (proper ? -1 : 0))
+      end
+
+      # Returns true if self intersects another attribute list
+      def intersect?(other)
+        !((self & other).empty?) || (empty? && other.empty?)
+      end
+
+      # Converts to an attribute list.
+      #
+      # @return [AttrList] return self
+      def to_attr_list
+        self
+      end
+
+      # Converts this attribute list to an ordering.
+      #
+      # @param [Symbol] :asc or :desc for ordering direction
+      # @return [Ordering] an ordering instance
+      def to_ordering(order = :asc)
+        Ordering.new elements.map{|arg| [arg, order]}
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this attribute list
+      def to_lispy
+        Support.to_ruby_literal(to_a)
+      end
+
+      # Returns a ruby literal for this attribute list.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        "Alf::AttrList#{Support.to_ruby_literal(to_a)}"
+      end
+      alias :to_s :to_ruby_literal
+      alias :inspect :to_ruby_literal
+
+      EMPTY = AttrList.new([])
+    end # class AttrList
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/attr_name.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Types
+    #
+    # Attribute name.
+    #
+    # Attribute names are ruby symbols that match the following regular expression:
+    #
+    #     /^[a-zA-Z0-9_]+[?!]?$/
+    #
+    # Example:
+    #
+    #     AttrName.coerce("city")
+    #     # => :city
+    #
+    class AttrName < Symbol
+      extend Domain::SByC.new(Symbol){|s| s.to_s =~ /^[a-zA-Z0-9_]+[?!]?$/}
+
+      coercions do |c|
+        c.delegate(:to_sym){|v,_| new(v.to_sym) }
+      end
+
+    end # class AttrName
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/boolean.rb

@@ -0,0 +1,8 @@
+module Alf
+  module Types
+
+    # Defines the Boolean type which is missing to ruby.
+    Boolean = Myrrha::Boolean
+
+  end
+end

data/lib/alf-types/alf/types/heading.rb

@@ -0,0 +1,189 @@
+module Alf
+  module Types
+    #
+    # Defines a Heading, that is, a set of attribute (name,domain) pairs.
+    #
+    class Heading
+      include Comparable
+      extend Domain::Reuse.new(Hash)
+
+      coercions do |c|
+        c.delegate :to_heading
+        c.coercion(Array){|arg,_|
+          Heading.new Hash[arg.each_slice(2).map{|k,v|
+            [ AttrName.coerce(k), Support.coerce(v, Module) ]
+          }]
+        }
+        c.coercion(Hash){|arg,_|
+          Heading.new Hash[arg.map{|k,v|
+            [ AttrName.coerce(k), Support.coerce(v, Module) ]
+          }]
+        }
+      end
+
+      def self.infer(arg)
+        return arg.to_heading if arg.respond_to?(:to_heading)
+        return arg.heading    if arg.respond_to?(:heading)
+        arg = [ arg ] if TupleLike===arg
+        Heading.new(Engine::InferHeading.new(arg).first)
+      end
+
+      reuse :each, :[], :size, :to_hash, :map
+
+      alias_method :attributes, :reused_instance
+      alias_method :cardinality, :size
+      alias_method :count, :size
+      alias_method :to_h, :to_hash
+
+      # Apply coercions to `arg`.
+      #
+      # If `arg` is a Hash or a Tuple, returns a Hash with coercion applied to known
+      # attributes. Otherwise, the method supposes that `arg` responds to `map` and
+      # recursively collects coercions on its members.
+      #
+      # This methods have no effect on missing attributes (with respect to heading)
+      # or unknown ones. In other words, it does not apply strong typing constraints
+      # with respect to the Heading.
+      #
+      # @param [Hash|Tuple|Enumerable] arg an object for which coercions must be applied.
+      # @return [Hash|Array[Hash]] the result of applied coercions.
+      def coerce(arg)
+        case arg
+        when TupleLike
+          arg.to_hash.each_with_object({}) do |(k,v),h|
+            k = k.to_sym
+            h[k] = attributes.has_key?(k) ? Support.coerce(v, self[k]) : v
+          end
+        else
+          arg.map{|t| coerce(t) }
+        end
+      end
+
+      # Computes the intersection of this heading with another one.
+      #
+      # @param [Heading] other another heading
+      # @return [Heading] the intersection of this heading with `other`
+      def intersection(other)
+        attrs = (to_attr_list & other.to_attr_list).to_a
+        Heading.new Hash[attrs.map{|name|
+          [name, Types.common_super_type(self[name], other[name])]
+        }]
+      end
+      alias_method :&, :intersection
+
+      # Computes the union of this heading with `other`.
+      #
+      # When self and other have no common attribute names, compute the classical set
+      # union on pairs. Otherwise, the type of a common attribute is returned as the
+      # common super type (see `Types.common_super_type`).
+      #
+      # @param [Heading] other another heading
+      # @return [Heading] the union of this heading with `other`
+      def union(other)
+        Heading.new attributes.merge(other.attributes){|k,t1,t2|
+          Types.common_super_type(t1, t2)
+        }
+      end
+      alias_method :+, :union
+      alias_method :join, :union
+
+      # Splits this heading according to an attribute list
+      #
+      # @return [Array[Heading]] an array of two headings.
+      def split(names, allbut=false)
+        l, r = AttrList.coerce(names).split_tuple(attributes, allbut)
+        [Heading.new(l), Heading.new(r)]
+      end
+
+      # Projects this heading on specified names.
+      #
+      # @param [AttrList] names an enumerable of attribute names.
+      # @param [Boolean] allbut apply a allbut projection?
+      def project(names, allbut = false)
+        Heading[AttrList.coerce(names).project_tuple(attributes, allbut)]
+      end
+
+      # Projects this heading on all but specified names.
+      #
+      # @param [AttrList] names an enumerable of attribute names.
+      def allbut(names)
+        project(names, true)
+      end
+
+      # Computes the merge of this heading with `other`.
+      #
+      # When self and other have no common attribute names, compute the
+      # classical set union on pairs. Otherwise, the type of a common attribute
+      # is returned as the one of `other`
+      #
+      # @param [Heading] other another heading
+      # @return [Heading] the merge of this heading with `other`
+      def merge(other)
+        Heading.new attributes.merge(Heading[other].attributes)
+      end
+
+      # Renames according to a Renaming instance.
+      #
+      # @param [Renaming] a renaming instance
+      # @return [Heading] a renamed heading
+      def rename(renaming)
+        Heading.new Renaming.coerce(renaming).rename_tuple(attributes)
+      end
+
+      # Compares this heading with another one
+      #
+      # @return [Fixnum] -1 if a self is a sub heading, 0 if equal, 1 if a super heading,
+      #                  nil if not comparable.
+      def <=>(other)
+        return nil unless other.is_a?(Heading) && to_attr_list==other.to_attr_list
+        comparisons = attributes.keys.map{|k| self[k] <=> other[k] }.reject{|x| x == 0}.uniq
+        case comparisons.size
+        when 0 then 0
+        when 1 then comparisons.first
+        else nil
+        end
+      end
+
+      # Check conformance of a given tuple.
+      #
+      # @return [Boolean] true if the tuple conforms to this heading, false otherwise.
+      def ===(tuple)
+        TypeCheck.new(self, true)===tuple
+      end
+
+      # Return self
+      #
+      # @return [Heading] this heading
+      def to_heading
+        self
+      end
+
+      # Converts this heading to an attribute list.
+      #
+      # @return [AttrList] heading's attributes as an attribute list
+      def to_attr_list
+        AttrList.new attributes.keys
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this heading
+      def to_lispy
+        "{" << to_h.map{|k,v| "#{k}: #{Support.to_lispy(v)}" }.join(', ') << "}"
+      end
+
+      # Returns a Heading literal
+      #
+      # @return [String] a Heading literal
+      def to_ruby_literal
+        attributes.empty? ?
+          "Alf::Heading::EMPTY" :
+          "Alf::Heading[#{Support.to_ruby_literal(attributes)[1...-1]}]"
+      end
+      alias_method :to_s,    :to_ruby_literal
+      alias_method :inspect, :to_ruby_literal
+
+      EMPTY = Heading.new({})
+    end # class Heading
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/keys.rb

@@ -0,0 +1,39 @@
+module Alf
+  module Types
+    class Keys
+      extend Domain::Reuse.new(Array)
+      include Support::OrderedSet
+
+      coercions do |c|
+        c.coercion(Array){|v,_| Keys.new(v.map{|e| AttrList.coerce(e)}) }
+      end
+      def self.[](*args); coerce(args); end
+
+      def if_empty(keys = nil, &bl)
+        return self unless empty?
+        Keys.coerce(keys || bl.call)
+      end
+
+      def project(attributes, allbut = false)
+        map{|k| k.project(attributes, allbut) }
+      end
+
+      def rename(renaming)
+        renaming = Renaming.coerce(renaming)
+        map{|k| renaming.rename_attr_list(k) }
+      end
+
+      def compact
+        reject{|k| k.empty? }
+      end
+
+      def to_ruby_literal
+        "Alf::Keys[" << reused_instance.map{|k| Support.to_ruby_literal(k.to_a) }.join(',') << "]"
+      end
+      alias_method :to_s, :to_ruby_literal
+      alias_method :inspect, :to_ruby_literal
+
+      EMPTY = Keys.new([])
+    end # class Keys
+  end # module Types
+end # module Alf