Result

Type Members

class Ap2[X, A, B] extends AnyRef
final class FromTryCatchAux[T >: Null <: Throwable, R] extends AnyRef
sealed trait I[E] extends AnyRef

Curried Result type, starting with the invalid part.
Curried Result type, starting with the invalid part.
This can be used to avoid type lambas:
```
// instead of
type FR[+E] = Functor[({type ￎﾻ[ￎﾱ] = Result[E, ￎﾱ]})#ￎﾻ]
// rather use
type FR[+E] = Functor[Result.I[E]#V]
```
E
the resulting invalid type
final case class Invalid[+E](error: E) extends Result[E, Nothing] with Product with Serializable
final case class Invalids[+E](error: NonEmptyVector[E]) extends Result[E, Nothing] with Product with Serializable
sealed trait V[A] extends AnyRef

Curried Result type, starting with the valid part.
Curried Result type, starting with the valid part.
This can be used to avoid type lambas:
```
// instead of
type FR[+A] = Functor[({type ￎﾻ[ￎﾱ] = Result[ￎﾱ, A]})#ￎﾻ]
// rather use
type FR[+A] = Functor[Result.V[A]#I]
```
A
the resulting valid type
final case class Valid[+A](value: A) extends Result[Nothing, A] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object all
final def asInstanceOf[T0]: T0

Definition Classes
Any
def catching[T >: Null <: Throwable](implicit arg0: ClassTag[T]): FromTryCatchAux[T, T]

T
returns
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cond[E, A](p: Boolean, ifTrue: ⇒ A, ifFalse: ⇒ E): Result[E, A]

E
A
p
ifTrue
ifFalse
returns
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fromEither[E, A](x: Either[E, A]): Result[E, A]

E
A
x
returns
def fromOption[E, A](x: Option[A], ifNone: ⇒ E): Result[E, A]

E
A
x
ifNone
returns
def fromTry[A](x: Try[A]): Result[Throwable, A]

A
x
returns
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def invalid[E, A](e: E): Result[E, A]

E
A
e
returns
def invalids[E, A](es: NonEmptyVector[E]): Result[E, A]

E
A
es
returns
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def parseByte(s: String): Result[NumberFormatException, Byte]

s
returns
def parseDouble(s: String): Result[NumberFormatException, Double]

s
returns
def parseFloat(s: String): Result[NumberFormatException, Float]

s
returns
def parseInt(s: String): Result[NumberFormatException, Int]

s
returns
def parseLong(s: String): Result[NumberFormatException, Long]

s
returns
def parseShort(s: String): Result[NumberFormatException, Short]

s
returns
def sequence[A, E](xs: Seq[Result[E, A]]): Result[E, Seq[A]]

[use case] Transforms a sequence of Results into a Result of a sequence.
[use case]
Transforms a sequence of Results into a Result of a sequence.
A
the resulting valid type
E
the resulting invalid type
xs
a collection of results
returns
A Result with all valid values or all invalid ones

Full Signature
def sequence[A, E, F[X] <: TraversableOnce[X]](xs: F[Result[E, A]])(implicit cbf: CanBuildFrom[F[Result[E, A]], A, F[A]]): Result[E, F[A]]
object symbolic
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
object syntax
def toString(): String

Definition Classes
AnyRef → Any
def traverse[A, B, E](xs: Seq[A])(f: (A) ⇒ Result[E, B]): Result[E, Seq[B]]

[use case] Traverses over xs and accumulates all results.
[use case]
Traverses over xs and accumulates all results.
A
the collection type
B
the resulting valid type
E
the resulting invalid type
xs
a collection of values
f
function to validate a single value
returns
A Result with all valid values or all invalid ones

Full Signature
def traverse[A, B, E, F[X] <: TraversableOnce[X], That](xs: F[A])(f: (A) ⇒ Result[E, B])(implicit cbf: CanBuildFrom[F[A], B, That]): Result[E, That]
def traverse_[A, E](xs: TraversableOnce[A])(f: (A) ⇒ Result[E, Unit]): Result[E, Unit]

Traverses over xs accumulating all invalids but discarding all valid values.
Traverses over xs accumulating all invalids but discarding all valid values.
A
the collection type
E
the resulting invalid type
xs
a collection of values
f
function to validate a single value
returns
A Result with all invalid values or Unit

Since
0.2.0
object unsafe
def valid[E, A](x: A): Result[E, A]

E
A
x
returns
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait Result | package validation

object Result extends Serializable

Type Members

class Ap2[X, A, B] extends AnyRef

final class FromTryCatchAux[T >: Null <: Throwable, R] extends AnyRef

sealed trait I[E] extends AnyRef

final case class Invalid[+E](error: E) extends Result[E, Nothing] with Product with Serializable

final case class Invalids[+E](error: NonEmptyVector[E]) extends Result[E, Nothing] with Product with Serializable

sealed trait V[A] extends AnyRef

final case class Valid[+A](value: A) extends Result[Nothing, A] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object all

final def asInstanceOf[T0]: T0

def catching[T >: Null <: Throwable](implicit arg0: ClassTag[T]): FromTryCatchAux[T, T]

def clone(): AnyRef

def cond[E, A](p: Boolean, ifTrue: ⇒ A, ifFalse: ⇒ E): Result[E, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fromEither[E, A](x: Either[E, A]): Result[E, A]

def fromOption[E, A](x: Option[A], ifNone: ⇒ E): Result[E, A]

def fromTry[A](x: Try[A]): Result[Throwable, A]

final def getClass(): Class[_]

def hashCode(): Int

def invalid[E, A](e: E): Result[E, A]

def invalids[E, A](es: NonEmptyVector[E]): Result[E, A]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parseByte(s: String): Result[NumberFormatException, Byte]

def parseDouble(s: String): Result[NumberFormatException, Double]

def parseFloat(s: String): Result[NumberFormatException, Float]

def parseInt(s: String): Result[NumberFormatException, Int]

def parseLong(s: String): Result[NumberFormatException, Long]

def parseShort(s: String): Result[NumberFormatException, Short]

def sequence[A, E](xs: Seq[Result[E, A]]): Result[E, Seq[A]]

def sequence[A, E, F[X] <: TraversableOnce[X]](xs: F[Result[E, A]])(implicit cbf: CanBuildFrom[F[Result[E, A]], A, F[A]]): Result[E, F[A]]

object symbolic

final def synchronized[T0](arg0: ⇒ T0): T0

object syntax

def toString(): String

def traverse[A, B, E](xs: Seq[A])(f: (A) ⇒ Result[E, B]): Result[E, Seq[B]]

def traverse[A, B, E, F[X] <: TraversableOnce[X], That](xs: F[A])(f: (A) ⇒ Result[E, B])(implicit cbf: CanBuildFrom[F[A], B, That]): Result[E, That]

def traverse_[A, E](xs: TraversableOnce[A])(f: (A) ⇒ Result[E, Unit]): Result[E, Unit]

object unsafe

def valid[E, A](x: A): Result[E, A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Factories and Constructors

Combinators

Ungrouped