Class: Literal::Some

Inherits:
Maybe show all
Defined in:
lib/literal/some.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Maybe

#call

Methods inherited from Monad

#handle

Constructor Details

#initialize(value) ⇒ Some

Returns a new instance of Some.



4
5
6
7
 
# File 'lib/literal/some.rb', line 4

def initialize(value)
	@value = value
	freeze
end

Instance Attribute Details

#value ⇒ Object

Returns the value of attribute value.



9
10
11
 
# File 'lib/literal/some.rb', line 9

def value
  @value
end

Instance Method Details

#==(other) ⇒ Object 



89
90
91
92
93
 
# File 'lib/literal/some.rb', line 89

def ==(other)
	return false unless Literal::Some === other

	@value == other.value
end

#bind {|@value| ... } ⇒ Object

Yields:



77
78
79
 
# File 'lib/literal/some.rb', line 77

def bind
	yield(@value)
end

#deconstruct ⇒ Object 



81
82
83
 
# File 'lib/literal/some.rb', line 81

def deconstruct
	[@value]
end

#deconstruct_keys(_) ⇒ Object 



85
86
87
 
# File 'lib/literal/some.rb', line 85

def deconstruct_keys(_)
	{ value: @value }
end

#empty? ⇒ false

Returns:

  • (false) 


15
 
# File 'lib/literal/some.rb', line 15

def empty? = false

#eql?(other) ⇒ Boolean

Returns:

  • (Boolean) 


95
96
97
98
99
 
# File 'lib/literal/some.rb', line 95

def eql?(other)
	return false unless Literal::Some === other

	@value.eql?(other.value)
end

#filter ⇒ Literal::Maybe

Returns:



32
33
34
 
# File 'lib/literal/some.rb', line 32

def filter
	yield(@value) ? self : Literal::Nothing
end

#fmap ⇒ Literal::Some

Returns:



71
72
73
74
75
 
# File 'lib/literal/some.rb', line 71

def fmap
	Literal::Some.new(
		yield(@value)
	)
end

#inspect ⇒ String

Returns:

  • (String) 


12
 
# File 'lib/literal/some.rb', line 12

def inspect = "Literal::Some(#{@value.inspect})"

#map(type = Literal::Null) ⇒ Literal::Maybe

Returns:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/literal/some.rb', line 37

def map(type = Literal::Null)
	output = yield(@value)

	if Literal::Null == type
		if nil == output
			Literal::Nothing
		else
			Literal::Some.new(output)
		end
	elsif type === output
		Literal::Some.new(output)
	else
		raise Literal::TypeError.expected(output, to_be_a: type)
	end
end

#nothing? ⇒ false

Returns:

  • (false) 


18
 
# File 'lib/literal/some.rb', line 18

def nothing? = false

#something? ⇒ true

Returns:

  • (true) 


21
 
# File 'lib/literal/some.rb', line 21

def something? = true

#then(type = Literal::Null) ⇒ Literal::Maybe

Returns:



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/literal/some.rb', line 54

def then(type = Literal::Null)
	output = yield(@value)

	if Literal::Null == type
		if Literal::Maybe === output
			output
		else
			raise Literal::TypeError.expected(output, to_be_a: Literal::Maybe)
		end
	elsif Literal::Maybe === output && type === output.value
		output
	else
		raise Literal::TypeError.expected(output, to_be_a: Literal::Maybe(type))
	end
end

#value_or ⇒ Object 



23
24
25
26
27
28
29
 
# File 'lib/literal/some.rb', line 23

def value_or
	if block_given?
		@value
	else
		raise Literal::ArgumentError, "no block given"
	end
end