specs2-fp
specs2-fp
org.specs2.fp
Applicative
Applicative
ApplicativeSyntax
ApplicativeOps
ListApplicativeOps
EitherIdOps
EitherObjectOps
EitherOps
EitherSyntax
Foldable
Foldable
FoldableSyntax
FoldableMonoidOps
FoldableOps
Functor
Functor
FunctorSyntax
FunctorOps
FunctorSyntax
LeftOps
Memo
Memo
Monad
Monad
MonadSyntax
MonadOps
Monoid
Monoid
Name
Name
NaturalTransformation
NaturalTransformation
Need
Need
RightOps
Semigroup
Semigroup
SemigroupSyntax
SemigroupOps
Show
Show
ShowSyntax
ShowOps
Traverse
Traversal
Traverse
TraverseSyntax
SequenceOps
TraverseOps
TraverseSyntax
Tree
Tree
Leaf
Node
TreeLoc
TreeLoc
Value
syntax
specs2-fp
/
org.specs2.fp
/
EitherOps
EitherOps
final
class
EitherOps
[
A
,
B
](
val
eab:
Either
[
A
,
B
])
extends
AnyVal
Graph
Supertypes
class
AnyVal
trait
Matchable
class
Any
Value members
Value members
Concrete methods
def
ap
[
AA
>:
A
,
BB
>:
B
,
C
](
that:
Either
[
AA
,
BB
=>
C
]):
Either
[
AA
,
C
]
final
def
append
[
AA
>:
A
,
BB
>:
B
](
that:
Either
[
AA
,
BB
])(
implicit
BB:
Semigroup
[
BB
]):
Either
[
AA
,
BB
]
def
bimap
[
C
,
D
](
fa:
A
=>
C
,
fb:
B
=>
D
):
Either
[
C
,
D
]
def
ensure
[
AA
>:
A
](
onFailure:
=>
AA
)(
f:
B
=>
Boolean
):
Either
[
AA
,
B
]
def
exists
(
f:
B
=>
Boolean
):
Boolean
def
flatMap
[
AA
>:
A
,
D
](
f:
B
=>
Either
[
AA
,
D
]):
Either
[
AA
,
D
]
def
foldLeft
[
C
](
c:
C
)(
f: (
C
,
B
)
=>
C
):
C
def
forall
(
f:
B
=>
Boolean
):
Boolean
def
foreach
(
f:
B
=>
Unit
):
Unit
def
getOrElse
[
BB
>:
B
](
default:
=>
BB
):
BB
def
leftMap
[
C
](
f:
A
=>
C
):
Either
[
C
,
B
]
def
map
[
C
](
f:
B
=>
C
):
Either
[
A
,
C
]
def
orElse
[
C
,
BB
>:
B
](
fallback:
=>
Either
[
C
,
BB
]):
Either
[
C
,
BB
]
def
recover
[
BB
>:
B
](
pf:
PartialFunction
[
A
,
BB
]):
Either
[
A
,
BB
]
def
recoverWith
[
AA
>:
A
,
BB
>:
B
](
pf:
PartialFunction
[
A
,
Either
[
AA
,
BB
]]):
Either
[
AA
,
BB
]
def
show
[
AA
>:
A
,
BB
>:
B
](
implicit
AA:
Show
[
AA
],
BB:
Show
[
BB
]):
String
def
toList
:
List
[
B
]
def
toOption
:
Option
[
B
]
def
toTry
(
implicit
ev:
A
<:<
Throwable
):
Try
[
B
]
def
traverse
[
F
[
_
],
AA
>:
A
,
D
](
f:
B
=>
F
[
D
])(
implicit
F:
Applicative
[
F
]):
F
[
Either
[
AA
,
D
]]
def
valueOr
[
BB
>:
B
](
f:
A
=>
BB
):
BB
Concrete fields
val
eab
:
Either
[
A
,
B
]