object Accumulation extends Accumulation
Companion object to trait Accumulation
that allows Accumulation
's members to be imported
rather than mixed in, and also contains nested traits used by implicit conversions declared in
trait Accumulations
.
For more information and examples, see the Accumulating errors with Or
section
of the main documentation for class Or
.
- Source
- Accumulation.scala
- Alphabetic
- By Inheritance
- Accumulation
- Accumulation
- AccumulationLowPriorityImplicits
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait Accumulatable[G, ERR, EVERY[b] <: Every[b]] extends AnyRef
Adds
zip
andwhen
methods toOr
s vai an implicit conversion provided by traitAccumulation
.Adds
zip
andwhen
methods toOr
s vai an implicit conversion provided by traitAccumulation
.For more information and examples, see the Using
zip
and Usingwhen
sections of the main documentation for classOr
. - trait Combinable[G, ERR, COLL[_]] extends AnyRef
Adds a
combined
method to “collections” of accumulatingOr
s via an implicit conversion provided by traitAccumulation
.Adds a
combined
method to “collections” of accumulatingOr
s via an implicit conversion provided by traitAccumulation
.For more information and examples, see the Using
combined
section of the main documentation for classOr
. - trait TravValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]] extends AnyRef
Adds a
validatedBy
method toGenTraversableOnce
via an implicit conversion provided by traitAccumulation
.Adds a
validatedBy
method toGenTraversableOnce
via an implicit conversion provided by traitAccumulation
.For more information and examples, see the Using
validatedBy
section of the main documentation for classOr
. - trait Validatable[G, COLL[_]] extends AnyRef
Adds a
validatedBy
method to (non-GenTraversableOnce
) “collections” via an implicit conversion provided by traitAccumulation
.Adds a
validatedBy
method to (non-GenTraversableOnce
) “collections” via an implicit conversion provided by traitAccumulation
.For more information and examples, see the Using
validatedBy
section of the main documentation for classOr
.
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- implicit def convertEveryToCombinable[G, ERR](oneToMany: Every[Or[G, Every[ERR]]]): Combinable[G, ERR, Every]
Implicitly converts an
Every
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts an
Every
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.For more information and examples, see the Using
combined
section of the main documentation for classOr
.- Definition Classes
- Accumulation
- implicit def convertEveryToValidatable[G](oneToMany: Every[G]): Validatable[G, Every]
Implicitly converts an
Every
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.Implicitly converts an
Every
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.For more information and examples, see the Using
validatedBy
section of the main documentation for classOr
.- Definition Classes
- Accumulation
- implicit def convertGenSetOnceToCombinable2[E, SET[e] <: GenSet[e]](xs: SET[Good[E]])(implicit cbf: CanBuildFrom[SET[Good[E]], Good[E], SET[Good[E]]]): Combinable[E, Nothing, SET]
Implicitly converts a
Set
containing accumulatingOr
s whoseGood
type is inferred asNothing
to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts a
Set
containing accumulatingOr
s whoseGood
type is inferred asNothing
to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Note: This implicit is required for
Set
s because althoughSet
s areGenTraversableOnce
s, they aren't covariant, so the implicit conversion provided byconvertGenTraversableOnceToCombinableNothing
will not be applied, because it only works on covariantGenTraversableOnce
s.- Definition Classes
- Accumulation
- implicit def convertGenSetOnceToCombinable3[E, SET[e] <: GenSet[e], EVERY[f] <: Every[f]](xs: SET[Bad[EVERY[E]]]): Combinable[Nothing, E, SET]
Implicitly converts a
Set
containing accumulatingOr
s whoseBad
type is inferred asNothing
to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts a
Set
containing accumulatingOr
s whoseBad
type is inferred asNothing
to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Note: This implicit is required for
Set
s because althoughSet
s areGenTraversableOnce
s, they aren't covariant, so the implicit conversion provided byconvertGenSetToCombinableNothing
will not be applied, because it only works on covariantGenTraversableOnce
s.- 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 accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts a
Set
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.For more information and examples, see the Using
combined
section of the main documentation for classOr
.Note: This implicit is required for
Set
s because althoughSet
s areGenTraversableOnce
s, they aren't covariant, so the implicit conversion provided byconvertGenTraversableOnceToCombinable
will not be applied, because it only works on covariantGenTraversableOnce
s.- 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 accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts a covariant
GenTraversableOnce
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.For more information and examples, see the Using
combined
section of the main documentation for classOr
.- Definition Classes
- AccumulationLowPriorityImplicits
- implicit def convertGenTraversableOnceToCombinable2[E, TRAVONCE[+e] <: Iterable[e]](xs: TRAVONCE[Good[E]])(implicit cbf: CanBuildFrom[TRAVONCE[Good[E]], Good[E], TRAVONCE[Good[E]]]): Combinable[E, Nothing, TRAVONCE]
- Definition Classes
- Accumulation
- implicit def convertGenTraversableOnceToCombinable3[E, TRAVONCE[+e] <: GenTraversableOnce[e]](xs: TRAVONCE[Bad[Every[E]]]): Combinable[Nothing, E, TRAVONCE]
- Definition Classes
- AccumulationLowPriorityImplicits
- implicit def convertGenTraversableOnceToValidatable[G, TRAVONCE[e] <: GenTraversableOnce[e]](xs: TRAVONCE[G]): TravValidatable[G, TRAVONCE]
Implicitly converts a
GenTraversableOnce
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.Implicitly converts a
GenTraversableOnce
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.For more information and examples, see the Using
validatedBy
section of the main documentation for classOr
.- Definition Classes
- Accumulation
- implicit def convertOptionToCombinable[G, ERR](option: Option[Or[G, Every[ERR]]]): Combinable[G, ERR, Option]
Implicitly converts an
Option
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.Implicitly converts an
Option
containing accumulatingOr
s to an instance ofCombinable
, which enables thecombined
method to be invoked on it.For more information and examples, see the Using
combined
section of the main documentation for classOr
.- Definition Classes
- Accumulation
- implicit def convertOptionToValidatable[G](option: Option[G]): Validatable[G, Option]
Implicitly converts an
Option
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.Implicitly converts an
Option
to an instance ofValidatable
, which enables thevalidatedBy
method to be invoked on it.For more information and examples, see the Using
validatedBy
section of the main documentation for classOr
.- 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 ofAccumulatable
, which enableszip
andwhen
methods to be invoked on it.Implicitly converts an accumulating
Or
to an instance ofAccumulatable
, which enableszip
andwhen
methods to be invoked on it.For more information and examples, see the Using
zip
and Usingwhen
sections of the main documentation for classOr
.- Definition Classes
- Accumulation
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- 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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 22
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 21
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 20
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 19
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 18
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 17
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 16
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 15
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 14
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 13
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 12
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 11
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 10
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 9
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 8
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 7
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 6
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 5
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 4
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 3
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
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
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).Given 2
Good
accumulatingOr
s, apply them to the given function and return the result, wrapped in aGood
; else return aBad
containing every error (i.e., aBad
whoseEvery
includes every value that appears in anyBad
s passed towithGood
).For more information and examples, see the Accumulating errors with
Or
section of the main documentation for classOr
.- returns
a
Good
result, if all passedOr
s wereGood
; else aBad
containing every error.
- Definition Classes
- Accumulation
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated