axiom 0.1.0 → 0.1.1

data/lib/axiom/function/numeric/square_root.rb

@@ -24,6 +24,19 @@ module Axiom
           Math.sqrt(value)
         end
 
+        # Return the type returned from #call
+        #
+        # @example
+        #   type = Axiom::Function::Numeric::SquareRoot.type
+        #   # => Axiom::Types::Float
+        #
+        # @return [Class<Types::Float>]
+        #
+        # @api public
+        def self.type
+          Types::Float
+        end
+
         # Return the inverse function
         #
         # @example
@@ -38,17 +51,20 @@ module Axiom
 
         # Return the type returned from #call
         #
-        # @return [Class<Attribute::Float>]
+        # @example
+        #   type = square_root.type  # => Axiom::Types::Float
+        #
+        # @return [Class<Types::Float>]
         #
         # @api public
         def type
-          Attribute::Float
+          self.class.type
         end
 
         module Methods
           extend Aliasable
 
-          inheritable_alias(:sqrt => :square_root)
+          inheritable_alias(sqrt: :square_root)
 
           # Return a square root function
           #

data/lib/axiom/function/predicate.rb

@@ -14,11 +14,14 @@ module Axiom
 
       # Return the type returned from #call
       #
-      # @return [Class<Attribute::Boolean>]
+      # @example
+      #   type = Axiom::Function::Predicate.type  # => Axiom::Types::Boolean
+      #
+      # @return [Class<Types::Boolean>]
       #
       # @api public
-      def type
-        Attribute::Boolean
+      def self.type
+        Types::Boolean
       end
 
     end # class Predicate

data/lib/axiom/function/predicate/exclusion.rb

@@ -11,7 +11,7 @@ module Axiom
         # Test an enumerable to see if a value is excluded
         #
         # @example
-        #   Exclusion.call(1, [ 1, 2, 3 ])  # => false
+        #   Exclusion.call(1, [1, 2, 3])  # => false
         #
         # @param [Object] left
         #   the object to test for in the Enumerable
@@ -42,7 +42,7 @@ module Axiom
           # Compare the left to see if it is excluded from the right
           #
           # @example
-          #   exclusion = attribute.exclude([ 1, 2, 3 ])
+          #   exclusion = attribute.exclude([1, 2, 3])
           #
           # @param [Function] other
           #

data/lib/axiom/function/predicate/inclusion.rb

@@ -11,7 +11,7 @@ module Axiom
         # Test an enumerable to see if a value is included
         #
         # @example
-        #   Inclusion.call(1, [ 1, 2, 3 ])  # => true
+        #   Inclusion.call(1, [1, 2, 3])  # => true
         #
         # @param [Object] left
         #   the object to test for in the Enumerable
@@ -42,7 +42,7 @@ module Axiom
           # Compare the left to see if it is included in the right
           #
           # @example
-          #   inclusion = attribute.include([ 1, 2, 3 ])
+          #   inclusion = attribute.include([1, 2, 3])
           #
           # @param [Function] other
           #

data/lib/axiom/function/proposition.rb

@@ -12,6 +12,18 @@ module Axiom
               Function::Connective::Negation::Methods
       include Equalizer.new
 
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Function::Proposition.type  # => Axiom::Types::Boolean
+      #
+      # @return [Class<Types::Boolean>]
+      #
+      # @api public
+      def self.type
+        Types::Boolean
+      end
+
       # Instantiate a new Proposition
       #
       # @example using a true value
@@ -83,15 +95,6 @@ module Axiom
         self.class.inverse.instance
       end
 
-      # Return the type returned from #call
-      #
-      # @return [Class<Attribute::Boolean>]
-      #
-      # @api public
-      def type
-        Attribute::Boolean
-      end
-
     end # class Proposition
   end # module Algebra
 end # module Axiom

data/lib/axiom/function/string/length.rb

@@ -24,11 +24,14 @@ module Axiom
 
         # Return the type returned from #call
         #
-        # @return [Class<Attribute::Integer>]
+        # @example
+        #   type = Axiom::Function::String.type  # => Axiom::Types::Integer
+        #
+        # @return [Class<Types::Integer>]
         #
         # @api public
-        def type
-          Attribute::Integer
+        def self.type
+          Types::Integer
         end
 
         module Methods

data/lib/axiom/function/unary.rb

@@ -86,6 +86,18 @@ module Axiom
           end
         end
 
+        # Return the type returned from #call
+        #
+        # @example
+        #   type = unary.type  # => Axiom::Types::Numeric
+        #
+        # @return [Class<Types::Numeric>]
+        #
+        # @api public
+        def type
+          Attribute.infer_type(operand)
+        end
+
         # Mixin for invertable unary functions
         module Invertible
 

data/lib/axiom/relation.rb

@@ -4,7 +4,7 @@ module Axiom
 
   # Abstract base class for Relation operations
   class Relation
-    include Enumerable, Visitable
+    include Enumerable, Visitable, Adamantium::Flat
     include Equalizer.new(:header, :to_set)
 
     # The relation header
@@ -34,16 +34,16 @@ module Axiom
     # Instantiate a new Relation
     #
     # @example of a materialized Array based relation
-    #   array    = [ [ 1 ], [ 2 ], [ 3 ] ]
-    #   relation = Relation.new([ [ :id, Integer ] ], array)
+    #   array    = [[1], [2], [3]]
+    #   relation = Relation.new([[:id, Integer]], array)
     #
     # @example of a materialized Set based relation
-    #   set      = Set[ [ 1 ], [ 2 ], [ 3 ] ]
-    #   relation = Relation.new([ [ :id, Integer ] ], set)
+    #   set      = Set[[1], [2], [3]]
+    #   relation = Relation.new([[:id, Integer]], set)
     #
     # @example of a non-materialized Enumerator based relation
-    #   enumerator = [ [ 1 ], [ 2 ], [ 3 ] ].each
-    #   relation   = Relation.new([ [ :id, Integer ] ], enumerator)
+    #   enumerator = [[1], [2], [3]].each
+    #   relation   = Relation.new([[:id, Integer]], enumerator)
     #
     # @param [Array(Header, Enumerable)] args
     #
@@ -51,14 +51,28 @@ module Axiom
     #
     # @api public
     def self.new(*args)
-      last = args.last
-      if superclass.equal?(Object) && last.respond_to?(:size) && last.size.kind_of?(Integer)
+      if equal?(Relation) && materialized?(args[1])
         Materialized.new(*args)
       else
         super
       end
     end
 
+    # Test if the tuples are materialized
+    #
+    # When tuples are nil, it means there are no tuples so it is the equivalent
+    # of specifying [] for the tuples.
+    #
+    # @param [Enumerable, nil] tuples
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def self.materialized?(tuples)
+      tuples.nil? || tuples.respond_to?(:size) && tuples.size.kind_of?(Integer)
+    end
+    private_class_method :materialized?
+
     # Initialize a Relation
     #
     # @param [Header, #to_ary] header
@@ -71,7 +85,7 @@ module Axiom
     # @api private
     def initialize(header, tuples)
       @header = Header.coerce(header)
-      @tuples = freeze_object(tuples)
+      @tuples = tuples
     end
 
     # Lookup an Attribute in the header given an attribute name
@@ -105,7 +119,7 @@ module Axiom
     # @api public
     def each
       return to_enum unless block_given?
-      seen = Hash.new
+      seen = {}
       tuples.each do |tuple|
         tuple = Tuple.coerce(header, tuple)
         yield seen[tuple] = tuple unless seen.key?(tuple)
@@ -113,25 +127,6 @@ module Axiom
       self
     end
 
-    # Return a tuple if the relation contains exactly one tuple
-    #
-    # @example
-    #   tuple = relation.one
-    #
-    # @return [Tuple]
-    #
-    # @raise [NoTuplesError]
-    #   raised if no tuples are returned
-    # @raise [ManyTuplesError]
-    #   raised if more than one tuple is returned
-    #
-    # @api public
-    def one
-      tuples = to_a
-      assert_exactly_one_tuple(tuples.size)
-      tuples.first
-    end
-
     # Return a relation that represents a replacement of a relation
     #
     # Delete the tuples from the relation that are not in the other relation,
@@ -201,7 +196,8 @@ module Axiom
     # @api public
     def ==(other)
       other = coerce(other)
-      header == other.header &&
+      other.kind_of?(Relation) &&
+      header == other.header   &&
       to_set == other.to_set
     end
 
@@ -242,25 +238,10 @@ module Axiom
     #
     # @api private
     def self.coerce(header, object)
-      object.kind_of?(Relation) ? object : Relation.new(header, object)
-    end
-
-    # Assert exactly one tuple is returned
-    #
-    # @return [undefined]
-    #
-    # @raise [NoTuplesError]
-    #   raised if no tuples are returned
-    # @raise [ManyTuplesError]
-    #   raised if more than one tuple is returned
-    #
-    # @api private
-    def assert_exactly_one_tuple(size)
-      if size.zero?
-        raise NoTuplesError, 'one tuple expected, but was an empty set'
-      elsif size > 1
-        raise ManyTuplesError,
-          "one tuple expected, but set contained #{size} tuples"
+      if object.kind_of?(Relation) || ! object.kind_of?(Enumerable)
+        object
+      else
+        Relation.new(header, object)
       end
     end
 

data/lib/axiom/relation/base.rb

@@ -12,14 +12,14 @@ module Axiom
       # @example
       #   name = base.name
       #
-      # @return [#to_s]
+      # @return [Symbol]
       #
       # @api public
       attr_reader :name
 
       # Initialize a base relation
       #
-      # @param [#to_s] name
+      # @param [#to_sym] name
       #   the relation name
       # @param [Header, #to_ary] header
       #   the relation header
@@ -31,7 +31,7 @@ module Axiom
       # @api private
       def initialize(name, header, tuples = Empty::ZERO_TUPLE)
         super(header, tuples)
-        @name = freeze_object(name.to_s)
+        @name = name.to_sym
       end
 
     end # class Base

data/lib/axiom/relation/empty.rb

@@ -5,46 +5,17 @@ module Axiom
 
     # An empty relation
     class Empty < Materialized
-      ZERO_TUPLE = EMPTY_ARRAY
 
       # Initialize an empty Relation
       #
-      # @param [Header] _header
+      # @param [Header] header
       #   the header for the empty relation
-      # @param [#each] _tuples
-      #   optional original tuples
       #
       # @return [undefined]
       #
       # @api public
-      def initialize(_header, _tuples = ZERO_TUPLE)
-        super
-      end
-
-      # Noop #each method
-      #
-      # @example
-      #   empty = Empty.new(header)
-      #   empty.each { ... }
-      #
-      # @return [self]
-      #
-      # @api public
-      def each
-        return to_enum unless block_given?
-        self
-      end
-
-      # Return the number of tuples
-      #
-      # @example
-      #   empty.size  # => 0
-      #
-      # @return [0]
-      #
-      # @api public
-      def size
-        0
+      def initialize(header)
+        super(header, ZERO_TUPLE)
       end
 
     end # class Empty

data/lib/axiom/relation/header.rb

@@ -43,7 +43,7 @@ module Axiom
           # Find the attribute with the block if possible, then fallback
           # to the default coercion method.
           block = lambda do |attribute|
-            block_given? and yield(attribute) or coerce_attribute(attribute)
+            coerce_attribute(block_given? && yield(attribute) || attribute)
           end
           new(Array(object).map(&block), options)
         end
@@ -114,7 +114,7 @@ module Axiom
       # Initialize a Header
       #
       # @example
-      #   header = Header.new(attributes, :keys => [ [ :id ] ])
+      #   header = Header.new(attributes, keys: [[:id]])
       #
       # @param [Array] attributes
       #
@@ -125,9 +125,8 @@ module Axiom
       # @api public
       def initialize(attributes, options)
         @attributes    = freeze_object(attributes)
-        @options       = freeze_object(options)
         @attribute_for = Hash[@attributes.map(&:name).zip(@attributes)]
-        @keys          = coerce_keys
+        @keys          = coerce_keys(options.fetch(:keys, EMPTY_ARRAY))
       end
 
       # Iterate over each attribute in the header
@@ -163,8 +162,10 @@ module Axiom
       # @api public
       def call(name)
         @attribute_for.fetch(Attribute.name_from(name)) do |attribute_name|
-          raise UnknownAttributeError,
+          raise(
+            UnknownAttributeError,
             "the attribute #{attribute_name} is unknown"
+          )
         end
       end
 
@@ -183,7 +184,7 @@ module Axiom
       #
       # @api public
       def project(attributes)
-        coerce(attributes, :keys => keys.project(attributes))
+        coerce(attributes, keys: keys.project(attributes))
       end
 
       # Return a header with the new attributes added
@@ -201,7 +202,7 @@ module Axiom
       #
       # @api public
       def extend(attributes)
-        new(to_ary + coerce(attributes), :keys => keys)
+        new(to_ary + coerce(attributes), keys: keys)
       end
 
       # Return a header with the attributes renamed
@@ -221,7 +222,7 @@ module Axiom
       def rename(aliases)
         new(
           map { |attribute| aliases[attribute] },
-          :keys => keys.rename(aliases)
+          keys: keys.rename(aliases)
         )
       end
 
@@ -241,7 +242,7 @@ module Axiom
       def intersect(other)
         other      = coerce(other)
         attributes = to_ary & other
-        new(attributes, :keys => (keys | other.keys).project(attributes))
+        new(attributes, keys: (keys | other.keys).project(attributes))
       end
 
       # Return the union of the header with another header
@@ -259,7 +260,7 @@ module Axiom
       # @api public
       def union(other)
         other = coerce(other)
-        new(to_ary | other, :keys => keys & other.keys)
+        new(to_ary | other, keys: keys & other.keys)
       end
 
       # Return the difference of the header with another header
@@ -277,7 +278,22 @@ module Axiom
       # @api public
       def difference(other)
         other = coerce(other)
-        new(to_ary - other, :keys => keys - other.keys)
+        new(to_ary - other, keys: keys - other.keys)
+      end
+
+      # Evaluate a block within the context of the header
+      #
+      # @yield [context]
+      #
+      # @yieldparam [Evaluator::Context] context
+      #
+      # @yieldreturn [Evaluator::Context]
+      #
+      # @return [Header]
+      #
+      # @api private
+      def context(&block)
+        Evaluator::Context.new(self, &block)
       end
 
       # Convert the Header into an Array
@@ -319,13 +335,13 @@ module Axiom
 
       # Coerce the keys into an Array of Headers
       #
+      # @return [Array]
+      #
       # @return [Array<Header>]
       #
       # @api private
-      def coerce_keys
-        Keys.coerce(@options.fetch(:keys, EMPTY_ARRAY)) do |attributes|
-          coerce(attributes)
-        end
+      def coerce_keys(keys)
+        Keys.coerce(keys) { |attributes| coerce(attributes) }
       end
 
       # Coerce the object into a Header