Class: Dry::Types::Nominal

Inherits:
Object
  • Object
show all
Includes:
Builder, Meta, Options, Printable, Type
Defined in:
lib/dry/types/nominal.rb

Overview

Nominal types define a primitive class and do not apply any constructors or constraints

Use these types for annotations and the base for building more complex types on top of them.

Direct Known Subclasses

AnyClass, Array, Constructor, Hash, Map

Constant Summary collapse

ALWAYS = 
proc { true }

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(primitive, **options) ⇒ Nominal

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of Nominal.

Parameters:

  • primitive (Type, Class)
  • options (Hash) 


42
43
44
45
46
 
# File 'lib/dry/types/nominal.rb', line 42

def initialize(primitive, **options)
  super
  @primitive = primitive
  freeze
end

Instance Attribute Details

#options ⇒ Hash (readonly) Originally defined in module Options

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

#primitive ⇒ Class (readonly)

Returns:

  • (Class) 


19
20
21
 
# File 'lib/dry/types/nominal.rb', line 19

def primitive
  @primitive
end

Class Method Details

.[](primitive) ⇒ Type

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • primitive (Class)

Returns:



26
27
28
29
30
31
32
33
34
 
# File 'lib/dry/types/nominal.rb', line 26

def self.[](primitive)
  if primitive == ::Array
    Types::Array
  elsif primitive == ::Hash
    Types::Hash
  else
    self
  end
end

Instance Method Details

#&(other) ⇒ Intersection, Intersection::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into an Intersection type

Parameters:

Returns:

#>(other) ⇒ Implication, Implication::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into an Implication type

Parameters:

Returns:

#call(input = Undefined) ⇒ Object #call(input = Undefined) {|output| ... } ⇒ Object Also known as: [] Originally defined in module Type

Apply type to a value

Overloads:

  • #call(input = Undefined) ⇒ Object

    Possibly unsafe coercion attempt. If a value doesn't match the type, an exception will be raised.

    Parameters:

    • input (Object) (defaults to: Undefined)

    Returns:

    • (Object)
  • #call(input = Undefined) {|output| ... } ⇒ Object

    When a block is passed, #call will never throw an exception on failed coercion, instead it will call the block.

    Parameters:

    • input (Object) (defaults to: Undefined)

    Yield Parameters:

    • output (Object) —

      Partially coerced value

    Returns:

    • (Object)

#call_safe(input) ⇒ BasicObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • input (BasicObject)

Returns:

  • (BasicObject) 


90
91
92
 
# File 'lib/dry/types/nominal.rb', line 90

def call_safe(input)
  input
end

#call_unsafe(input) ⇒ BasicObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • input (BasicObject)

Returns:

  • (BasicObject) 


81
82
83
 
# File 'lib/dry/types/nominal.rb', line 81

def call_unsafe(input)
  input
end

#coerce(input, &_block) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



139
140
141
142
143
144
145
146
147
 
# File 'lib/dry/types/nominal.rb', line 139

def coerce(input, &_block)
  if primitive?(input)
    input
  elsif block_given?
    yield
  else
    raise CoercionError, "#{input.inspect} must be an instance of #{primitive}"
  end
end

#constrained ⇒ Constrained Originally defined in module Builder

Turn a type into a constrained type

Parameters:

Returns:

#constrained? ⇒ false

Returns:

  • (false) 


65
66
67
 
# File 'lib/dry/types/nominal.rb', line 65

def constrained?
  false
end

#constrained_type ⇒ Class Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Class)

#constructor(constructor = nil, **options, &block) ⇒ Constructor Also known as: append, prepend, >>, << Originally defined in module Builder

Define a constructor for the type

Parameters:

  • constructor (#call, nil) (defaults to: nil)
  • options (Hash)
  • block (#call, nil)

Returns:

#constructor_type ⇒ Class Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Class)

#default(input = Undefined, options = EMPTY_HASH, &block) ⇒ Default Originally defined in module Builder

Turn a type into a type with a default value

Parameters:

  • input (Object) (defaults to: Undefined)
  • block (#call, nil)
  • [Boolean] (Hash) —

    a customizable set of options

Returns:

Raises:

#default? ⇒ false

Returns:

  • (false) 


58
59
60
 
# File 'lib/dry/types/nominal.rb', line 58

def default?
  false
end

#enum(*values) ⇒ Enum Originally defined in module Builder

Define an enum on top of the existing type

Parameters:

Returns:

#failure(input, error) ⇒ Result::Failure

Returns:

Raises:

  • (ArgumentError) 


121
122
123
124
125
 
# File 'lib/dry/types/nominal.rb', line 121

def failure(input, error)
  raise ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)

  Result::Failure.new(input, error)
end

#fallback(value = Undefined, shared: false, &_fallback) ⇒ Constructor Originally defined in module Builder

Use the given value on type mismatch

Parameters:

  • value (Object) (defaults to: Undefined)
  • fallback (#call, nil)
  • [Boolean] (Hash) —

    a customizable set of options

Returns:

#lax ⇒ Nominal

Return self. Nominal types are lax by definition

Returns:



181
182
183
 
# File 'lib/dry/types/nominal.rb', line 181

def lax
  self
end

#maybe ⇒ Maybe Originally defined in module Builder

Turn a type into a maybe type

Returns:

#meta ⇒ Hash #meta(data) ⇒ Type Originally defined in module Meta

Overloads:

  • #meta ⇒ Hash

    Returns metadata associated with type.

    Returns:

    • (Hash) —

      metadata associated with type

  • #meta(data) ⇒ Type

    Returns new type with added metadata.

    Parameters:

    • new (Hash) —

      metadata to merge into existing metadata

    Returns:

    • (Type) —

      new type with added metadata

#name ⇒ String

Returns:

  • (String) 


51
52
53
 
# File 'lib/dry/types/nominal.rb', line 51

def name
  primitive.name
end

#optional ⇒ Sum Originally defined in module Builder

Turn a type into an optional type

Returns:

#optional? ⇒ false

Returns:

  • (false) 


72
73
74
 
# File 'lib/dry/types/nominal.rb', line 72

def optional?
  false
end

#primitive?(value) ⇒ Boolean

Checks whether value is of a #primitive class

Parameters:

  • value (Object)

Returns:

  • (Boolean) 


134
135
136
 
# File 'lib/dry/types/nominal.rb', line 134

def primitive?(value)
  value.is_a?(primitive)
end

#pristine ⇒ Dry::Types::Type Originally defined in module Meta

Resets meta

Returns:

#success(input) ⇒ Result::Success

Returns:



112
113
114
 
# File 'lib/dry/types/nominal.rb', line 112

def success(input)
  Result::Success.new(input)
end

#to_ast(meta: true) ⇒ Array

Return AST representation of a type nominal

Returns:



172
173
174
 
# File 'lib/dry/types/nominal.rb', line 172

def to_ast(meta: true)
  [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
end

#to_proc ⇒ Proc

Wrap the type with a proc

Returns:

  • (Proc) 


190
191
192
 
# File 'lib/dry/types/nominal.rb', line 190

def to_proc
  ALWAYS
end

#to_s ⇒ String Also known as: inspect Originally defined in module Printable

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (String)

#try(input) {|failure| ... } ⇒ Result, ...

Parameters:

  • input (Object)

Yield Parameters:

  • failure (Failure)

Yield Returns:

Returns:

  • (Result, Logic::Result) —

    when a block is not provided

  • (nil) —

    otherwise



103
104
105
 
# File 'lib/dry/types/nominal.rb', line 103

def try(input)
  success(input)
end

#try_coerce(input) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/dry/types/nominal.rb', line 150

def try_coerce(input)
  result = success(input)

  coerce(input) do
    result = failure(
      input,
      CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
    )
  end

  if block_given?
    yield(result)
  else
    result
  end
end

#valid?(input = Undefined) ⇒ Boolean Also known as: === Originally defined in module Type

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Whether a value is a valid member of the type

Returns:

  • (Boolean)

#with(**options) ⇒ Type Originally defined in module Meta

Parameters:

  • options (Hash) —

    new_options

Returns:

#|(other) ⇒ Sum, Sum::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into a Sum type

Parameters:

Returns: