nrser 0.0.25 → 0.0.26

data/lib/nrser/types/{hash.rb → hashes.rb}

@@ -14,8 +14,7 @@ module NRSER::Types
       super ::Hash, **options
       
       @keys = NRSER::Types.make keys
-      @values = NRSER::Types.make keys
-      
+      @values = NRSER::Types.make values
     end
     
     def test value
@@ -31,9 +30,20 @@ module NRSER::Types
     end
   end # HashType
   
-  HASH = HashType.new.freeze
   
-  def self.hash_ *args
+
+  # Type satisfied by {Hash} instances.
+  # 
+  # @param [Array] *args
+  #   Passed to {NRSER::Types::HashType#initialize} unless empty.
+  # 
+  # @return [NRSER::Types::HASH]
+  #   If `args` are empty.
+  # 
+  # @return [NRSER::Types::Type]
+  #   Newly constructed hash type from `args`.
+  # 
+  def self.hash_type *args
     if args.empty?
       HASH
     else
@@ -41,5 +51,9 @@ module NRSER::Types
     end
   end
   
-  singleton_class.send :alias_method, :dict, :hash_
+  singleton_class.send :alias_method, :dict, :hash_type
+  singleton_class.send :alias_method, :hash_, :hash_type
+  
+  HASH = HashType.new.freeze
+  
 end

data/lib/nrser/types/in.rb

@@ -0,0 +1,47 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+require_relative './where'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements'
+using NRSER
+
+
+# Declarations
+# =======================================================================
+
+module NRSER; end
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  # Type that tests value for membership in a group object via that object's
+  # `#include?` method.
+  # 
+  # @param [#include?] group
+  #   `#include?` will be called on this value to determine type membership.
+  # 
+  # @return [NRSER::Types::Type]
+  # 
+  def self.in group, **options
+    where( name: "In(#{ group })", **options ) { |value|
+      group.include? value
+    }
+  end # .in
+  
+end # module NRSER::Types

data/lib/nrser/types/is_a.rb

@@ -11,8 +11,8 @@ module NRSER::Types
       @klass = klass
     end
     
-    def name
-      @name || "#{ self.class.short_name }(#{ @klass })"
+    def default_name
+      "#{ self.class.short_name }(#{ @klass })"
     end
     
     def test value

data/lib/nrser/types/labels.rb

@@ -0,0 +1,49 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements'
+using NRSER
+
+
+# Declarations
+# =======================================================================
+
+module NRSER; end
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  # A label is a non-empty {String} or {Symbol}.
+  # 
+  # @param [Hash] **options
+  #   Options to pass to {NRSER::Types::Type#initialize}.
+  # 
+  # @return [NRSER::Types::Type]
+  # 
+  def self.label **options
+    if options.empty?
+      LABEL
+    else
+      union non_empty_str, non_empty_sym, **options
+    end
+  end # .label
+  
+  LABEL = label( name: 'LabelType' ).freeze
+  
+end # module NRSER::Types

data/lib/nrser/types/numbers.rb

@@ -7,91 +7,127 @@ require 'nrser/types/bounded'
 using NRSER
   
 module NRSER::Types
+  # Parse a string into a number.
+  # 
+  # @return [Integer]
+  #   If the string represents a whole integer.
+  # 
+  # @return [Float]
+  #   If the string represents a decimal number.
+  # 
   def self.parse_number s
-    float = s.to_f
+    float = Float s
     int = float.to_i
     if float == int then int else float end
   end
   
-  # zero
-  # ====
   
-  ZERO = is 0, name: 'zero', from_s: method(:parse_number)
+  # Zero
+  # =====================================================================
+  
+  ZERO = is(
+    0,
+    name: 'ZeroType',
+    from_s: method( :parse_number )
+  ).freeze
   
   def self.zero
     ZERO
   end
   
-  # number (Numeric)
-  # ================
   
-  NUM = IsA.new Numeric, name: 'Num', from_s: method(:parse_number)
+  # Number ({Numeric})
+  # =====================================================================
+  
+  NUM = IsA.new(
+    Numeric,
+    name: 'NumType',
+    from_s: method( :parse_number )
+  ).freeze
   
   def self.num
     NUM
   end
   
-  # integers
-  # ========
+  singleton_class.send :alias_method, :number, :num
+  
+  
+  # Integers
+  # =====================================================================
   
-  INT = IsA.new Integer, name: 'Int', from_s: method(:parse_number)
+  INT = IsA.new(
+    Integer,
+    name: 'IntType',
+    from_s: method( :parse_number )
+  ).freeze
   
   def self.int
     INT
   end
   
-  def self.integer
-    int
-  end
+  singleton_class.send :alias_method, :integer, :int
   
-  # bounded integers
-  # ================
-  # 
   
-  # positive integer
+  # Bounded Integers
+  # ---------------------------------------------------------------------
+  
+  # Positive Integer
   # ----------------
   # 
-  # integer greater than zero.
+  # Integer greater than zero.
   # 
   
-  POS_INT = intersection INT, bounded(min: 1), name: 'PosInt'
+  POS_INT = intersection(
+    INT,
+    bounded(min: 1),
+    name: 'PosIntType'
+  ).freeze
   
   def self.pos_int
     POS_INT
   end
   
-  # negative integer
+  
+  # Negative Integer
   # ----------------
   # 
-  # integer less than zero
+  # Integer less than zero.
   # 
   
-  NEG_INT = intersection INT, bounded(max: -1), name: 'NegInt'
+  NEG_INT = intersection(
+    INT,
+    bounded(max: -1),
+    name: 'NegIntType'
+  ).freeze
   
   def self.neg_int
     NEG_INT
   end
   
-  # non-negative integer
+  
+  # Non-Negative Integer
   # --------------------
   # 
-  # positive integers and zero... but it seems more efficient to define these
+  # Positive integers and zero... but it seems more efficient to define these
   # as bounded instead of a union. 
   # 
   
-  NON_NEG_INT = intersection INT, bounded(min: 0), name: 'NonNegInt'
+  NON_NEG_INT = intersection INT, bounded(min: 0), name: 'NonNegIntType'
   
   def self.non_neg_int
     NON_NEG_INT
   end
   
-  # non-positive integer
+  singleton_class.send :alias_method, :unsigned, :non_neg_int
+  
+  
+  # Non-Positive Integer
   # --------------------
   # 
   # negative integers and zero.
   # 
   
-  NON_POS_INT = intersection INT, bounded(max: 0), name: 'NonPosInt'
+  NON_POS_INT = intersection INT, bounded(max: 0), name: 'NonPosIntType'
   
   def self.non_pos_int
     NON_POS_INT

data/lib/nrser/types/pairs.rb

@@ -0,0 +1,109 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+require_relative './combinators'
+
+
+# Refinements
+# =======================================================================
+
+
+# Declarations
+# =======================================================================
+
+module NRSER; end
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  
+  # @todo Document array_pair method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.array_pair **options
+    return ARRAY_PAIR if options.empty?
+    
+    key   = options.delete(:key)    || ANY
+    value = options.delete(:value)  || ANY
+    
+    tuple key, value, **options
+  end # .array_pair
+  
+  ARRAY_PAIR = array_pair( name: 'ArrayPairType' ).freeze
+  
+  
+  # Type for a {Hash} that consists of only a single key and value pair.
+  # 
+  # @param [String] name:
+  #   Name to give the new type.
+  # 
+  # @param [Hash] **options
+  #   Other options to pass to 
+  # 
+  # @return [NRSER::Types::Type]
+  # 
+  def self.hash_pair **options
+    return HASH_PAIR if options.empty?
+    
+    hash_options = {}
+    {key: :keys, value: :values}.each { |from_key, to_key|
+      if options.key? from_key
+        hash_options[to_key] = options.delete from_key
+      end
+    }
+    
+    if hash_options.empty?
+      intersection is_a( Hash ), length( 1 ), **options
+    else    
+      intersection \
+        hash_type( **hash_options ),
+        length( 1 ),
+        **options
+    end
+    
+  end # .hash_pair
+  
+  HASH_PAIR = hash_pair( name: 'HashPairType' ).freeze
+  
+
+  # @todo Document pair method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.pair **options
+    if options.empty?
+      PAIR
+    else
+      type_options = NRSER.slice_keys! options, :key, :value
+      
+      union \
+        array_pair( **type_options ),
+        hash_pair( **type_options ),
+        **options
+    end
+  end # #pair
+  
+  PAIR = pair( name: 'PairType' ).freeze
+  
+end # module NRSER::Types
+

data/lib/nrser/types/responds.rb

@@ -1,8 +1,8 @@
 
-# @todo document NRSER::Types module.
 module NRSER::Types
   
-  # @todo document Responds class.
+  # Type that encodes messages mapped to result types that member values must
+  # satisfy.
   class Responds < NRSER::Types::Type
     
     # Constants
@@ -87,7 +87,6 @@ module NRSER::Types
     end # #responds
     
     
-    
     # @todo Document respond_to Responds.
     # 
     # @param [type] arg_name

data/lib/nrser/types/strings.rb

@@ -6,35 +6,34 @@ require 'nrser/types/attrs'
 using NRSER
   
 module NRSER::Types
-  STR = IsA.new String, name: 'Str', from_s: ->(s) { s }
-  
-  def self.str **options
-    if options.empty?
+  def self.str length: nil, **options
+    if length.nil? && options.empty?
       # if there are no options can point to the constant for efficiency
       STR
     else
-      types = []
-      
-      if options[:length]
-        types << length(options[:length])
+      if length.nil?
+        IsA.new String, from_s: ->(s) { s }, **options
+      else
+        intersection \
+          IsA.new( String, from_s: ->(s) { s } ),
+          NRSER::Types.length( length ),
+          **options
       end
-      
-      intersection STR, *types
     end
   end # string
   
-  def self.string
-    str
-  end
-  
-  EMPTY_STR = Is.new ''
+  singleton_class.send :alias_method, :string, :str
   
-  NON_EMPTY_STR = str length: {min: 1}, name: "NonEmptyStr"
+  STR = str( name: 'StrType' ).freeze
   
+  EMPTY_STR = Is.new( '' ).freeze
   
-  def self.non_empty_str
-    NON_EMPTY_STR
+  def self.non_empty_str **options
+    return NON_EMPTY_STR if options.empty?
+    
+    str( length: {min: 1}, **options )
   end # .non_empty_str
   
+  NON_EMPTY_STR = non_empty_str( name: 'NonEmptyStr' ).freeze
   
 end # NRSER::Types