123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::Maybe

Overview

A Maybe encapsulates an optional value. A Maybe either contains a value of (represented as Just), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as exceptions.

Maybe is a replacement for the use of nil with better type checking.

For compatibility with Concern::Obligation the predicate and accessor methods are aliased as #fulfilled?, #rejected?, #value, and #reason.

Motivation

A common pattern in languages with pattern matching, such as Erlang and Haskell, is to return either a value or an error from a function Consider this Erlang code:

“‘erlang case file:consult(“data.dat”) of

{ok, Terms} -> do_something_useful(Terms);
{error, Reason} -> lager:error(Reason)

end. “‘

In this example the standard library function consult returns a tuple with two elements: an atom (similar to a ruby symbol) and a variable containing ancillary data. On success it returns the atom ok and the data from the file. On failure it returns error and a string with an explanation of the problem. With this pattern there is no ambiguity regarding success or failure. If the file is empty the return value cannot be misinterpreted as an error. And when an error occurs the return value provides useful information.

In Ruby we tend to return nil when an error occurs or else we raise an exception. Both of these idioms are problematic. Returning nil is ambiguous because nil may also be a valid value. It also lacks information pertaining to the nature of the error. Raising an exception is both expensive and usurps the normal flow of control. All of these problems can be solved with the use of a Maybe.

A Maybe is unambiguous with regard to whether or not it contains a value. When Just it contains a value, when Nothing it does not. When Just the value it contains may be nil, which is perfectly valid. When Nothing the reason for the lack of a value is contained as well. The previous Erlang example can be duplicated in Ruby in a principled way by having functions return Maybe objects:

“‘ruby result = MyFileUtils.consult(“data.dat”) # returns a Maybe if result.just?

do_something_useful(result.value)      # or result.just

else

logger.error(result.reason)            # or result.nothing

end “‘

Examples:

Returning a Maybe from a Function

module MyFileUtils
  def self.consult(path)
    file = File.open(path, 'r')
    Concurrent::Maybe.just(file.read)
  rescue => ex
    return Concurrent::Maybe.nothing(ex)
  ensure
    file.close if file
  end
end

maybe = MyFileUtils.consult('bogus.file')
maybe.just?    #=> false
maybe.nothing? #=> true
maybe.reason   #=> #<Errno::ENOENT: No such file or directory @ rb_sysopen - bogus.file>

maybe = MyFileUtils.consult('README.md')
maybe.just?    #=> true
maybe.nothing? #=> false
maybe.value    #=> "# Concurrent Ruby\n[![Gem Version..."

Using Maybe with a Block

result = Concurrent::Maybe.from do
  Client.find(10) # Client is an ActiveRecord model
end

# -- if the record was found
result.just? #=> true
result.value #=> #<Client id: 10, first_name: "Ryan">

# -- if the record was not found
result.just?  #=> false
result.reason #=> ActiveRecord::RecordNotFound

Using Maybe with the Null Object Pattern

# In a Rails controller...
result = ClientService.new(10).find    # returns a Maybe
render json: result.or(NullClient.new)

See Also:

Constant Summary

Class Attribute Summary

Synchronization::Object - Inherited

.safe_initialization?

Class Method Summary

Synchronization::Object - Inherited

.atomic_attribute?, .atomic_attributes,
.attr_atomic

Creates methods for reading and writing to a instance variable with volatile (Java) semantic as .attr_volatile does.
.attr_volatile

Creates methods for reading and writing (as attr_accessor does) to a instance variable with volatile (Java) semantic.
.ensure_safe_initialization_when_final_fields_are_present

For testing purposes, quite slow.
.new

Has to be called by children.
.safe_initialization!, .define_initialize_atomic_fields

Synchronization::AbstractObject - Inherited

.attr_volatile, .new

Instance Attribute Summary

Instance Method Summary

Synchronization::Object - Inherited

#__initialize_atomic_fields__

Synchronization::Volatile - Included

#full_memory_barrier

Synchronization::AbstractObject - Inherited

#full_memory_barrier

Constructor Details

.new(just, nothing) ⇒ Maybe (private)

Create a new Maybe with the given attributes.

Parameters:

  • just (Object) —

    The value when Just else NONE.

  • nothing (Exception, Object) —

    The exception when Nothing else NONE.

[ GitHub ] 

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 224



def initialize(just, nothing)
  @just = just
  @nothing = nothing
end


  







Class Method Details



  

    .from(*args) {|args| ... } ⇒ Maybe 
  



  

    

Create a new Maybe using the given block.



Runs the given block passing all function arguments to the block as block arguments. If the block runs to completion without raising an exception a new Just is created with the value set to the return value of the block. If the block raises an exception a new Nothing is created with the reason being set to the raised exception.


  





  
Parameters:


    
  
  • 
    args
    (Array<Object>)
—    
    

    Zero or more arguments to pass to the block.
    

    
  
    • 



Yields:


    
  
  • 
    
    
    

    The block from which to create a new Maybe.
    

    
  
    • 



Yield Parameters:


    
  
  • 
    args
    (Array<Object>)
—    
    

    Zero or more block arguments passed as arguments to the function.
    

    
  
    • 



Returns:


    
  
  • 
    (Maybe)
—    
    

    The newly created object.
    

    
  
    • 



Raises:


    
  
  • 
    (ArgumentError)
—    
    

    when no block given.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 137



def self.from(*args)
  raise ArgumentError.new('no block given') unless block_given?
  begin
    value = yield(*args)
    return new(value, NONE)
  rescue => ex
    return new(NONE, ex)
  end
end


  








  

    .just(value)  ⇒ Maybe 
  



  

    

Create a new Just with the given value.


  





  
Parameters:


    
  
  • 
    value
    (Object)
—    
    

    The value to set for the new Maybe object.
    

    
  
    • 



Returns:


    
  
  • 
    (Maybe)
—    
    

    The newly created object.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 152



def self.just(value)
  return new(value, NONE)
end


  








  

    .nothing(error = '')  ⇒ Maybe 
  



  

    

Create a new Nothing with the given (optional) reason.


  





  
Parameters:


    
  
  • 
    error
    (Exception)
    (defaults to: '')
—    
    

    The reason to set for the new Maybe object. When given a string a new StandardError will be created with the argument as the message. When no argument is given a new StandardError with an empty message will be created.
    

    
  
    • 



Returns:


    
  
  • 
    (Maybe)
—    
    

    The newly created object.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 164



def self.nothing(error = '')
  if error.is_a?(Exception)
    nothing = error
  else
    nothing = StandardError.new(error.to_s)
  end
  return new(NONE, nothing)
end


  







Instance Attribute Details



  

    #fulfilled?   (readonly)
  



  

    

Alias for #just?.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 179



alias :fulfilled? :just?


  








  

    #just   (readonly)
    Also known as: #value
  



  

    

The value of a Maybe when Just. Will be NONE when Nothing.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 114



attr_reader :just


  








  

    #just?  ⇒ Boolean  (readonly)
    Also known as: #fulfilled?
  



  

    

Is this Maybe a Just (successfully fulfilled with a value)?


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    True if Just or false if Nothing.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 176



def just?
  ! nothing?
end


  








  

    #nothing   (readonly)
    Also known as: #reason
  



  

    

The reason for the Maybe when Nothing. Will be NONE when Just.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 117



attr_reader :nothing


  








  

    #nothing?  ⇒ Boolean  (readonly)
    Also known as: #rejected?
  



  

    

Is this Maybe a .nothing (rejected with an exception upon fulfillment)?


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    True if Nothing or false if Just.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 184



def nothing?
  @nothing != NONE
end


  








  

    #reason   (readonly)
  



  

    

Alias for #nothing.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 191



alias :reason :nothing


  








  

    #rejected?   (readonly)
  



  

    

Alias for #nothing?.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 187



alias :rejected? :nothing?


  








  

    #value   (readonly)
  



  

    

Alias for #just.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 189



alias :value :just


  







Instance Method Details



  

    #<=>(other)  ⇒ Integer 
  



  

    

Comparison operator.


  





  
Returns:


    
  
  • 
    (Integer)
—    
    

    0 if self and other are both Nothing; -1 if self is Nothing and other is ‘Just`; 1 if self is Just and other is nothing; `self.just <=> other.just` if both self and other are Just.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 199



def <=>(other)
  if nothing?
    other.nothing? ? 0 : -1
  else
    other.nothing? ? 1 : just <=> other.just
  end
end


  








  

    #or(other)  ⇒ Object 
  



  

    

Return either the value of self or the given default value.


  





  
Returns:


    
  
  • 
    (Object)
—    
    

    The value of self when Just; else the given default.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/maybe.rb', line 210



def or(other)
  just? ? just : other
end