Module: Fear::Option

Included in:
Some
Defined in:
lib/fear/option.rb

Overview

Represents optional values. Instances of Option are either an instance of Some or the object None.

This allows for sophisticated chaining of Option values without having to check for the existence of a value.

Examples:

The most idiomatic way to use an Option instance is to treat it as a collection

name = Fear.option(params[:name])
upper = name.map(&:strip).select { |n| n.length != 0 }.map(&:upcase)
puts upper.get_or_else('')

A less-idiomatic way to use Option values is via pattern matching

Fear.option(params[:name]).match do |m|
  m.some { |name| name.strip.upcase }
  m.none { 'No name value' }
end

or manually checking for non emptiness

name = Fear.option(params[:name])
if name.empty?
  puts 'No name value'
else
  puts name.strip.upcase
end

See Also:

Defined Under Namespace

Modules: Mixin

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.match(value, &block) ⇒ Object 



191
192
193
 
# File 'lib/fear/option.rb', line 191

def match(value, &block)
  matcher(&block).(value)
end

.matcher {|| ... } ⇒ Fear::PartialFunction

Build pattern matcher to be used later, despite off Option#match method, it doesn’t apply matcher immanently, but build it instead. Usually in sake of efficiency it’s better to statically build matcher and reuse it later.

Examples:

matcher =
  Option.matcher do |m|
    m.some(Integer) { |x| x * 2 }
    m.some(String) { |x| x.to_i * 2 }
    m.none { 'NaN' }
    m.else { 'error '}
  end
matcher.call(Fear.some(42))

Yield Parameters:

Returns:



187
188
189
 
# File 'lib/fear/option.rb', line 187

def matcher(&matcher)
  OptionPatternMatch.new(&matcher)
end

Instance Method Details

#any? {|value| ... } ⇒ Boolean

Returns false if None or returns the result of the application of the given predicate to the Some value.

Examples:

Fear.some(12).any?( |v| v > 10)  #=> true
Fear.some(7).any?( |v| v > 10)   #=> false
Fear.none.any?( |v| v > 10)    #=> false

Yield Parameters:

  • value (any)

Yield Returns:

  • (Boolean)

Returns:

  • (Boolean) 


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#each {|value| ... } ⇒ Option

Performs the given block if this is a Some.

Examples:

Fear.some(17).each do |value|
  puts value
end #=> prints 17

Fear.none.each do |value|
  puts value
end #=> does nothing

Yield Parameters:

  • value (any)

Yield Returns:

  • (void)

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#empty? ⇒ Boolean

Returns true if the Option is None, false otherwise.

Examples:

Fear.some(42).empty? #=> false
Fear.none.empty?   #=> true

Returns:

  • (Boolean) 


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#flat_map {|value| ... } ⇒ Option

Returns the given block applied to the value from this Some or returns this if this is a None

Examples:

Fear.some(42).flat_map { |v| Fear.some(v/2) }   #=> Fear.some(21)
Fear.none.flat_map { |v| Fear.some(v/2) }     #=> None

Yield Parameters:

  • value (any)

Yield Returns:

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#get ⇒ any

Returns the Option‘s value.

Returns:

  • (any) —

    the Option‘s value.

Raises:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#get_or_else(&default) ⇒ any #get_or_else(default) ⇒ any

Returns the value from this Some or evaluates the given default argument if this is a None.

Overloads:

  • #get_or_else(&default) ⇒ any

    Examples:

    Fear.some(42).get_or_else { 24/2 } #=> 42
Fear.none.get_or_else { 24/2 }   #=> 12

    Yield Returns:

    • (any)

    Returns:

    • (any)
  • #get_or_else(default) ⇒ any

    Examples:

    Fear.some(42).get_or_else(12)  #=> 42
Fear.none.get_or_else(12)    #=> 12

    Returns:

    • (any) 


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#include?(other_value) ⇒ Boolean

Returns true if it has an element that is equal (as determined by ==) to other_value, false otherwise.

Examples:

Fear.some(17).include?(17) #=> true
Fear.some(17).include?(7)  #=> false
Fear.none.include?(17)   #=> false

Parameters:

  • (any)

Returns:

  • (Boolean) 


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#map {|value| ... } ⇒ Object

Maps the given block to the value from this Some or returns this if this is a None

Examples:

Fear.some(42).map { |v| v/2 } #=> Fear.some(21)
Fear.none.map { |v| v/2 }   #=> None

Yield Parameters:

  • value (any)

Yield Returns:

  • (any) 


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#match(&matcher) ⇒ Object

Pattern match against this Option

Examples:

Fear.option(val).match do |m|
  m.some(Integer) do |x|
   x * 2
  end

  m.some(String) do |x|
    x.to_i * 2
  end

  m.none { 'NaN' }
  m.else { 'error '}
end


158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#or_else(&alternative) ⇒ Option

Returns this Some or the given alternative if this is a None.

Examples:

Fear.some(42).or_else { Fear.some(21) } #=> Fear.some(42)
Fear.none.or_else { Fear.some(21) }   #=> Fear.some(21)
Fear.none.or_else { None }     #=> None

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#reject {|value| ... } ⇒ Option

Returns Some if applying the predicate to this Option‘s value returns false. Otherwise, return None.

Examples:

Fear.some(42).reject { |v| v > 40 } #=> None
Fear.some(42).reject { |v| v < 40 } #=> Fear.some(42)
Fear.none.reject { |v| v < 40 }   #=> None

Yield Parameters:

  • value (any)

Yield Returns:

  • (Boolean)

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end

#select {|value| ... } ⇒ Option

Returns self if it is nonempty and applying the predicate to this Option‘s value returns true. Otherwise, return None.

Examples:

Fear.some(42).select { |v| v > 40 } #=> Fear.success(21)
Fear.some(42).select { |v| v < 40 } #=> None
Fear.none.select { |v| v < 40 }   #=> None

Yield Parameters:

  • value (any)

Yield Returns:

  • (Boolean)

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fear/option.rb', line 158

module Option
  # @private
  def left_class
    NoneClass
  end

  # @private
  def right_class
    Some
  end

  class << self
    # Build pattern matcher to be used later, despite off
    # +Option#match+ method, it doesn't apply matcher immanently,
    # but build it instead. Usually in sake of efficiency it's better
    # to statically build matcher and reuse it later.
    #
    # @example
    #   matcher =
    #     Option.matcher do |m|
    #       m.some(Integer) { |x| x * 2 }
    #       m.some(String) { |x| x.to_i * 2 }
    #       m.none { 'NaN' }
    #       m.else { 'error '}
    #     end
    #   matcher.call(Fear.some(42))
    #
    # @yieldparam [OptionPatternMatch]
    # @return [Fear::PartialFunction]
    def matcher(&matcher)
      OptionPatternMatch.new(&matcher)
    end

    def match(value, &block)
      matcher(&block).(value)
    end
  end

  # Include this mixin to access convenient factory methods.
  # @example
  #   include Fear::Option::Mixin
  #
  #   Option(17) #=> #<Fear::Some get=17>
  #   Option(nil) #=> #<Fear::None>
  #   Some(17) #=> #<Fear::Some get=17>
  #   None() #=> #<Fear::None>
  #
  module Mixin
    # An +Option+ factory which creates +Some+ if the argument is
    # not +nil+, and +None+ if it is +nil+.
    # @param value [any]
    # @return [Fear::Some, Fear::None]
    #
    # @example
    #   Option(17) #=> #<Fear::Some get=17>
    #   Option(nil) #=> #<Fear::None>
    #
    def Option(value)
      Fear.option(value)
    end

    # @return [None]
    # @example
    #   None() #=> #<Fear::None>
    #
    def None
      Fear.none
    end

    # @param value [any] except nil
    # @return [Fear::Some]
    # @example
    #   Some(17) #=> #<Fear::Some get=17>
    #   Some(nil) #=> #<Fear::Some get=nil>
    #
    def Some(value)
      Fear.some(value)
    end
  end
end