trait Accumulation extends AccumulationLowPriorityImplicits
Provides mechanisms that enable errors to be accumulated in “accumulating Or
s,” Or
s whose
Bad
type is an Every
.
The mechanisms are:
- Passing accumulating
Or
s towithGood
methods - Invoking
combined
on a container of accumulatingOr
s - Invoking
validatedBy
on a container of any type, passing in a function from that type to an accumulatingOr
- Invoking
zip
on an accumulatingOr
- Invoking
when
on an accumulatingOr
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
- AccumulationLowPriorityImplicits
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
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()
- 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
. - 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
. - 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. - 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. - 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. - 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]
- 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
. - 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
. - 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
. - 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
. - final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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(classOf[java.lang.InterruptedException])
- 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()
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.