nrser 0.3.9 → 0.3.10

data/lib/nrser/types/symbols.rb

@@ -1,36 +1,86 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Project / Package
+# -----------------------------------------------------------------------
+
 require_relative './is'
 require_relative './is_a'
 
-module NRSER::Types
-
-  def_factory(
-    :Symbol,
-    aliases: [ :sym, :symbol ],
-  ) do |from_s: :to_sym.to_proc, **options|
-    is_a \
-      ::Symbol,
-      from_s: from_s,
-      **options
-  end # sym
-  
-  
-  def_factory(
-    :EmptySymbol,
-    aliases: [ :empty_sym, :empty_symbol ],
-  ) do |name: 'EmptySymbol', **options|
-    is :'', name: name, **options
-  end
-  
-  
-  def_factory(
-    :NonEmptySymbol,
-    aliases: [ :non_empty_sym, :non_empty_symbol ],
-  ) do |name: 'NonEmptySymbol', **options|
-    intersection \
-      sym,
-      self.not( empty_sym ),
-      name: name,
-      **options
-  end
-  
-end # NRSER::Types
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+# @!group Symbol Type Factories
+# ----------------------------------------------------------------------------
+
+#@!method self.Symbol **options
+#   {Symbol} instances. Load from strings as you would expect {::String#to_sym}.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :Symbol,
+  aliases:      [ :sym ],
+  from_s:       :to_sym.to_proc,
+&->( **options ) do
+  self.IsA ::Symbol, **options
+end # .Symbol
+
+
+#@!method self.EmptySymbol **options
+#   Exactly `:''`.
+#   
+#   Pretty much just exists for use in {.NonEmptySymbol}, which pretty much
+#   just exists for use in {.Label}, which actually has some use ;)
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :EmptySymbol,
+  aliases:      [ :empty_sym ],
+  from_s:       :to_sym.to_proc,
+&->( **options ) do
+  self.Is :'', **options
+end # .EmptySymbol
+
+
+#@!method self.NonEmptySymbol **options
+#   A {Symbol} that is *not* `:''`.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :NonEmptySymbol,
+  aliases:      [ :non_empty_sym ],
+&->( **options ) do
+  self.Intersection \
+    self.Symbol,
+    ~self.EmptySymbol,
+    **options
+end # .NonEmptySymbol
+
+# @!endgroup Symbol Type Factories # *****************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER

data/lib/nrser/types/top.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
+require_relative './type'
+
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+# The top type is the universal type - all values are members.
+# 
+# @see https://en.wikipedia.org/wiki/Top_type
+# 
+class Top < NRSER::Types::Type
+  NAME = '*'
+
+  def initialize
+    super name: NAME
+  end
+
+  def test? value
+    true
+  end
+  
+  def explain
+    'Top'
+  end
+
+  def symbolic
+    '*' # '⊤'
+  end
+
+  def has_from_s?
+    true
+  end
+
+  def from_s string
+    string
+  end
+  
+
+  # {AnyType} instances are all equal.
+  # 
+  # @note
+  #   `other`'s class must be {AnyType} exactly - we make no assumptions
+  #   about anything that has subclasses {AnyType}.
+  # 
+  # @param [*] other
+  #   Object to compare to.
+  # 
+  # @return [Boolean]
+  #   `true` if `other#class` equals {AnyType}.
+  # 
+  def == other
+    other.class == Top
+  end
+  
+end # class Top
+
+# Anything at all...
+# 
+def_type(
+  :Top,
+  aliases: [ :everything, :all, :any ],
+) do
+  # Top type gets used as a default a lot, so cache it...
+  @_top_type_instance ||= Top.new
+end
+
+
+# /Namespace
+# ========================================================================
+
+end # module  Types
+end # module  NRSER

data/lib/nrser/types/tuples.rb

@@ -1,3 +1,7 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
 # Requirements
 # =======================================================================
 
@@ -6,112 +10,144 @@
 require_relative './arrays'
 
 
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
 # Definitions
-# =======================================================================
+# ========================================================================
 
-module NRSER::Types
+# Tuple type - array of fixed length and types (though those could be
+# {.Top}).
+# 
+# @note
+#   Construct {Tuple} types using the {.Tuple} factory.
+# 
+class Tuple < ArrayType
   
-  # Tuple type - array of fixed length and types (though those could be
-  # {NRSER::Types.any}).
+  # Attributes
+  # ======================================================================
+  
+  # The types of each of the tuple indexes.
   # 
-  class TupleType < NRSER::Types::ArrayType
-    
-    # Attributes
-    # ======================================================================
-    
-    # The types of each of the tuple indexes.
-    # 
-    # @return [Array<NRSER::Types::Type>]
-    #     
-    attr_reader :types
-    
-    
-    # Constructor
-    # ======================================================================
-    
-    # Instantiate a new `TupleType`.
-    # 
-    # @param [Array] *types
-    #   Tuple value types by their index in the tuples.
-    #   
-    #   Entries are passed through {NRSER::Types.make} to create the type
-    #   if needed.
-    # 
-    # @param [Hash<Symbol, *>] **options
-    #   Type options; see {NRSER::Types::Type#initialize}.
-    # 
-    def initialize *types, **options
-      super **options
-      @types = types.map( &NRSER::Types.method(:make) ).freeze
-    end # #initialize
-    
-    
-    # @return [String]
-    #   See {NRSER::Types::Type#explain}
-    # 
-    def explain
-      'Array<(' + @types.map( &:explain ).join( ', ' ) + ')>'
-    end
-    
-    
-    # Instance Methods
-    # ======================================================================
-    
-    # Test value for membership.
-    # 
-    # @param  (see NRSER::Types::Type#test?)
-    # @return (see NRSER::Types::Type#test?)
-    # @raise  (see NRSER::Types::Type#test?)
-    # 
-    def test? value
-      # Test the super class first
-      return false unless super( value )
-      
-      # If it's not the right length then it doesn't pass
-      return false unless value.length == @types.length
-      
-      # Test each item type
-      @types.each_with_index.all? { |type, index|
-        type.test value[index]
-      }
-    end # #test?
-    
-    
-    # @return [Boolean]
-    #   `true` if this type can load values from a string, which is true if
-    #   *all* it's types can load values from strings.
-    # 
-    def has_from_s?
-      @from_s || @types.all?( &:has_from_s? )
-    end # #has_from_s?
-    
+  # @return [Array<Type>]
+  #     
+  attr_reader :types
+  
+  
+  # Constructor
+  # ======================================================================
+  
+  # Instantiate a new `Tuple`.
+  # 
+  # @param [Array] types
+  #   Tuple value types by their index in the tuples.
+  #   
+  #   Entries are passed through {NRSER::Types.make} to create the type
+  #   if needed.
+  # 
+  # @param [Hash<Symbol, *>] options
+  #   Type options; see {Type#initialize}.
+  # 
+  def initialize *types, **options
+    super **options
+    @types = types.map( &NRSER::Types.method(:make) ).freeze
+  end # #initialize
+
+
+  def default_name
+    'Array<(' + types.map( &:name ).join( ', ' ) + ')>'
+  end
+
+
+  def default_symbolic
+    '[' + types.map( &:symbolic ).join( ', ' ) + ']'
+  end
+  
+  
+  # @return [String]
+  #   See {Type#explain}
+  # 
+  def explain
+    'Array<(' + types.map( &:explain ).join( ', ' ) + ')>'
+  end
+  
+  
+  # Instance Methods
+  # ======================================================================
+  
+  # Test value for membership.
+  # 
+  # @param  (see Type#test?)
+  # @return (see Type#test?)
+  # @raise  (see Type#test?)
+  # 
+  def test? value
+    # Test the super class first
+    return false unless super( value )
     
-    # Load each value in an array of strings split out by
-    # {NRSER::Types::ArrayType#from_s} by passing each value to `#from_s` in
-    # the type of the corresponding index.
-    # 
-    # @param [Array<String>] strings
-    # 
-    # @return [Array]
-    # 
-    def items_from_strings strings
-      @types.each_with_index.map { |type, index|
-        type.from_s strings[index]
-      }
-    end
+    # If it's not the right length then it doesn't pass
+    return false unless value.length == types.length
     
-  end # class TupleType
+    # Test each item type
+    types.each_with_index.all? { |type, index|
+      type.test value[index]
+    }
+  end # #test?
   
-
-  # Get a tuple type.
+  
+  # @return [Boolean]
+  #   `true` if this type can load values from a string, which is true if
+  #   *all* it's types can load values from strings.
+  # 
+  def has_from_s?
+    @from_s || types.all?( &:has_from_s? )
+  end # #has_from_s?
+  
+  
+  # Load each value in an array of strings split out by
+  # {ArrayType#from_s} by passing each value to `#from_s` in
+  # the type of the corresponding index.
   # 
-  # @param *types (see TupleType#initialize)
-  # @param **options (see TupleType#initialize)
+  # @param [Array<String>] strings
   # 
-  # @return [NRSER::Types::Type]
+  # @return [Array]
   # 
-  def_factory :tuple do |*types, **options|
-    TupleType.new *types, **options
-  end # .tuple
+  def items_from_strings strings
+    types.each_with_index.map { |type, index|
+      type.from_s strings[index]
+    }
+  end
   
-end # module NRSER::Types
+end # class Tuple
+
+
+#@!method self.Tuple *types, **options
+#   Get a {Tuple} type.
+#   
+#   @param [Array<TYPE>] types
+#     The types of the tuple values, in order they will appear. If entries are
+#     not {Type} instances, they will be {.make} into them.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Tuple]
+#   
+def_type        :Tuple,
+  default_name: false,
+  parameterize: :types,
+&->( *types, **options ) do
+  Tuple.new *types, **options
+end # .Tuple
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER