nrser 0.2.2 → 0.3.0

data/lib/nrser/types/is_a.rb

@@ -3,73 +3,92 @@ require 'nrser/types/type'
 using NRSER
 
 module NRSER::Types
+  # Type satisfied by class membership (or mixin presence for modules).
+  # 
+  # Tests via the subject value's `#is_a?` method.
+  # 
   class IsA < NRSER::Types::Type
-    attr_reader :klass
-    
-    def initialize klass, **options
-      unless klass.is_a?( Class ) || klass.is_a?( Module )
-        raise ArgumentError.new binding.erb <<-ERB
-          `klass` argument must be a Class or Module, found:
-          
-              <%= klass.pretty_inspect %>
-          
-        ERB
+    attr_reader :mod
+    
+    def initialize mod, init_from_data: false, **options
+      unless mod.is_a?( Module )
+        raise ArgumentError,
+          "`mod` argument must be a Module (inc. Class), " \
+          "received #{ mod.inspect }"
       end
       
       super **options
-      @klass = klass
+      
+      @init_from_data = !!init_from_data
+      
+      @mod = mod
     end
     
     
-    def default_name
-      @klass.name
+    def explain
+      mod.safe_name
     end
     
     
-    def test value
-      value.is_a? @klass
+    def test? value
+      value.is_a? mod
     end
     
     
-    # If {#klass} responds to `#from_data`, call that and check results.
+    
+    # @todo Document init_from_data? method.
+    # 
+    # @param [type] arg_name
+    #   @todo Add name param description.
     # 
-    # Otherwise, forward up to {NRSER::Types::Type#from_data}.
+    # @return [return_type]
+    #   @todo Document return value.
     # 
-    # @param [Object] data
-    #   Data to create the value from that will satisfy the type.
+    def init_from_data?
+      @init_from_data
+    end # #init_from_data?
+    
+    
+    
+    # Forwards to `mod.from_data`.
     # 
-    # @return [Object]
-    #   Instance of {#klass}.
+    # @param data (see NRSER::Types::Type#from_data)
+    # @return     (see NRSER::Types::Type#from_data)
+    # @raise      (see NRSER::Types::Type#from_data)
     # 
-    def from_data data
-      if @from_data.nil?
-        if @klass.respond_to? :from_data
-          check @klass.from_data( data )
-        else
-          super data
-        end
+    def custom_from_data data
+      if init_from_data?
+        mod.new data
       else
-        @from_data.call data
+        mod.from_data data
       end
     end
     
     
+    # Overrides {NRSER::Types::Type#has_from_data?} to respond `true` when
+    # there is a instance-specific `@from_data` or the {#mod} responds to
+    # `.from_data`.
+    # 
+    # @return [Boolean]
+    # 
     def has_from_data?
-      @from_data || @klass.respond_to?( :from_data )
+      @from_data ||
+        init_from_data? ||
+        mod.respond_to?( :from_data )
     end
     
     
     def == other
       equal?( other ) ||
       ( self.class == other.class &&
-        self.klass == other.klass )
+        self.mod == other.mod )
     end
     
   end # IsA
   
   
   # class membership
-  def self.is_a klass, **options
-    IsA.new klass, **options
+  def_factory :is_a do |mod, **options|
+    IsA.new mod, **options
   end
 end # NRSER::Types

data/lib/nrser/types/labels.rb

@@ -1,28 +1,5 @@
-# Requirements
-# =======================================================================
-
-# Stdlib
-# -----------------------------------------------------------------------
-
-# Deps
-# -----------------------------------------------------------------------
-
-# Project / Package
-# -----------------------------------------------------------------------
-
-
-# Refinements
-# =======================================================================
-
-require 'nrser/refinements'
-using NRSER
-
-
-# Declarations
-# =======================================================================
-
-module NRSER; end
-
+require_relative './combinators'
+require_relative './strings'
 
 # Definitions
 # =======================================================================
@@ -36,14 +13,10 @@ module NRSER::Types
   # 
   # @return [NRSER::Types::Type]
   # 
-  def self.label **options
-    if options.empty?
-      LABEL
-    else
-      union non_empty_str, non_empty_sym, **options
-    end
+  def_factory(
+    :label,
+  ) do |name: 'Label', **options|
+    union non_empty_str, non_empty_sym, name: name, **options
   end # .label
   
-  LABEL = label( name: 'LabelType' ).freeze
-  
 end # module NRSER::Types

data/lib/nrser/types/maybe.rb

@@ -1,10 +1,18 @@
-require 'nrser/types/combinators'
+require_relative './combinators'
+require_relative './nil'
 
 module NRSER::Types
     
-  # nil or the argument type
-  def self.maybe type, **options
-    union self.nil, type, name: "#{ type.name }?", **options
+  # Type satisfied by `nil` or the parametrized type.
+  # 
+  def_factory(
+    :maybe,
+  ) do |type, **options|
+    union \
+      self.nil,
+      type,
+      name: (options[:name] || "#{ type.name }?"),
+      **options
   end
   
 end # NRSER::Types

data/lib/nrser/types/nil.rb

@@ -1,8 +1,28 @@
-require 'nrser/types/is'
+require_relative './is'
   
 module NRSER::Types
-  # nothing
-  def self.nil
-    is nil, name: 'Nil'
+  # Type for `nil`, itself and only.
+  # 
+  # @todo
+  #   Should we have a `#from_s` that converts the empty string to `nil`?
+  #   
+  #   Kind-of seems like we would want that to be a different types so that
+  #   you can have a Nil type that is distinct from the empty string in
+  #   parsing, but also have a type that accepts the empty string and coverts
+  #   it to `nil`?
+  #   
+  #   Something like:
+  #   
+  #       type = t.empty | t.non_empty_str
+  #       type.from_s ''
+  #       # => nil
+  #       type.from_s 'blah'
+  #       # => 'blah'
+  # 
+  def_factory(
+    :nil,
+    aliases: [ :null ],
+  ) do |name: 'Nil', **options|
+    is nil, name: name, **options
   end
 end # NRSER::Types

data/lib/nrser/types/not.rb

@@ -22,31 +22,21 @@ module NRSER::Types
     # Instance Methods
     # ======================================================================
     
-    def test value
+    def test? value
       ! @type.test( value )
     end
     
     
-    def default_name
-      "!#{ @type.name }"
+    def explain
+      "~#{ @type.name }"
     end
     
-    
-    # @return [String]
-    #   a brief string description of the type - just it's {#name} surrounded
-    #   by some back-ticks to make it easy to see where it starts and stops.
-    # 
-    def to_s
-      "{ x ∉ #{ @type.name } }"
-    end
-    
-    alias_method :inspect, :to_s
-    
-    
   end # class Not
   
   
-  def self.not type, **options
+  def_factory(
+    :not,
+  ) do |type, **options|
     Not.new type, **options
   end
   

data/lib/nrser/types/numbers.rb

@@ -15,8 +15,8 @@ module NRSER::Types
   # @return [Float]
   #   If the string represents a decimal number.
   # 
-  def self.parse_number s
-    float = Float s
+  def self.parse_number string
+    float = Float string
     int = float.to_i
     if float == int then int else float end
   end
@@ -25,48 +25,44 @@ module NRSER::Types
   # Zero
   # =====================================================================
   
-  ZERO = is(
-    0,
-    name: 'ZeroType',
-    from_s: method( :parse_number )
-  ).freeze
-  
-  def self.zero
-    ZERO
+  def_factory(
+    :Zero,
+    aliases: [ :zero ],
+  ) do |from_s: method( :parse_number ), **options|
+    is \
+      0,
+      from_s: from_s,
+      **options
   end
   
   
   # Number ({Numeric})
   # =====================================================================
   
-  NUM = IsA.new(
-    Numeric,
-    name: 'NumType',
-    from_s: method( :parse_number )
-  ).freeze
-  
-  def self.num
-    NUM
+  def_factory(
+    :Number,
+    aliases: [ :num, :number, :numeric, :Numeric ],
+  ) do |name: 'Number', from_s: method( :parse_number ), **options|
+    IsA.new \
+      Numeric,
+      from_s: from_s,
+      **options
   end
   
-  singleton_class.send :alias_method, :number, :num
-  
   
   # Integers
   # =====================================================================
   
-  INT = IsA.new(
-    Integer,
-    name: 'IntType',
-    from_s: method( :parse_number )
-  ).freeze
-  
-  def self.int
-    INT
+  def_factory(
+    :Integer,
+    aliases: [ :int, :integer, :signed ],
+  ) do |name: 'ℤ', from_s: method( :parse_number ), **options|
+    IsA.new \
+      Integer,
+      from_s: from_s,
+      **options
   end
   
-  singleton_class.send :alias_method, :integer, :int
-  
   
   # Bounded Integers
   # ---------------------------------------------------------------------
@@ -77,12 +73,15 @@ module NRSER::Types
   # Integer greater than zero.
   # 
   
-  def self.pos_int
-    intersection(
-      INT,
-      bounded(min: 1),
-      name: 'ℤ⁺'
-    ).freeze
+  def_factory(
+    :PositiveInteger,
+    aliases: [ :pos_int, :positive_int, :positive_integer ]
+  ) do |name: 'ℤ⁺', **options|
+    intersection \
+      int,
+      bounded( min: 1 ),
+      name: name,
+      **options
   end
   
   # Ugh sometimes the naturals have 0, so omit it...
@@ -95,12 +94,15 @@ module NRSER::Types
   # Integer less than zero.
   # 
   
-  def self.neg_int
-    intersection(
-      INT,
-      bounded(max: -1),
-      name: 'ℤ⁻'
-    ).freeze
+  def_factory(
+    :NegativeInteger,
+    aliases: [ :neg_int, :negative_int, :negative_integer ],
+  ) do |name: 'ℤ⁻', **options|
+    intersection \
+      int,
+      bounded( max: -1 ),
+      name: name,
+      **options
   end
   
   
@@ -111,20 +113,23 @@ module NRSER::Types
   # as bounded instead of a union.
   # 
   
-  def self.non_neg_int **options
-    # Alternative symbol: 'ℤ⋆'
-    intersection INT, bounded(min: 0), name: '{0}∪ℤ⁺', **options
-  end
-  
-  singleton_class.send :alias_method, :unsigned, :non_neg_int
-  
-  
-  def self.non_neg_int? **options
-    maybe non_neg_int, **options
+  def_factory(
+    :NonNegativeInteger,
+    aliases: [
+      :non_neg_int,
+      :unsigned,
+      :index,
+      :non_negative_int,
+      :non_negative_integer,
+    ],
+  ) do |name: 'ℕ⁰', **options|
+    intersection \
+      int,
+      bounded( min: 0 ),
+      name: name,
+      **options
   end
   
-  singleton_class.send :alias_method, :unsigned?, :non_neg_int?
-  
   
   # Non-Positive Integer
   # --------------------
@@ -132,8 +137,40 @@ module NRSER::Types
   # negative integers and zero.
   # 
   
-  def self.non_pos_int **options
-    intersection INT, bounded(max: 0), name: '{0}∪ℤ⁻', **options
+  def_factory(
+    :NonPositiveInteger,
+    aliases: [ :non_pos_int, :non_positive_int, :non_positive_integer ],
+  ) do |name: '{0}∪ℤ⁻', **options|
+    intersection \
+      int,
+      bounded( max: 0 ),
+      name: name,
+      **options
+  end
+  
+  
+  def_factory(
+    :Unsigned16BitInteger,
+    aliases: [ :uint16, :ushort ],
+  ) do |name: 'uint16', **options|
+    intersection \
+      int,
+      bounded( min: 0, max: ((2 ** 16) - 1) ),
+      name: name,
+      **options
   end
-   
+  
+  
+  # TODO  Move?
+  def_factory(
+    :UNIXPort,
+    aliases: [ :port, ],
+  ) do |name: 'port', **options|
+    intersection \
+      int,
+      bounded( min: 1, max: (2**16 - 1) ),
+      name: name,
+      **options
+  end
+  
 end # NRSER::Types

data/lib/nrser/types/pairs.rb

@@ -9,7 +9,10 @@
 
 # Project / Package
 # -----------------------------------------------------------------------
+require 'nrser/core_ext/hash'
+
 require_relative './combinators'
+require_relative './tuples'
 
 
 # Refinements
@@ -27,83 +30,80 @@ module NRSER; end
 
 module NRSER::Types
   
-  
-  # @todo Document array_pair method.
-  # 
-  # @param [type] arg_name
-  #   @todo Add name param description.
+  # Type for key/value pairs encoded as a {.tuple} (Array) of length 2.
   # 
-  # @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
+  def_factory(
+    :array_pair,
+  ) do |name: 'ArrayPair', key: any, value: any, **options|
+    unless options.key? :name
+      options[:name] = if key == any && value == any
+        'ArrayPair'
+      else
+        key = NRSER::Types.make key
+        value = NRSER::Types.make value
+        
+        "ArrayPair<#{ key.name }, #{ value.name }>"
+      end
+    end
     
-    tuple key, value, **options
+    tuple \
+      key,
+      value,
+      # name: name,
+      **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.
+  # Type for key/value pairs encoded as {Hash} with a single entry.
   # 
   # @param [String] name:
   #   Name to give the new type.
   # 
   # @param [Hash] **options
-  #   Other options to pass to 
-  # 
-  # @return [NRSER::Types::Type]
+  #   Other options to pass to
   # 
-  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
+  def_factory(
+    :hash_pair,
+  ) do |key: any, value: any, **options|
+    unless options.key? :name
+      options[:name] = if key == any && value == any
+        'HashPair'
+      else
+        key = NRSER::Types.make key
+        value = NRSER::Types.make value
+        
+        "HashPair<#{ key.name }, #{ value.name }>"
       end
-    }
-    
-    if hash_options.empty?
-      intersection is_a( Hash ), length( 1 ), **options
-    else    
-      intersection \
-        hash_type( **hash_options ),
-        length( 1 ),
-        **options
     end
     
+    intersection \
+      hash_type( keys: key, values: value ),
+      length( 1 ),
+      # name: name,
+      **options
   end # .hash_pair
   
-  HASH_PAIR = hash_pair( name: 'HashPairType' ).freeze
-  
 
-  # @todo Document pair method.
-  # 
-  # @param [type] arg_name
-  #   @todo Add name param description.
+  # A key/value pair, which can be encoded as an Array of length 2 or a
+  # Hash of length 1.
   # 
-  # @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
+  def_factory :pair do |key: any, value: any, **options|
+    unless options.key? :name
+      options[:name] = if key == any && value == any
+        'Pair'
+      else
+        key = NRSER::Types.make key
+        value = NRSER::Types.make value
+        
+        "Pair<#{ key.name }, #{ value.name }>"
+      end
     end
+    
+    union \
+      array_pair( key: key, value: value ),
+      hash_pair( key: key, value: value ),
+      **options
   end # #pair
   
-  PAIR = pair( name: 'PairType' ).freeze
-  
 end # module NRSER::Types
-