nrser 0.3.9 → 0.3.10

data/lib/nrser/types/maybe.rb

@@ -67,17 +67,20 @@ end # class Maybe
 # @!group Type Factory Functions
 # ----------------------------------------------------------------------------
 
-# @!method
+# @!method self.Maybe type, **options
 #   Type satisfied by `nil` or the parametrized type.
 #   
 #   @param [Type] type
 #     The type values must be if they are not `nil`.
 #   
-#   @param **options (see Type.initialize)
+#   @param [Hash] options (see Type.initialize)
 # 
 #   @return [Type]
 # 
-def_factory :maybe do |type, **options|
+def_type        :Maybe,
+  parameterize: :type,
+  default_name: false,
+&->( type, **options ) do
   Maybe.new type, **options
 end
 

data/lib/nrser/types/nil.rb

@@ -1,28 +1,65 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
 require_relative './is'
-  
-module NRSER::Types
-  # 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
+
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+# @!group Nil Type Factories
+# ----------------------------------------------------------------------------
+
+#@!method self.Nil **options
+#   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'
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :Nil,
+  aliases:      [ :null ],
+  # `.Nil?` would not make any sense...
+  maybe:        false,
+&->( **options ) do
+  is nil, **options
+end # .Nil
+
+# @!endgroup Nil Type Factories # ********************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER

data/lib/nrser/types/not.rb

@@ -1,43 +1,101 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
+require_relative './type'
+
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
 
 # Definitions
 # =======================================================================
 
-module NRSER::Types
-  
-  class Not < Type
-    
-    # Constructor
-    # ======================================================================
-    
-    # Instantiate a new `NRSER::Types::Not`.
-    def initialize type, **options
-      super **options
-      @type = type
-    end # #initialize
-    
-    
-    # Instance Methods
-    # ======================================================================
-    
-    def test? value
-      ! @type.test( value )
-    end
-    
-    
-    def explain
-      "~#{ @type.name }"
-    end
-    
-  end # class Not
-  
-  
-  def_factory(
-    :not,
-  ) do |type, **options|
-    Not.new type, **options
+# Negation {Type} - A {Type} that parameterizes another {#type} by admitting
+# values that the {#type} does not.
+# 
+# @note
+#   Construct {Not} types using the {.Not} factory.
+#
+class Not < Type
+
+  # The type this one isn't.
+  # 
+  # @return [Type]
+  #     
+  attr_reader :type
+
+  
+  # Constructor
+  # ======================================================================
+  
+  # Instantiate a new `NRSER::Types::Not`.
+  def initialize type, **options
+    super **options
+    @type = NRSER::Types.make type
+  end # #initialize
+  
+  
+  # Instance Methods
+  # ======================================================================
+  
+  def test? value
+    ! type.test( value )
   end
   
-end # module NRSER::Types
+
+  def default_symbolic
+    "#{ NRSER::Types.Top.symbolic }#{ COMPLEMENT }#{ type.symbolic }"
+  end
+
+
+  def default_name
+    "#{ NOT }#{ type.name }"
+  end
+
+  
+  def explain
+    "#{ self.class.demod_name }<#{ type.explain }>"
+  end
+  
+end # class Not
+
+
+# @!group Negation Type Factories
+# ----------------------------------------------------------------------------
+
+#@!method self.Not type, **options
+#   Negates another type.
+#   
+#   @param [TYPE] type
+#     The type to negate, made into one via {.make} if it's not already.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Not]
+#   
+def_type        :Not,
+  default_name: false,
+  parameterize: :type,
+&->( type, **options ) do
+  Not.new type, **options
+end # .Not
+
+# @!endgroup Negation Type Factories # ***************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module  NRSER
+end #module  Types

data/lib/nrser/types/numbers.rb

@@ -3,172 +3,227 @@ require 'nrser/types/is_a'
 require 'nrser/types/combinators'
 require 'nrser/types/bounded'
 
-  
-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 string
-    float = Float string
-    int = float.to_i
-    if float == int then int else float end
-  end
-  
-  
-  # Zero
-  # =====================================================================
-  
-  def_factory(
-    :Zero,
-    aliases: [ :zero ],
-  ) do |from_s: method( :parse_number ), **options|
-    is \
-      0,
-      from_s: from_s,
-      **options
-  end
-  
-  
-  # Number ({Numeric})
-  # =====================================================================
-  
-  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
-  
-  
-  # Integers
-  # =====================================================================
-  
-  def_factory(
-    :Integer,
-    aliases: [ :int, :integer, :signed ],
-  ) do |name: 'ℤ', from_s: method( :parse_number ), **options|
-    IsA.new \
-      Integer,
-      from_s: from_s,
-      **options
-  end
-  
-  
-  # Bounded Integers
-  # ---------------------------------------------------------------------
-  
-  # Positive Integer
-  # ----------------
-  # 
-  # Integer greater than zero.
-  # 
-  
-  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...
-  # singleton_class.send :alias_method, :natural, :pos_int
-  
-  
-  # Negative Integer
-  # ----------------
-  # 
-  # Integer less than zero.
-  # 
-  
-  def_factory(
-    :NegativeInteger,
-    aliases: [ :neg_int, :negative_int, :negative_integer ],
-  ) do |name: 'ℤ⁻', **options|
-    intersection \
-      int,
-      bounded( max: -1 ),
-      name: name,
-      **options
-  end
-  
-  
-  # Non-Negative Integer
-  # --------------------
-  # 
-  # Positive integers and zero... but it seems more efficient to define these
-  # as bounded instead of a union.
-  # 
-  
-  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
-  
-  
-  # Non-Positive Integer
-  # --------------------
-  # 
-  # negative integers and zero.
-  # 
-  
-  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
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+
+# 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 string
+  float = Float string
+  int = float.to_i
+  if float == int then int else float end
+end
+
+
+# @!group Number Type Factories
+# ----------------------------------------------------------------------------
+
+# @!method self.Numeric **options
+#   The Ruby {Numeric} type, which is the super-class of all number classes:
+#   {Integer}, {Float}, {Rational}, {Complex}.
+#   
+#   In set theory notation this would either be expressed as either:
+#   
+#   1.  ℤ ∪ ℚ ∪ ℝ ∪ ℂ
+#   2.  ℂ
+#   
+#   depending on how you want to thing about the embeddability of the sets
+#   within each other (ℤ is embeddable in ℚ, which is embeddable in ℝ, which
+#   is embeddable in ℂ).
+#   
+#   However, I feel like (2) is not at all useful for expressing the type,
+#   and I feel like the default of just using the {Type#name} as the 
+#   {Type#symbolic} is easier to read than (1), so this type does not provide
+#   a `symbolic:` keyword argument.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#     A type whose members are all instances of Ruby's {Numeric} class.
+# 
+def_type    :Numeric,
+  aliases:  [ :num, :number, :numeric ],
+  # symbolic: [ INTEGERS,
+  #             RATIONALS,
+  #             REALS,
+  #             COMPLEXES ].join( " #{ UNION } " ),
+  from_s:   method( :parse_number ),
+&->( **options ) do
+  IsA.new Numeric, **options
+end
+
+
+# Integers
+# =====================================================================
+
+# @!method self.Integer **options
+#   Instances of the built-in {Integer} class.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type      :Integer,
+  symbolic:   'ℤ',
+  from_s:     method( :parse_number ),
+  aliases:  [ :int,
+              :integer,
+              :signed ],
+&->( **options ) do
+  IsA.new Integer, **options
+end
+
+
+# Bounded Integers
+# ---------------------------------------------------------------------
+
+# @!method self.PositiveInteger **options
+#   Integers greater than zero.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type      :PositiveInteger,
+  symbolic: 'ℤ⁺',
+  aliases:  [ :pos_int,
+              :positive_int ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    bounded( min: 1 ),
+    **options
+end
+
+
+# @!method self.NegativeInteger **options
+#   Integer less than zero.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type      :NegativeInteger,
+  symbolic:   'ℤ⁻',
+  aliases:  [ :neg_int,
+              :negative_int ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    self.Bounded( max: -1 ),
+    **options
+end
+
+
+# @!method self.NonNegativeInteger **options
+#   Positive integers and zero... but it seems more efficient to define these
+#   as bounded instead of a union.
+# 
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#
+def_type      :NonNegativeInteger,
+  symbolic:   'ℕ⁰',
+  aliases:  [ :non_neg_int,
+              :unsigned,
+              :index,
+              :non_negative_int, ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    self.Bounded( min: 0 ),
+    **options
+end
+
+
+# @!method self.NonPositiveInteger **options
+#   Negative integers and zero.
+# 
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#
+def_type      :NonPositiveInteger,
+  symbolic:   '{0}∪ℤ⁻',
+  aliases:  [ :non_pos_int,
+              :non_positive_int,
+              :non_positive_integer ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    self.Bounded( max: 0 ),
+    **options
+end
+
+
+# Etc...
+# ----------------------------------------------------------------------------
+
+#@!method self.Unsigned16BitInteger **options
+#   Unsigned 16-bit {Integer} type.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type      :Unsigned16BitInteger,
+  symbolic:   'uint16',
+  aliases:  [ :uint16,
+              :ushort ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    self.Bounded( min: 0, max: ((2 ** 16) - 1) ),
+    **options
+end
+
+
+#@!method self.UNIXPort **options
+#   A valid UNIX port number {Integer}, which is a 16-bit unsigned integer
+#   that can ot be `0`.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type      :UNIXPort,
+  aliases:  [ :port, ],
+&->( **options ) do
+  intersection \
+    self.Integer,
+    self.Bounded( min: 1, max: (2**16 - 1) ),
+    **options
+end
+
+# @!endgroup Number Type Factories # *****************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER