Class: Dry::Types::Sum

Inherits:

Object

• Object
• Dry::Types::Sum

Includes:

Composition

Defined in:

lib/dry/types/sum.rb

Overview

Sum type

Instance Attribute Summary

• #left ⇒ Type included from Composition readonly
• #options ⇒ Hash included from Options readonly private
• #right ⇒ Type included from Composition readonly

Class Method Summary

• .operator ⇒ Object

Instance Method Summary

• #&(other) ⇒ Intersection, Intersection::Constrained included from Builder private

  Compose two types into an Intersection type.

• #>(other) ⇒ Implication, Implication::Constrained included from Builder private

  Compose two types into an Implication type.

• #call(input = Undefined, &block) ⇒ Object (also: #[]) included from Type

  Apply type to a value.

• #call_safe(input, &block) ⇒ Object private
• #call_unsafe(input) ⇒ Object private
• #constrained ⇒ Constrained, Sum
• #constrained? ⇒ false included from Composition
• #constrained_type ⇒ Class included from Builder private
• #constructor(constructor = nil, **options, &block) ⇒ Constructor (also: #append, #prepend, #>>, #<<) included from Builder

  Define a constructor for the type.

• #constructor_type ⇒ Class included from Builder private
• #default(input = Undefined, options = EMPTY_HASH, &block) ⇒ Default included from Builder

  Turn a type into a type with a default value.

• #default? ⇒ false included from Composition
• #enum(*values) ⇒ Enum included from Builder

  Define an enum on top of the existing type.

• #failure(input, _error = nil) ⇒ Object included from Composition private
• #fallback(value = Undefined, shared: false, &_fallback) ⇒ Constructor included from Builder

  Use the given value on type mismatch.

• #initialize(left, right, **options) ⇒ Object included from Composition private
• #lax ⇒ Lax included from Builder

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

• #maybe ⇒ Maybe included from Builder

  Turn a type into a maybe type.

• #meta(data = Undefined) ⇒ Object

  Manage metadata to the type.

• #name ⇒ String included from Composition
• #optional ⇒ Sum included from Builder

  Turn a type into an optional type.

• #optional? ⇒ Boolean
• #primitive?(value) ⇒ Boolean private
• #pristine ⇒ Dry::Types::Type included from Meta

  Resets meta.

• #success(input) ⇒ Object included from Composition private
• #to_ast(meta: true) ⇒ Object included from Composition
• #to_proc ⇒ Proc included from Composition

  Wrap the type with a proc.

• #to_s ⇒ String (also: #inspect) included from Printable private
• #try(input) ⇒ Object
• #valid?(input = Undefined) ⇒ Boolean (also: #===) included from Type private

  Whether a value is a valid member of the type.

• #with(**options) ⇒ Type included from Meta
• #|(other) ⇒ Sum, Sum::Constrained included from Builder private

  Compose two types into a Sum type.

Instance Attribute Details

#left ⇒ Type (readonly) Originally defined in module Composition

Returns:

• (Type)

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

• (Hash)

#right ⇒ Type (readonly) Originally defined in module Composition

Returns:

• (Type)

Class Method Details

.operator ⇒ Object

# File 'lib/dry/types/sum.rb', line 11

def self.operator
  :|
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:

• other (Type)

Returns:

• (Intersection, Intersection::Constrained)

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

• other (Type)

Returns:

• (Implication, Implication::Constrained)

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

# File 'lib/dry/types/sum.rb', line 36

def call_safe(input, &block)
  left.call_safe(input) { right.call_safe(input, &block) }
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)

# File 'lib/dry/types/sum.rb', line 27

def call_unsafe(input)
  left.call_safe(input) { right.call_unsafe(input) }
end

#constrained ⇒ Constrained, Sum

Parameters:

• options (Hash)

Returns:

• (Constrained, Sum)

See Also:

• Builder#constrained

# File 'lib/dry/types/sum.rb', line 87

def constrained(...)
  if optional?
    right.constrained(...).optional
  else
    super
  end
end

#constrained? ⇒ false Originally defined in module Composition

Returns:

• (false)

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

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

• (Default)

Raises:

• (ConstraintError)

#default? ⇒ false Originally defined in module Composition

Returns:

• (false)

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

Define an enum on top of the existing type

Parameters:

• values (Array)

Returns:

• (Enum)

#failure(input, _error = nil) ⇒ Object Originally defined in module Composition

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.

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

• (Constructor)

#initialize(left, right, **options) ⇒ Object Originally defined in module Composition

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:

• left (Type)
• right (Type)
• options (Hash)

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

• (Lax)

#maybe ⇒ Maybe Originally defined in module Builder

Turn a type into a maybe type

Returns:

• (Maybe)

#meta(data = Undefined) ⇒ Object

Manage metadata to the type. If the type is an optional, #meta delegates to the right branch

See Also:

• Dry::Types::Sum.[Meta[Meta#meta]

# File 'lib/dry/types/sum.rb', line 70

def meta(data = Undefined)
  if Undefined.equal?(data)
    optional? ? right.meta : super
  elsif optional?
    self.class.new(left, right.meta(data), **options)
  else
    super
  end
end

#name ⇒ String Originally defined in module Composition

Returns:

• (String)

#optional ⇒ Sum Originally defined in module Builder

Turn a type into an optional type

Returns:

• (Sum)

#optional? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/dry/types/sum.rb', line 18

def optional?
  primitive?(nil)
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)

# File 'lib/dry/types/sum.rb', line 60

def primitive?(value)
  left.primitive?(value) || right.primitive?(value)
end

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

Resets meta

Returns:

• (Dry::Types::Type)

#success(input) ⇒ Object Originally defined in module Composition

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.

#to_ast(meta: true) ⇒ Object Originally defined in module Composition

See Also:

• Nominal#to_ast

#to_proc ⇒ Proc Originally defined in module Composition

Wrap the type with a proc

Returns:

• (Proc)

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

# File 'lib/dry/types/sum.rb', line 43

def try(input)
  left.try(input) do
    right.try(input) do |failure|
      if block_given?
        yield(failure)
      else
        failure
      end
    end
  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:

• (Type)

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

• other (Type)

Returns:

• (Sum, Sum::Constrained)