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

Attributes included from Options

#options

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Printable

#to_s

Methods included from Builder

#&, #>, #constrained, #constrained_type, #constructor, #constructor_type, #default, #enum, #fallback, #maybe, #optional, #|

Methods included from Meta

#meta, #pristine, #with

Methods included from Options

#with

Methods included from Type

#call, #valid?

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

#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

#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? ⇒ false

Returns:

  • (false) 


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

def constrained?
  false
end

#default? ⇒ false

Returns:

  • (false) 


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

def default?
  false
end

#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

#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

#name ⇒ String

Returns:

  • (String) 


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

def name
  primitive.name
end

#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

#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

#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