Scalactic 3.3.0-alpha.1
API
Generated with
Scalactic 3.3.0-alpha.1/org.scalactic/Accumulation

Accumulation

org.scalactic.Accumulation
See theAccumulation companion object
trait Accumulation extends AccumulationLowPriorityImplicits

Provides mechanisms that enable errors to be accumulated in “accumulating Ors,” Ors whose Bad type is an Every.

The mechanisms are:

  • Passing accumulating Ors to withGood methods

  • Invoking combined on a container of accumulating Ors

  • Invoking validatedBy on a container of any type, passing in a function from that type to an accumulating Or

  • Invoking zip on an accumulating Or

  • Invoking when on an accumulating Or

For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.

Attributes

Companion
object
Source
Accumulation.scala
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Accumulation.type

Members list

Value members

Concrete methods

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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala
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.

Attributes

Returns

a Good result, if all passed Ors were Good; else a Bad containing every error.

Source
Accumulation.scala

Implicits

Implicits

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.

Attributes

Source
Accumulation.scala
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.

Attributes

Source
Accumulation.scala
implicit def convertGenSetOnceToCombinable2[E, SET <: (Set)](xs: SET[Good[E]])(implicit cbf: BuildFrom[SET[Good[E]], Good[E], SET[Good[E]]]): Combinable[E, Nothing, SET]

Implicitly converts a Set containing accumulating Ors whose Good type is inferred as Nothing to an instance of Combinable, which enables the combined method to be invoked on it.

Implicitly converts a Set containing accumulating Ors whose Good type is inferred as Nothing to an instance of Combinable, which enables the combined method to be invoked on it.

Note: This implicit is required for Sets because although Sets are IterableOnces, they aren't covariant, so the implicit conversion provided by convertIterableOnceToCombinableNothing will not be applied, because it only works on covariant IterableOnces.

Attributes

Source
Accumulation.scala
implicit def convertGenSetOnceToCombinable3[E, SET <: (Set), EVERY <: (Every)](xs: SET[Bad[EVERY[E]]]): Combinable[Nothing, E, SET]

Implicitly converts a Set containing accumulating Ors whose Bad type is inferred as Nothing to an instance of Combinable, which enables the combined method to be invoked on it.

Implicitly converts a Set containing accumulating Ors whose Bad type is inferred as Nothing to an instance of Combinable, which enables the combined method to be invoked on it.

Note: This implicit is required for Sets because although Sets are IterableOnces, they aren't covariant, so the implicit conversion provided by convertGenSetToCombinableNothing will not be applied, because it only works on covariant IterableOnces.

Attributes

Source
Accumulation.scala
implicit def convertGenSetToCombinable[G, ERR, X, EVERY <: (Every), SET <: (Set)](xs: SET[X & Or[G, EVERY[ERR]]])(implicit cbf: BuildFrom[SET[X & 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 IterableOnces, they aren't covariant, so the implicit conversion provided by convertIterableOnceToCombinable will not be applied, because it only works on covariant IterableOnces.

Attributes

Source
Accumulation.scala
implicit def convertIterableOnceToCombinable2[E, ITRONCE <: (Iterable)](xs: ITRONCE[Good[E]])(implicit cbf: BuildFrom[ITRONCE[Good[E]], Good[E], ITRONCE[Good[E]]]): Combinable[E, Nothing, ITRONCE]

Attributes

Source
Accumulation.scala
implicit def convertIterableOnceToValidatable[G, ITRONCE <: (IterableOnce)](xs: ITRONCE[G]): TravValidatable[G, ITRONCE]

Implicitly converts a IterableOnce to an instance of Validatable, which enables the validatedBy method to be invoked on it.

Implicitly converts a IterableOnce 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.

Attributes

Source
Accumulation.scala
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.

Attributes

Source
Accumulation.scala
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.

Attributes

Source
Accumulation.scala
implicit def convertOrToAccumulatable[G, ERR, EVERY <: (Every)](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.

Attributes

Source
Accumulation.scala

Inherited implicits

implicit def convertIterableOnceToCombinable[G, ERR, EVERY <: (Every), ITRONCE <: (IterableOnce)](xs: ITRONCE[Or[G, EVERY[ERR]]])(implicit cbf: BuildFrom[ITRONCE[Or[G, EVERY[ERR]]], G, ITRONCE[G]]): Combinable[G, ERR, ITRONCE]

Implicitly converts a covariant IterableOnce containing accumulating Ors to an instance of Combinable, which enables the combined method to be invoked on it.

Implicitly converts a covariant IterableOnce 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.

Attributes

Inherited from:
AccumulationLowPriorityImplicits
Source
Accumulation.scala
implicit def convertIterableOnceToCombinable3[E, ITRONCE <: (IterableOnce)](xs: ITRONCE[Bad[Every[E]]]): Combinable[Nothing, E, ITRONCE]

Attributes

Inherited from:
AccumulationLowPriorityImplicits
Source
Accumulation.scala
Generated with