nrser 0.1.4 → 0.2.0.pre.0

data/lib/nrser/types.rb

@@ -7,15 +7,6 @@
 # need to be required in the "Post-Processing" section at the bottom.
 # 
 require_relative './types/type'
-require_relative './types/is'
-require_relative './types/nil'
-require_relative './types/is_a'
-require_relative './types/where'
-require_relative './types/combinators'
-require_relative './types/maybe'
-require_relative './types/attrs'
-require_relative './types/in'
-
 
 # Refinements
 # =======================================================================
@@ -29,6 +20,10 @@ using NRSER
 # 
 module NRSER::Types
   
+  L_PAREN = '(' # '❪'
+  R_PAREN = ')' # '❫'
+  RESPONDS_WITH = '→'
+  
   # Make a {NRSER::Types::Type} from a value.
   # 
   # If the `value` argument is...
@@ -50,12 +45,12 @@ module NRSER::Types
   # @return [NRSER::Types::Type]
   # 
   def self.make value
-    if value.is_a? NRSER::Types::Type
+    if value.nil?
+      self.nil
+    elsif value.is_a? NRSER::Types::Type
       value
-    elsif value.is_a? ::Class
-      IsA.new value
     else
-      Is.new value
+      self.when value
     end
   end
   
@@ -138,11 +133,62 @@ module NRSER::Types
       },
       
       Hash => ->(hash) {
-        
+        raise NotImplementedError, "Haven't gotten to it yet!"
       },
     }
   end # .from_repr
   
+  
+  # Define a type factory.
+  # 
+  # @!macro [attach] factory
+  #   @param [Hash] **options
+  #     Common type construction options, see {Type#initialize}.
+  #   
+  #   @return [NRSER::Types::Type]
+  #     The type.
+  # 
+  def self.def_factory name, maybe: true, aliases: [], &body
+    define_singleton_method name, &body
+    
+    aliases.each do |alias_name|
+      singleton_class.send :alias_method, alias_name, name
+    end
+    
+    if maybe && !name.to_s.end_with?( '?' )
+      maybe_name = "#{ name }?".to_sym
+      
+      # HACK  Ugh maybe I wrote this quick to fix it, not sure if it's a decent
+      #       idea.. basically, need to figure out what `options` keys go
+      #       to {.maybe} and which ones go to the regular factory... matters
+      #       for shit like {.attrs} and {.hash_type} 'cause they use option
+      #       keys (whether they *should* is something I've debated... sigh,
+      #       it is what it is for now).
+      #       
+      #       So they options that go to {.maybe} just go strait through to
+      #       {Type#initialize}, so just grab that method, see what keys it
+      #       takes, and then can slice and dice off that...
+      # 
+      maybe_option_keys = Set.new \
+        Type.
+          instance_method( :initialize ).
+          parameters.
+          select { |param_type, name| param_type == :key }.
+          map { |param_type, name| name }
+      
+      define_singleton_method maybe_name do |*args, **options|
+        maybe_options = options.slice *maybe_option_keys
+        factory_options = options.except *maybe_option_keys
+        
+        maybe public_send( name, *args, **factory_options ), **maybe_options
+      end
+      
+      aliases.each do |alias_name|
+        singleton_class.send :alias_method, "#{ alias_name }?", maybe_name
+      end
+    end
+  end
+  
 end # NRSER::Types
 
 
@@ -152,6 +198,16 @@ end # NRSER::Types
 # Files that define constants that need the proceeding infrastructure.
 # 
 
+require_relative './types/is'
+require_relative './types/nil'
+require_relative './types/is_a'
+require_relative './types/where'
+require_relative './types/combinators'
+require_relative './types/maybe'
+require_relative './types/attrs'
+require_relative './types/in'
+
+require_relative './types/when'
 require_relative './types/any'
 require_relative './types/booleans'
 
@@ -168,3 +224,4 @@ require_relative './types/paths'
 require_relative './types/tuples'
 require_relative './types/pairs'
 require_relative './types/trees'
+require_relative './types/shape'

data/lib/nrser/types/attrs.rb

@@ -8,6 +8,12 @@ module NRSER::Types
   class Attrs < NRSER::Types::Type
     def initialize attrs, **options
       super **options
+      
+      if attrs.empty?
+        raise ArgumentError,
+          "Must provide at least one attribute name/type pair"
+      end
+      
       @attrs = NRSER.map_values(attrs) { |name, type|
         NRSER::Types.make type
       }
@@ -15,10 +21,14 @@ module NRSER::Types
     
     def default_name
       attrs_str = @attrs.map { |name, type|
-        "#{ name }=#{ type.name }"
+        "##{ name }#{ RESPONDS_WITH }#{ type.name }"
       }.join(', ')
       
-      "#{ self.class.short_name } #{ attrs_str }"
+      if @attrs.length < 2
+        attrs_str
+      else
+        L_PAREN + attrs_str + R_PAREN
+      end
     end
     
     def test value
@@ -29,121 +39,122 @@ module NRSER::Types
   end # Attrs
   
   
-  # Eigenclass (Singleton Class)
-  # ========================================================================
+  # @!group Type Factory Functions
+  
+  # Get a {Type} that checks the types of one or more attributes on values.
   # 
-  class << self
-    def attrs attrs, options = {}
-      Attrs.new attrs, **options
-    end
-    
+  # @example Type where first element of an Enumerable is a String
+  #   string_first = intersection Enumerable, attrs(first: String)
+  # 
+  def_factory :attrs do |attrs, **options|
+    Attrs.new attrs, **options
+  end
+  
+  
+  # @overload length exact, options = {}
+  #   Get a length attribute type that specifies an `exact` value.
+  #   
+  #   @example
+  #     only_type = NRSER::Types.length 1
+  #     
+  #     only_type.test []
+  #     # => false
+  #     
+  #     only_type.test [:x]
+  #     # => true
+  #     
+  #     only_type.test [:x, :y]
+  #     # => false
+  #   
+  #   @param [Integer] exact
+  #     Exact non-negative integer that the length must be to satisfy the
+  #     type created.
+  #   
+  #   @param [Hash] options
+  #     Options hash passed up to {NRSER::Types::Type} constructor.
+  #   
+  #   @return [NRSER::Types::Attrs]
+  #     Type satisfied by a `#length` attribute that is exactly `exact`.
+  # 
+  # 
+  # @overload length bounds, options = {}
+  #   Get a length attribute type satisfied by values within a `:min` and
+  #   `:max` (inclusive).
+  #   
+  #   @example
+  #     three_to_five = NRSER::Types.length( {min: 3, max: 5}, name: '3-5' )
+  #     three_to_five.test [1, 2]               # => false
+  #     three_to_five.test [1, 2, 3]            # => true
+  #     three_to_five.test [1, 2, 3, 4]         # => true
+  #     three_to_five.test [1, 2, 3, 4, 5]      # => true
+  #     three_to_five.test [1, 2, 3, 4, 5, 6]   # => false
+  # 
+  #   @param [Hash] bounds
+  #   
+  #   @option bounds [Integer] :min
+  #     An optional minimum value that the `#length` should not be less than.
+  #   
+  #   @option bounds [Integer] :max
+  #     An optional maximum value that the `#length` should not be more than.
+  #   
+  #   @option bounds [Integer] :length
+  #     An optional value for both the minimum and maximum.
+  #   
+  #   @param [Hash] options
+  #     Options hash passed up to {NRSER::Types::Type} constructor.
+  #   
+  #   @return [NRSER::Types::Attrs]
+  #     Type satisfied by a `#length` attribute between the `:min` and `:max`
+  #     (inclusive).
+  # 
+  def self.length *args
+    bounds = {}
+    options = if args[1].is_a?( Hash ) then args[1] else {} end
     
-    # @overload length exact, options = {}
-    #   Get a length attribute type that specifies an `exact` value.
-    #   
-    #   @example
-    #     only_type = NRSER::Types.length 1
-    #     
-    #     only_type.test []
-    #     # => false
-    #     
-    #     only_type.test [:x]
-    #     # => true
-    #     
-    #     only_type.test [:x, :y]
-    #     # => false
-    #   
-    #   @param [Integer] exact
-    #     Exact non-negative integer that the length must be to satisfy the
-    #     type created.
-    #   
-    #   @param [Hash] options
-    #     Options hash passed up to {NRSER::Types::Type} constructor.
-    #   
-    #   @return [NRSER::Types::Attrs]
-    #     Type satisfied by a `#length` attribute that is exactly `exact`.
-    # 
-    # 
-    # @overload length bounds, options = {}
-    #   Get a length attribute type satisfied by values within a `:min` and 
-    #   `:max` (inclusive).
-    #   
-    #   @example
-    #     three_to_five = NRSER::Types.length( {min: 3, max: 5}, name: '3-5' )
-    #     three_to_five.test [1, 2]               # => false
-    #     three_to_five.test [1, 2, 3]            # => true
-    #     three_to_five.test [1, 2, 3, 4]         # => true
-    #     three_to_five.test [1, 2, 3, 4, 5]      # => true
-    #     three_to_five.test [1, 2, 3, 4, 5, 6]   # => false
-    # 
-    #   @param [Hash] bounds
-    #   
-    #   @option bounds [Integer] :min
-    #     An optional minimum value that the `#length` should not be less than.
-    #   
-    #   @option bounds [Integer] :max
-    #     An optional maximum value that the `#length` should not be more than.
-    #   
-    #   @option bounds [Integer] :length
-    #     An optional value for both the minimum and maximum.
-    #   
-    #   @param [Hash] options
-    #     Options hash passed up to {NRSER::Types::Type} constructor.
-    #   
-    #   @return [NRSER::Types::Attrs]
-    #     Type satisfied by a `#length` attribute between the `:min` and `:max`
-    #     (inclusive).
-    # 
-    def length *args
-      bounds = {}
-      options = if args[1].is_a?( Hash ) then args[1] else {} end
+    case args[0]
+    when ::Integer
+      # It's just a length
+      bounds[:min] = bounds[:max] = non_neg_int.check args[0]
       
-      case args[0]
-      when ::Integer
-        # It's just a length
-        bounds[:min] = bounds[:max] = non_neg_int.check args[0]
-        
-      when ::Hash
-        # It's keyword args
-        kwds = NRSER.symbolize_keys args[0]
-        
-        # Pull any :min and :max in the keywords
-        bounds[:min] = kwds.delete :min
-        bounds[:max] = kwds.delete :max
-        
-        # But override with :length if we got it
-        if length = kwds.delete(:length)
-          bounds[:min] = length
-          bounds[:max] = length
-        end
-        
-        # (Reverse) merge anything else into the options (options hash values
-        # take precedence)
-        options = kwds.merge options
-        
-      else        
-        raise ArgumentError, <<-END.squish
-          arg must be positive integer or option hash, found:
-          #{ args[0].inspect } of type #{ args[0].class }
-        END
-        
-      end
+    when ::Hash
+      # It's keyword args
+      kwds = NRSER.symbolize_keys args[0]
       
-      bounded_type = bounded bounds
+      # Pull any :min and :max in the keywords
+      bounds[:min] = kwds.delete :min
+      bounds[:max] = kwds.delete :max
       
-      length_type = if !bounded_type.min.nil? && bounded_type.min >= 0
-        # We don't need the non-neg check
-        bounded_type
-      else
-        # We do need the non-neg check
-        intersection(non_neg_int, bounded_type)
+      # But override with :length if we got it
+      if length = kwds.delete(:length)
+        bounds[:min] = length
+        bounds[:max] = length
       end
       
-      options[:name] ||= "Length<#{ bounded_type.name }>"
+      # (Reverse) merge anything else into the options (options hash values
+      # take precedence)
+      options = kwds.merge options
+      
+    else
+      raise ArgumentError, <<-END.squish
+        arg must be positive integer or option hash, found:
+        #{ args[0].inspect } of type #{ args[0].class }
+      END
       
-      attrs({ length: length_type }, options)
-    end # #length
+    end
+    
+    bounded_type = bounded bounds
+    
+    length_type = if !bounded_type.min.nil? && bounded_type.min >= 0
+      # We don't need the non-neg check
+      bounded_type
+    else
+      # We do need the non-neg check
+      intersection(non_neg_int, bounded_type)
+    end
+    
+    options[:name] ||= "Length<#{ bounded_type.name }>"
     
-  end # class << self (Eigenclass)
+    attrs({ length: length_type }, options)
+  end # #length
   
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/bounded.rb

@@ -3,7 +3,7 @@ require 'nrser/types/type'
 
 using NRSER
   
-module NRSER::Types  
+module NRSER::Types
   class Bounded < NRSER::Types::Type
     
     # @!attribute [r] min
@@ -44,10 +44,11 @@ module NRSER::Types
       
       "#{ self.class.short_name } #{ attrs_str }"
     end
+    
   end # Bounded
   
   def self.bounded **options
     Bounded.new **options
   end
    
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/combinators.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'nrser/refinements'
 require 'nrser/types/type'
 
@@ -16,9 +19,15 @@ module NRSER::Types
     
     
     def default_name
-      "#{ self.class.short_name }<" +
-      @types.map {|type| type.name }.join(',') +
-      ">"
+      if self.class::JOIN_SYMBOL
+        NRSER::Types::L_PAREN +
+        @types.map { |type| type.name }.join( self.class::JOIN_SYMBOL ) +
+        NRSER::Types::R_PAREN
+      else
+        "#{ self.class.short_name }<" +
+        @types.map {|type| type.name }.join(',') +
+        ">"
+      end
     end
     
     
@@ -101,6 +110,8 @@ module NRSER::Types
   end
   
   class Union < Combinator
+    JOIN_SYMBOL = ' ⋁ '
+    
     def test value
       @types.any? {|type| type.test value}
     end
@@ -112,14 +123,14 @@ module NRSER::Types
   end
   
   singleton_class.send :alias_method, :one_of, :union
+  singleton_class.send :alias_method, :or, :union
   
   class Intersection < Combinator
-    def test value
-      @types.all? {|type| type.test value}
-    end
+    # JOIN_SYMBOL = ', '
+    JOIN_SYMBOL = ' ⋀ '
     
-    def default_name
-      "( #{ @types.map { |t| t.name }.join ' | ' } )"
+    def test value
+      @types.all? { |type| type.test value}
     end
   end
   
@@ -129,5 +140,25 @@ module NRSER::Types
   end
   
   singleton_class.send :alias_method, :all_of, :intersection
+  singleton_class.send :alias_method, :and, :intersection
+  
+  
+  class XOR < Combinator
+    JOIN_SYMBOL = ' ⊕ '
+    
+    def test value
+      @types.count { |type| type === value } == 1
+    end
+    
+    # def default_name
+    #   '⊕'
+    #   "( #{ @types.map { |t| t.name }.join ' ⊕ ' } )"
+    # end
+  end
+  
+  
+  def self.xor *types, **options
+    XOR.new *types, **options
+  end
   
 end # NRSER::Types