Module: Dry::Types::Composition

Includes:
Builder, Meta, Options, Printable, Type
Included in:
Implication, Intersection, Sum
Defined in:
lib/dry/types/composition.rb

Defined Under Namespace

Modules: Constrained

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#left ⇒ Type (readonly)

Returns:



18
19
20
 
# File 'lib/dry/types/composition.rb', line 18

def left
  @left
end

#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:

#right ⇒ Type (readonly)

Returns:



21
22
23
 
# File 'lib/dry/types/composition.rb', line 21

def right
  @right
end

Class Method Details

.included(base) ⇒ Object 



33
34
35
36
37
38
39
 
# File 'lib/dry/types/composition.rb', line 33

def self.included(base)
  composition_name = Inflector.demodulize(base)
  ast_type = Inflector.underscore(composition_name).to_sym
  base.define_singleton_method(:ast_type) { ast_type }
  base.define_singleton_method(:composition_name) { composition_name }
  base.const_set("Constrained", Class.new(base) { include Constrained })
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, &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.

Parameters:

  • input (Object)

Returns:

  • (Object)

Raises:

  • (NotImplementedError) 


94
95
96
 
# File 'lib/dry/types/composition.rb', line 94

def call_safe(input, &block)
  raise NotImplementedError
end

#call_unsafe(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.

Parameters:

  • input (Object)

Returns:

  • (Object)

Raises:

  • (NotImplementedError) 


85
86
87
 
# File 'lib/dry/types/composition.rb', line 85

def call_unsafe(input)
  raise NotImplementedError
end

#constrained ⇒ Constrained Originally defined in module Builder

Turn a type into a constrained type

Parameters:

Returns:

#constrained? ⇒ false

Returns:

  • (false) 


69
70
71
 
# File 'lib/dry/types/composition.rb', line 69

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) 


62
63
64
 
# File 'lib/dry/types/composition.rb', line 62

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 = nil) ⇒ 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. 



116
117
118
119
120
121
122
123
 
# File 'lib/dry/types/composition.rb', line 116

def failure(input, _error = nil)
  result = try(input)
  if result.failure?
    result
  else
    raise ArgumentError, "Invalid failure value '#{input}' for #{inspect}"
  end
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:

#initialize(left, right, **options) ⇒ 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.

Parameters:



46
47
48
49
50
 
# File 'lib/dry/types/composition.rb', line 46

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

#lax ⇒ Lax Originally defined in module Builder

Turn a type into a lax type that will rescue from type-errors and return the original input

Returns:

#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) 


55
56
57
 
# File 'lib/dry/types/composition.rb', line 55

def name
  [left, right].map(&:name).join(" #{self.class.operator} ")
end

#optional ⇒ Sum Originally defined in module Builder

Turn a type into an optional type

Returns:

#optional? ⇒ Boolean

Returns:

  • (Boolean) 


76
77
78
 
# File 'lib/dry/types/composition.rb', line 76

def optional?
  false
end

#primitive?(value) ⇒ Boolean

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:

  • value (Object)

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


130
131
132
 
# File 'lib/dry/types/composition.rb', line 130

def primitive?(value)
  raise NotImplementedError
end

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

Resets meta

Returns:

#success(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. 



106
107
108
109
110
111
112
113
 
# File 'lib/dry/types/composition.rb', line 106

def success(input)
  result = try(input)
  if result.success?
    result
  else
    raise ArgumentError, "Invalid success value '#{input}' for #{inspect}"
  end
end

#to_ast(meta: true) ⇒ Object

See Also:



137
138
139
140
 
# File 'lib/dry/types/composition.rb', line 137

def to_ast(meta: true)
  [self.class.ast_type,
   [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
end

#to_proc ⇒ Proc

Wrap the type with a proc

Returns:

  • (Proc) 


147
148
149
 
# File 'lib/dry/types/composition.rb', line 147

def to_proc
  proc { |value| self.(value) }
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) ⇒ Object

Parameters:

  • input (Object)

Raises:

  • (NotImplementedError) 


101
102
103
 
# File 'lib/dry/types/composition.rb', line 101

def try(input)
  raise NotImplementedError
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: