Accumulation

Type Members

trait Accumulatable[G, ERR, EVERY[b] <: Every[b]] extends AnyRef

Adds zip and when methods to Ors vai an implicit conversion provided by trait Accumulation.
trait Combinable[G, ERR, COLL[_]] extends AnyRef

Adds a combined method to “collections” of accumulating Ors via an implicit conversion provided by trait Accumulation.
trait TravValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]] extends AnyRef

Adds a validatedBy method to GenTraversableOnce via an implicit conversion provided by trait Accumulation.
trait Validatable[G, COLL[_]] extends AnyRef

Adds a validatedBy method to (non-GenTraversableOnce) “collections” via an implicit conversion provided by trait Accumulation.

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
implicit def convertEveryToCombinable[G, ERR](oneToMany: Every[Or[G, Every[ERR]]]): Combinable[G, ERR, Every]

Implicitly converts an Every containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
Implicitly converts an Every containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
For more information and examples, see the Using combined section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertEveryToValidatable[G](oneToMany: Every[G]): Validatable[G, Every]

Implicitly converts an Every to an instance of Validatable, which enables the validatedBy method to be invoked on it.
Implicitly converts an Every to an instance of Validatable, which enables the validatedBy method to be invoked on it.
For more information and examples, see the Using validatedBy section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertGenSetToCombinable[G, ERR, X, EVERY[b] <: Every[b], SET[e] <: GenSet[e]](xs: SET[X with Or[G, EVERY[ERR]]])(implicit cbf: CanBuildFrom[SET[X with Or[G, EVERY[ERR]]], G, SET[G]]): Combinable[G, ERR, SET]

Implicitly converts a Set containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
Implicitly converts a Set containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
For more information and examples, see the Using combined section of the main documentation for class Or.
Note: This implicit is required for Sets because although Sets are GenTraversableOnces, they aren't covariant, so the implicit conversion provided by convertGenTraversableOnceToCombinable will not be applied, because it only works on covariant GenTraversableOnces.

Definition Classes
Accumulation
implicit def convertGenTraversableOnceToCombinable[G, ERR, EVERY[b] <: Every[b], TRAVONCE[+e] <: GenTraversableOnce[e]](xs: TRAVONCE[Or[G, EVERY[ERR]]])(implicit cbf: CanBuildFrom[TRAVONCE[Or[G, EVERY[ERR]]], G, TRAVONCE[G]]): Combinable[G, ERR, TRAVONCE]

Implicitly converts a covariant GenTraversableOnce containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
Implicitly converts a covariant GenTraversableOnce containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
For more information and examples, see the Using combined section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertGenTraversableOnceToValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]](xs: TRAVONCE[G]): TravValidatable[G, TRAVONCE]

Implicitly converts a GenTraversableOnce to an instance of Validatable, which enables the validatedBy method to be invoked on it.
Implicitly converts a GenTraversableOnce to an instance of Validatable, which enables the validatedBy method to be invoked on it.
For more information and examples, see the Using validatedBy section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertOptionToCombinable[G, ERR](option: Option[Or[G, Every[ERR]]]): Combinable[G, ERR, Option]

Implicitly converts an Option containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
Implicitly converts an Option containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.
For more information and examples, see the Using combined section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertOptionToValidatable[G](option: Option[G]): Validatable[G, Option]

Implicitly converts an Option to an instance of Validatable, which enables the validatedBy method to be invoked on it.
Implicitly converts an Option to an instance of Validatable, which enables the validatedBy method to be invoked on it.
For more information and examples, see the Using validatedBy section of the main documentation for class Or.

Definition Classes
Accumulation
implicit def convertOrToAccumulatable[G, ERR, EVERY[b] <: Every[b]](accumulatable: Or[G, EVERY[ERR]]): Accumulatable[G, ERR, EVERY]

Implicitly converts an accumulating Or to an instance of Accumulatable, which enables zip and when methods to be invoked on it.
Implicitly converts an accumulating Or to an instance of Accumulatable, which enables zip and when methods to be invoked on it.
For more information and examples, see the Using zip and Using when sections of the main documentation for class Or.

Definition Classes
Accumulation
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()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
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
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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()
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]], r: Or[R, Every[ERR]], s: Or[S, Every[ERR]], t: Or[T, Every[ERR]], u: Or[U, Every[ERR]], v: Or[V, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 22 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 22 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]], r: Or[R, Every[ERR]], s: Or[S, Every[ERR]], t: Or[T, Every[ERR]], u: Or[U, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 21 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 21 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]], r: Or[R, Every[ERR]], s: Or[S, Every[ERR]], t: Or[T, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 20 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 20 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]], r: Or[R, Every[ERR]], s: Or[S, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 19 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 19 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]], r: Or[R, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 18 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 18 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]], q: Or[Q, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 17 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 17 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]], p: Or[P, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 16 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 16 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]], o: Or[O, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 15 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 15 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]], n: Or[N, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 14 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 14 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, M, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]], m: Or[M, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 13 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 13 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, L, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]], l: Or[L, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 12 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 12 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, K, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]], k: Or[K, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J, K) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 11 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 11 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, J, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]], j: Or[J, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I, J) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 10 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 10 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, I, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]], i: Or[I, Every[ERR]])(fn: (A, B, C, D, E, F, G, H, I) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 9 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 9 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, H, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]])(fn: (A, B, C, D, E, F, G, H) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 8 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 8 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, G, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]])(fn: (A, B, C, D, E, F, G) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 7 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 7 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, F, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]])(fn: (A, B, C, D, E, F) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 6 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 6 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, E, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]])(fn: (A, B, C, D, E) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 5 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 5 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, D, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]])(fn: (A, B, C, D) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 4 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 4 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, C, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]])(fn: (A, B, C) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 3 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 3 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, B, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]])(fn: (A, B) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given 2 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
Given 2 Good accumulating Ors, apply them to the given function and return the result, wrapped in a Good; else return a Bad containing every error (i.e., a Bad whose Every includes every value that appears in any Bads passed to withGood).
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.
returns
a Good result, if all passed Ors were Good; else a Bad containing every error.

Definition Classes
Accumulation
def withGood[A, ERR, RESULT](a: Or[A, Every[ERR]])(fn: (A) ⇒ RESULT): Or[RESULT, Every[ERR]]

Given a Good accumulating Or, apply it to the given function and return the result, wrapped in a Good; else return the given Bad.
Given a Good accumulating Or, apply it to the given function and return the result, wrapped in a Good; else return the given Bad.
For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.

Definition Classes
Accumulation

object Accumulation extends Accumulation

Type Members

trait Accumulatable[G, ERR, EVERY[b] <: Every[b]] extends AnyRef

trait Combinable[G, ERR, COLL[_]] extends AnyRef

trait TravValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]] extends AnyRef

trait Validatable[G, COLL[_]] extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def convertEveryToCombinable[G, ERR](oneToMany: Every[Or[G, Every[ERR]]]): Combinable[G, ERR, Every]

implicit def convertEveryToValidatable[G](oneToMany: Every[G]): Validatable[G, Every]

implicit def convertGenSetToCombinable[G, ERR, X, EVERY[b] <: Every[b], SET[e] <: GenSet[e]](xs: SET[X with Or[G, EVERY[ERR]]])(implicit cbf: CanBuildFrom[SET[X with Or[G, EVERY[ERR]]], G, SET[G]]): Combinable[G, ERR, SET]

implicit def convertGenTraversableOnceToCombinable[G, ERR, EVERY[b] <: Every[b], TRAVONCE[+e] <: GenTraversableOnce[e]](xs: TRAVONCE[Or[G, EVERY[ERR]]])(implicit cbf: CanBuildFrom[TRAVONCE[Or[G, EVERY[ERR]]], G, TRAVONCE[G]]): Combinable[G, ERR, TRAVONCE]

implicit def convertGenTraversableOnceToValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]](xs: TRAVONCE[G]): TravValidatable[G, TRAVONCE]

implicit def convertOptionToCombinable[G, ERR](option: Option[Or[G, Every[ERR]]]): Combinable[G, ERR, Option]

implicit def convertOptionToValidatable[G](option: Option[G]): Validatable[G, Option]

implicit def convertOrToAccumulatable[G, ERR, EVERY[b] <: Every[b]](accumulatable: Or[G, EVERY[ERR]]): Accumulatable[G, ERR, EVERY]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withGood[A, B, C, D, E, F, G, H, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]], h: Or[H, Every[ERR]])(fn: (A, B, C, D, E, F, G, H) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, C, D, E, F, G, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]], g: Or[G, Every[ERR]])(fn: (A, B, C, D, E, F, G) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, C, D, E, F, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]], f: Or[F, Every[ERR]])(fn: (A, B, C, D, E, F) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, C, D, E, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]], e: Or[E, Every[ERR]])(fn: (A, B, C, D, E) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, C, D, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]], d: Or[D, Every[ERR]])(fn: (A, B, C, D) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, C, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]], c: Or[C, Every[ERR]])(fn: (A, B, C) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, B, ERR, RESULT](a: Or[A, Every[ERR]], b: Or[B, Every[ERR]])(fn: (A, B) ⇒ RESULT): Or[RESULT, Every[ERR]]

def withGood[A, ERR, RESULT](a: Or[A, Every[ERR]])(fn: (A) ⇒ RESULT): Or[RESULT, Every[ERR]]

Inherited from Accumulation

Inherited from AnyRef

Inherited from Any

Ungrouped