org.scalautils

Accumulation

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
Linear Supertypes
Accumulation, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Accumulation
  2. Accumulation
  3. AnyRef
  4. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. 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.

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

    Adds a combined method to “collections” of accumulating Ors via an implicit conversion provided by trait Accumulation.

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

    Adds a validatedBy method to GenTraversableOnce via an implicit conversion provided by trait Accumulation.

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

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

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

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

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

    Definition Classes
    Any
  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  8. 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
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  18. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  19. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  20. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  21. final def isInstanceOf[T0]: Boolean

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

    Definition Classes
    AnyRef
  23. final def notify(): Unit

    Definition Classes
    AnyRef
  24. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  25. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  26. def toString(): String

    Definition Classes
    AnyRef → Any
  27. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()
  30. 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
  31. 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
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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
  43. 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
  44. 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
  45. 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. 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
  51. 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

Inherited from Accumulation

Inherited from AnyRef

Inherited from Any

Ungrouped