nrser 0.1.4 → 0.2.0.pre.0

data/lib/nrser/types/hashes.rb

@@ -28,6 +28,10 @@ module NRSER::Types
         keys.test(k) && values.test(v)
       }
     end
+    
+    def default_name
+      "Hash{#{ @keys.name }=>#{ @values.name }}"
+    end
   end # HashType
   
   
@@ -43,7 +47,7 @@ module NRSER::Types
   # @return [NRSER::Types::Type]
   #   Newly constructed hash type from `args`.
   # 
-  def self.hash_type *args
+  def_factory :hash_type, aliases: [:dict, :hash_] do |*args|
     if args.empty?
       HASH
     else
@@ -51,9 +55,6 @@ module NRSER::Types
     end
   end
   
-  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/is.rb

@@ -23,6 +23,16 @@ module NRSER::Types
     def == other
       equal?(other) || @value === other.value
     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 ≡ #{ @value.inspect } }"
+    end
+    
+    alias_method :inspect, :to_s
   end # Is
   
   # an exact value (using ===)
@@ -30,4 +40,4 @@ module NRSER::Types
     Is.new value, **options
   end
   
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/is_a.rb

@@ -20,10 +20,12 @@ module NRSER::Types
       @klass = klass
     end
     
+    
     def default_name
-      "#{ self.class.short_name }(#{ @klass.name })"
+      @klass.name
     end
     
+    
     def test value
       value.is_a? @klass
     end
@@ -56,6 +58,13 @@ module NRSER::Types
       @from_data || @klass.respond_to?( :from_data )
     end
     
+    
+    def == other
+      equal?( other ) ||
+      ( self.class == other.class &&
+        self.klass == other.klass )
+    end
+    
   end # IsA
   
   
@@ -63,4 +72,4 @@ module NRSER::Types
   def self.is_a klass, **options
     IsA.new klass, **options
   end
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/maybe.rb

@@ -1,11 +1,10 @@
-require 'nrser/refinements'
 require 'nrser/types/combinators'
 
-using NRSER
-  
 module NRSER::Types
+    
   # nil or the argument type
-  def self.maybe type
-    union nil, type, name: "Maybe(#{ type.name })"
+  def self.maybe type, **options
+    union self.nil, type, name: "#{ type.name }?", **options
   end
+  
 end # NRSER::Types

data/lib/nrser/types/nil.rb

@@ -1,17 +1,8 @@
 require 'nrser/types/is'
   
 module NRSER::Types
-
-  NIL_TYPE = is(
-    nil,
-    name: 'NilType',
-    # from_s: ->( s ) {
-    #   
-    # }
-  ).freeze
-  
   # nothing
   def self.nil
-    NIL_TYPE
+    is nil, name: 'Nil'
   end
 end # NRSER::Types

data/lib/nrser/types/not.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
+# 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 default_name
+      "!#{ @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
+    Not.new type, **options
+  end
+  
+end # module NRSER::Types

data/lib/nrser/types/numbers.rb

@@ -94,14 +94,12 @@ module NRSER::Types
   # Integer less than zero.
   # 
   
-  NEG_INT = intersection(
-    INT,
-    bounded(max: -1),
-    name: 'NegIntType'
-  ).freeze
-  
   def self.neg_int
-    NEG_INT
+    intersection(
+      INT,
+      bounded(max: -1),
+      name: 'NegIntType'
+    ).freeze
   end
   
   
@@ -109,16 +107,23 @@ module NRSER::Types
   # --------------------
   # 
   # Positive integers and zero... but it seems more efficient to define these
-  # as bounded instead of a union. 
+  # as bounded instead of a union.
   # 
   
-  NON_NEG_INT = intersection INT, bounded(min: 0), name: 'NonNegIntType'
+  def self.natural **options
+    intersection INT, bounded(min: 0), name: 'ℕ', **options
+  end
   
-  def self.non_neg_int
-    NON_NEG_INT
+  singleton_class.send :alias_method, :non_neg_int, :natural
+  singleton_class.send :alias_method, :unsigned, :natural
+  
+  
+  def self.natural? **options
+    maybe non_neg_int, **options
   end
   
-  singleton_class.send :alias_method, :unsigned, :non_neg_int
+  singleton_class.send :alias_method, :non_neg_int?, :natural?
+  singleton_class.send :alias_method, :unsigned?, :natural?
   
   
   # Non-Positive Integer
@@ -127,10 +132,8 @@ module NRSER::Types
   # negative integers and zero.
   # 
   
-  NON_POS_INT = intersection INT, bounded(max: 0), name: 'NonPosIntType'
-  
-  def self.non_pos_int
-    NON_POS_INT
+  def self.non_pos_int **options
+    intersection INT, bounded(max: 0), name: 'NonPosIntType', **options
   end
    
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/shape.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+
+# Declarations
+# =======================================================================
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  class Shape < Type
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `NRSER::Types::Shape`.
+    def initialize pairs, **options
+      super **options
+      @pairs = pairs.map { |k, v|
+        [k, NRSER::Types.make( v )]
+      }.to_h
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    def test value
+      begin
+        @pairs.all? { |k, v|
+          v === value[k]
+        }
+      rescue
+        false
+      end
+    end
+    
+    def default_name
+      inner = @pairs.map { |k, v|
+        "[#{ k.inspect }]→#{ v.name }"
+      }.join( ", " )
+      
+      if @pairs.count == 1
+        inner
+      else
+        '(' + inner + ')'
+      end
+    end
+    
+  end # class Shape
+  
+  
+  def self.shape pairs, **options
+    Shape.new pairs, **options
+  end
+  
+end # module NRSER::Types

data/lib/nrser/types/strings.rb

@@ -2,73 +2,63 @@ require 'nrser/refinements'
 require 'nrser/types/is'
 require 'nrser/types/is_a'
 require 'nrser/types/attrs'
+require 'nrser/types/not'
 
 using NRSER
   
 module NRSER::Types
   
-  # Eigenclass (Singleton Class)
-  # ========================================================================
-  # 
-  class << self
-    # @!group Type Factory Functions
-    
-    def str length: nil, **options
-      if length.nil? && options.empty?
-        # if there are no options can point to the constant for efficiency
-        STR
-      else
-        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
-      end
-    end # string
-    
-    alias_method :string, :str
-    
-    
-    def empty_str
-      EMPTY_STR
-    end
-    
-    
-    def non_empty_str **options
-      return NON_EMPTY_STR if options.empty?
-      
-      str( length: {min: 1}, **options )
-    end # .non_empty_str
-    
-    
-    private
-    # ========================================================================
-      
-      
-      # @todo Document make_string_type method.
-      # 
-      # @param [type] arg_name
-      #   @todo Add name param description.
-      # 
-      # @return [return_type]
-      #   @todo Document return value.
-      # 
-      def make_string_type length: nil, match: nil
-        # method body...
-      end # #make_string_type
+  # @!group Type Factory Functions
+  
+  def self.str length: nil, encoding: nil, **options
+    if [length, encoding].all?( &:nil? )
+      IsA.new String, from_s: ->(s) { s }, **options
       
+    else
+      types = [str]
+      types << self.length( length ) if length
+      types << attrs( encoding: encoding ) if encoding
       
-    # end private
-    
-  end # class << self (Eigenclass)
+      intersection *types, **options
+    end
+  end # string
+  
+  singleton_class.send :alias_method, :string, :str
   
-  STR = str( name: 'StringType' ).freeze
   
-  EMPTY_STR = str( name: 'EmptyStringType', length: 0 ).freeze
+  # Get a {Type} only satisfied by empty strings.
+  # 
+  # @param [String] name: (default 'EmptyString')
+  # 
+ def_factory :empty_str do |name: 'EmptyString', **options|
+    str length: 0, name: name, **options
+  end
+  
+  
+ def_factory :non_empty_str do |**options|
+    str length: {min: 1}, **options
+  end
+  
+  
+ def_factory :char do |**options|
+    str length: 1, name: "Character", **options
+  end
+  
+  
+  # A type satisfied by UTF-8 encoded strings.
+  # 
+  # @param [String] name: (default 'UTF8String')
+  # 
+ def_factory :uft_8, aliases: [:utf8] do |name: 'UTF8String', **options|
+    str encoding: Encoding::UTF_8, name: name, **options
+  end
+  
   
-  NON_EMPTY_STR = non_empty_str( name: 'NonEmptyStr' ).freeze
+  def_factory(
+    :utf_8_char,
+    aliases: [:utf8_char]
+  ) do |name: 'UTF8Character', **options|
+    str length: 1, encoding: Encoding::UTF_8, name: name, **options
+  end
   
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/symbols.rb

@@ -8,32 +8,27 @@ using NRSER
 module NRSER::Types
 
   def self.sym **options
-    if options.empty?
-      # if there are no options can point to the constant for efficiency
-      SYM
-    else
-      IsA.new(
-        Symbol,
-        from_s: :to_sym.to_proc,
-        **options
-      )
-    end
+    IsA.new(
+      Symbol,
+      from_s: :to_sym.to_proc,
+      **options
+    )
   end # sym
   
   singleton_class.send :alias_method, :symbol, :sym
   
-  SYM = sym( name: 'SymType' ).freeze
+  
+  def self.empty_sym **options
+    is :'', name: 'EmptySymbol', **options
+  end
   
   
   def self.non_empty_sym **options
-    return NON_EMPTY_SYM if options.empty?
-    
     intersection \
-      SYM,
-      attrs( {to_s: non_empty_str} ),
+      sym,
+      self.not( empty_sym ),
+      name: 'NonEmptySymbol',
       **options
   end
   
-  NON_EMPTY_SYM = non_empty_sym( name: 'NonEmptySym' ).freeze
-  
-end # NRSER::Types
+end # NRSER::Types