ZPure

abstract def tag: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def &&&[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, (A, B)]

A symbolic alias for zip.

final def ***[W1 >: W, S3, R1, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, (R, R1), E1, (A, B)]

Splits the environment, providing the first part to this computation and the second part to that computation.

final def *>[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, B]

A symbolic alias for zipRight.

final def +++[W1 >: W, S0 <: S1, S3 >: S2, R1, B, E1 >: E](that: ZPure[W1, S0, S3, R1, E1, B]): ZPure[W1, S0, S3, Either[R, R1], E1, Either[A, B]]

Runs this computation if the provided environment is a Left or else runs that computation if the provided environment is a Right, returning the result in an Either.

final def <*[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, A]

A symbolic alias for zipLeft.

final def <*>[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, (A, B)]

A symbolic alias for zip.

final def <+>[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, B](that: ⇒ ZPure[W1, S0, S3, R1, E1, B])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, Either[A, B]]

A symbolic alias for orElseEither.

final def <<<[W1 >: W, S0, R0, E1 >: E](that: ZPure[W1, S0, S1, R0, E1, R]): ZPure[W1, S0, S2, R0, E1, A]

A symbolic alias for compose.

final def <>[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, A1 >: A](that: ⇒ ZPure[W1, S0, S3, R1, E1, A1])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, A1]

A symbolic alias for orElse.

final def ==(arg0: Any): Boolean

final def >>=[W1 >: W, S3, R1 <: R, E1 >: E, B](f: (A) ⇒ ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, B]

A symbolic alias for flatMap.

final def >>>[W1 >: W, S3, E1 >: E, B](that: ZPure[W1, S2, S3, A, E1, B]): ZPure[W1, S1, S3, R, E1, B]

A symbolic alias for andThen.

final def ??[W1 >: W](w: W1): ZPure[W1, S1, S2, R, E, A]

A symbolic alias for log.

final def absolve[E1 >: E, B](implicit ev: <:<[A, Either[E1, B]]): ZPure[W, S1, S2, R, E1, B]

Submerges the error case of an Either into the error type of this computation.

final def andThen[W1 >: W, S3, E1 >: E, B](that: ZPure[W1, S2, S3, A, E1, B]): ZPure[W1, S1, S3, R, E1, B]

Runs this computation and uses its result to provide the specified computation with its required environment.

final def as[B](b: ⇒ B): ZPure[W, S1, S2, R, E, B]

Maps the success value of this computation to a constant value.

final def asInstanceOf[T0]: T0

final def asSome: ZPure[W, S1, S2, R, E, Option[A]]

Maps the success value of this computation to the optional value.

final def asSomeError(implicit ev: CanFail[E]): ZPure[W, S1, S2, R, Option[E], A]

Maps the error value of this computation to the optional value.

final def asState[S3](s: S3): ZPure[W, S1, S3, R, E, A]

Maps the output state to a constant value

final def bimap[E1, B](f: (E) ⇒ E1, g: (A) ⇒ B)(implicit ev: CanFail[E]): ZPure[W, S1, S2, R, E1, B]

Returns a computation whose error and success channels have been mapped by the specified functions, f and g.

final def catchAll[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, A1 >: A](f: (E) ⇒ ZPure[W1, S0, S3, R1, E1, A1])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, A1]

Recovers from all errors.

final def catchSome[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZPure[W1, S0, S3, R1, E1, A1]])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, A1]

Recovers from some or all of the error cases.

final def clearLogOnError: ZPure[W, S1, S2, R, E, A]

Modifies the behavior of the inner computation regarding logs, so that logs written in a failed computation will be cleared.

def clone(): AnyRef

final def collect[E1 >: E, B](e: ⇒ E1)(pf: PartialFunction[A, B]): ZPure[W, S1, S2, R, E1, B]

Transforms the result of this computation with the specified partial function, failing with the e value if the partial function is not defined for the given input.

final def collectM[W1 >: W, S3, R1 <: R, E1 >: E, B](e: ⇒ E1)(pf: PartialFunction[A, ZPure[W1, S2, S3, R1, E1, B]]): ZPure[W1, S1, S3, R1, E1, B]

Transforms the result of this computation with the specified partial function which returns a new computation, failing with the e value if the partial function is not defined for the given input.

final def compose[W1 >: W, S0, R0, E1 >: E](that: ZPure[W1, S0, S1, R0, E1, R]): ZPure[W1, S0, S2, R0, E1, A]

Runs the specified computation and uses its result to provide this computation with its required environment.

final def contramapState[S0](f: (S0) ⇒ S1): ZPure[W, S0, S2, R, E, A]

Transforms the initial state of this computation with the specified function.

final def either[S3 >: S2 <: S1](implicit ev: CanFail[E]): ZPure[W, S3, S3, R, Nothing, Either[E, A]]

Returns a computation whose failure and success have been lifted into an Either.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def filterOrElse[W1 >: W, S3 >: S2, R1 <: R, E1 >: E, A1 >: A](p: (A) ⇒ Boolean)(f: (A) ⇒ ZPure[W1, S2, S3, R1, E1, A1]): ZPure[W1, S1, S3, R1, E1, A1]

Applies the specified function if the predicate fails.

final def filterOrElse_[W1 >: W, S3 >: S2, R1 <: R, E1 >: E, A1 >: A](p: (A) ⇒ Boolean)(zPure: ⇒ ZPure[W1, S2, S3, R1, E1, A1]): ZPure[W1, S1, S3, R1, E1, A1]

Similar to filterOrElse, but instead of a function it accepts the ZPure computation to apply if the predicate fails.

final def filterOrFail[E1 >: E](p: (A) ⇒ Boolean)(e: ⇒ E1): ZPure[W, S1, S2, R, E1, A]

Fails with the specified error if the predicate fails.

def finalize(): Unit

final def flatMap[W1 >: W, S3, R1 <: R, E1 >: E, B](f: (A) ⇒ ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, B]

Extends this computation with another computation that depends on the result of this computation by running the first computation, using its result to generate a second computation, and running that computation.

final def flatten[W1 >: W, S3, R1 <: R, E1 >: E, B](implicit ev: <:<[A, ZPure[W1, S2, S3, R1, E1, B]]): ZPure[W1, S1, S3, R1, E1, B]

Flattens a nested computation to a single computation by running the outer computation and then running the inner computation.

final def flip[S3 >: S2 <: S1]: ZPure[W, S3, S3, R, A, E]

Swaps the error and success types of this computation.

final def fold[S3 >: S2 <: S1, B](failure: (E) ⇒ B, success: (A) ⇒ B)(implicit ev: CanFail[E]): ZPure[W, S3, S3, R, Nothing, B]

Folds over the failed or successful results of this computation to yield a computation that does not fail, but succeeds with the value of the left or righr function passed to fold.

final def foldCauseM[W1 >: W, S0 <: S1, S3, R1 <: R, E1, B](failure: (Cause[E]) ⇒ ZPure[W1, S0, S3, R1, E1, B], success: (A) ⇒ ZPure[W1, S2, S3, R1, E1, B])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, B]

final def foldM[W1 >: W, S0 <: S1, S3, R1 <: R, E1, B](failure: (E) ⇒ ZPure[W1, S0, S3, R1, E1, B], success: (A) ⇒ ZPure[W1, S2, S3, R1, E1, B])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, B]

Recovers from errors by accepting one computation to execute for the case of an error, and one computation to execute for the case of success.

final def getClass(): Class[_]

final def getState: ZPure[W, S1, S2, R, E, (S2, A)]

Exposes the output state into the value channel.

def hashCode(): Int

final def head[B](implicit ev: <:<[A, List[B]]): ZPure[W, S1, S2, R, Option[E], B]

Returns a successful computation with the head of the list if the list is non-empty or fails with the error None if the list is empty.

final def isInstanceOf[T0]: Boolean

final def join[W1 >: W, S0 <: S1, S3 >: S2, R1, B, E1 >: E, A1 >: A](that: ZPure[W1, S0, S3, R1, E1, A1]): ZPure[W1, S0, S3, Either[R, R1], E1, A1]

Runs this computation if the provided environment is a Left or else runs that computation if the provided environment is a Right, unifying the result to a common supertype.

final def keepLogOnError: ZPure[W, S1, S2, R, E, A]

Modifies the behavior of the inner computation regarding logs, so that logs written in a failed computation will be kept (this is the default behavior).

final def left[B, C](implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, Option[E], B]

Returns a successful computation if the value is Left, or fails with error None.

final def leftOrFail[B, C, E1 >: E](e: ⇒ E1)(implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, E1, B]

Returns a successful computation if the value is Left, or fails with error e.

final def leftOrFailWith[B, C, E1 >: E](e: (C) ⇒ E1)(implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, E1, B]

Returns a successful computation if the value is Left, or fails with the given error function e.

final def leftOrFailWithException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZPure[W, S1, S2, R, E1, B]

Returns a successful computation if the value is Left, or fails with a java.util.NoSuchElementException.

final def log[W1 >: W](w: W1): ZPure[W1, S1, S2, R, E, A]

final def map[B](f: (A) ⇒ B): ZPure[W, S1, S2, R, E, B]

Transforms the result of this computation with the specified function.

final def mapError[E1](f: (E) ⇒ E1)(implicit ev: CanFail[E]): ZPure[W, S1, S2, R, E1, A]

Transforms the error type of this computation with the specified function.

final def mapErrorCause[E2](f: (Cause[E]) ⇒ Cause[E2]): ZPure[W, S1, S2, R, E2, A]

Returns a computation with its full cause of failure mapped using the specified function.

final def mapState[S3](f: (S2) ⇒ S3): ZPure[W, S1, S3, R, E, A]

Transforms the updated state of this computation with the specified function.

final def ne(arg0: AnyRef): Boolean

final def negate(implicit ev: <:<[A, Boolean]): ZPure[W, S1, S2, R, E, Boolean]

Negates the boolean value of this computation.

final def none[B](implicit ev: <:<[A, Option[B]]): ZPure[W, S1, S2, R, Option[E], Unit]

Requires the value of this computation to be None, otherwise fails with None.

final def notify(): Unit

final def notifyAll(): Unit

final def orElse[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, A1 >: A](that: ⇒ ZPure[W1, S0, S3, R1, E1, A1])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, A1]

Executes this computation and returns its value, if it succeeds, but otherwise executes the specified computation.

final def orElseEither[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, B](that: ⇒ ZPure[W1, S0, S3, R1, E1, B])(implicit ev: CanFail[E]): ZPure[W1, S0, S3, R1, E1, Either[A, B]]

Executes this computation and returns its value, if it succeeds, but otherwise executes the specified computation.

final def orElseFail[E1](e1: ⇒ E1)(implicit ev: CanFail[E]): ZPure[W, S1, S2, R, E1, A]

Executes this computation and returns its value, if it succeeds, but otherwise fails with the specified error.

final def orElseFallback[A1 >: A, S3 >: S2](a1: ⇒ A1, s3: ⇒ S3)(implicit ev: CanFail[E]): ZPure[W, S1, S3, R, Nothing, A1]

Executes this computation and returns its value, if it succeeds, but otherwise fallbacks to the new state with the specified value.

final def orElseOptional[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1, A1 >: A](that: ⇒ ZPure[W1, S0, S3, R1, Option[E1], A1])(implicit ev: <:<[E, Option[E1]]): ZPure[W1, S0, S3, R1, Option[E1], A1]

Returns an computation that will produce the value of this computation, unless it fails with the None value, in which case it will produce the value of the specified computation.

final def orElseSucceed[A1 >: A](a1: ⇒ A1)(implicit ev: CanFail[E]): ZPure[W, S1, Any, R, Nothing, A1]

Executes this computation and returns its value, if it succeeds, but otherwise succeeds with the specified value.

final def provide(r: R)(implicit ev: NeedsEnv[R]): ZPure[W, S1, S2, Any, E, A]

Provides this computation with its required environment.

final def provideSome[R0](f: (R0) ⇒ R): ZPure[W, S1, S2, R0, E, A]

Provides this computation with part of its required environment, leaving the remainder.

final def provideState(s: S1): ZPure[W, Any, S2, R, E, A]

Provides this computation with its initial state.

final def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZPure[W, S1, S2, R, E1, A]

Keeps some of the errors, and throw the rest

final def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) ⇒ Throwable)(implicit ev: CanFail[E]): ZPure[W, S1, S2, R, E1, A]

Keeps some of the errors, and throw the rest, using the specified function to convert the E into a Throwable.

final def reject[S0 <: S1, S3 >: S2, R1 <: R, E1 >: E](pf: PartialFunction[A, E1]): ZPure[W, S0, S3, R1, E1, A]

Fail with the returned value if the PartialFunction matches, otherwise continue with our held value.

final def rejectM[W1 >: W, S0 <: S1, S3 >: S2, R1 <: R, E1 >: E](pf: PartialFunction[A, ZPure[W1, S2, S3, R1, E1, E1]]): ZPure[W1, S0, S3, R1, E1, A]

Continue with the returned computation if the PartialFunction matches, translating the successful match into a failure, otherwise continue with our held value.

final def repeatN(n: Int)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A]

Repeats this computation the specified number of times (or until the first failure) passing the updated state to each successive repetition.

final def repeatUntil(f: (A) ⇒ Boolean)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A]

Repeats this computation until its value satisfies the specified predicate (or until the first failure) passing the updated state to each successive repetition.

final def repeatUntilEquals[A1 >: A](a: ⇒ A1)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A1]

Repeats this computation until its value is equal to the specified value (or until the first failure) passing the updated state to each successive repetition.

final def repeatUntilState(f: (S2) ⇒ Boolean)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A]

Repeats this computation until the updated state satisfies the specified predicate (or until the first failure) passing the updated state to each successive repetition.

final def repeatUntilStateEquals[S3 >: S2](s: ⇒ S3)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S3, R, E, A]

Repeats this computation until the updated state is equal to the specified value (or until the first failure) passing the updated state to each successive repetition.

final def repeatWhile(f: (A) ⇒ Boolean)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A]

Repeats this computation for as long as its value satisfies the specified predicate (or until the first failure) passing the updated state to each successive repetition.

final def repeatWhileEquals[A1 >: A](a: ⇒ A1)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A1]

Repeats this computation for as long as its value is equal to the specified value (or until the first failure) passing the updated state to each successive repetition.

final def repeatWhileState(f: (S2) ⇒ Boolean)(implicit ev: <:<[S2, S1]): ZPure[W, S1, S2, R, E, A]

Repeats this computation for as long as the updated state satisfies the specified predicate (or until the first failure) passing the updated state to each successive repetition.

final def right[B, C](implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, Option[E], C]

Returns a successful computation if the value is Right, or fails with error None.

final def rightOrFail[B, C, E1 >: E](e: ⇒ E1)(implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, E1, C]

final def rightOrFailWith[B, C, E1 >: E](e: (B) ⇒ E1)(implicit ev: <:<[A, Either[B, C]]): ZPure[W, S1, S2, R, E1, C]

final def rightOrFailWithException[B, C, E1 >: NoSuchElementException](implicit ev: <:<[A, Either[B, C]], ev2: <:<[E, E1]): ZPure[W, S1, S2, R, E1, C]

final def run(s: S1)(implicit ev1: <:<[Any, R], ev2: <:<[E, Nothing]): (S2, A)

Runs this computation with the specified initial state, returning both the updated state and the result.

final def run(implicit ev1: <:<[Unit, S1], ev2: <:<[Any, R], ev3: <:<[E, Nothing]): A

Runs this computation to produce its result.

final def runAll(s: S1)(implicit ev: <:<[Any, R]): (Chunk[W], Either[Cause[E], (S2, A)])

Runs this computation with the specified initial state, returning both the log and either all the failures that occurred or the updated state and the result.

final def runEither(implicit ev1: <:<[Unit, S1], ev2: <:<[Any, R]): Either[E, A]

Runs this computation to produce its result or the first failure to occur.

final def runLog(implicit ev1: <:<[Unit, S1], ev2: <:<[Any, R], ev3: <:<[E, Nothing]): (Chunk[W], A)

Runs this computation to produce its result and the log.

final def runResult(s: S1)(implicit ev1: <:<[Any, R], ev2: <:<[E, Nothing]): A

Runs this computation with the specified initial state, returning the result and discarding the updated state.

final def runState(s: S1)(implicit ev1: <:<[Any, R], ev2: <:<[E, Nothing]): S2

Runs this computation with the specified initial state, returning the updated state and discarding the result.

final def runValidation(implicit ev1: <:<[Unit, S1], ev2: <:<[Any, R]): ZValidation[W, E, A]

Runs this computation to a ZValidation value.

final def sandbox: ZPure[W, S1, S2, R, Cause[E], A]

Exposes the full cause of failures of this computation.

final def some[B](implicit ev: <:<[A, Option[B]]): ZPure[W, S1, S2, R, Option[E], B]

Converts an option on values into an option on errors leaving the state unchanged.

final def someOrElse[B](default: ⇒ B)(implicit ev: <:<[A, Option[B]]): ZPure[W, S1, S2, R, E, B]

Extracts the optional value or returns the given 'default' leaving the state unchanged.

final def someOrElseM[W1 >: W, S3 >: S2, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B])(implicit ev: <:<[A, Option[B]]): ZPure[W1, S1, S3, R1, E1, B]

Extracts the optional value or runs the specified computation passing the updated state from this computation.

final def someOrFail[B, E1 >: E](e: ⇒ E1)(implicit ev: <:<[A, Option[B]]): ZPure[W, S1, S2, R, E1, B]

Extracts the optional value or fails with the given error 'e'.

final def someOrFailException[B, E1 >: E](implicit ev: <:<[A, Option[B]], ev2: <:<[NoSuchElementException, E1]): ZPure[W, S1, S2, R, E1, B]

Extracts the optional value or fails with a java.util.NoSuchElementException leaving the state unchanged.

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

def toString(): String

def toZIO[R1 <: R](implicit ev: <:<[Unit, S1], tag: zio.Tag[R1]): ZIO[R1, E, A]

Transforms ZPure to ZIO that either succeeds with A or fails with error(s) E.

def toZIOWith[R1 <: R](s1: S1)(implicit tag: zio.Tag[R1]): ZIO[R1, E, A]

Transforms ZPure to ZIO that either succeeds with A or fails with error(s) E.

def toZIOWithAll[R1 <: R](s1: S1)(implicit tag: zio.Tag[R1]): ZIO[R1, E, (Chunk[W], S2, A)]

Transforms ZPure to ZIO that either succeeds with Chunk[W], S2 and A or fails with error(s) E.

def toZIOWithState[R1 <: R](s1: S1)(implicit tag: zio.Tag[R1]): ZIO[R1, E, (S2, A)]

Transforms ZPure to ZIO that either succeeds with S2 and A or fails with error(s) E.

final def unit: ZPure[W, S1, S2, R, E, Unit]

Maps the value of this computation to unit.

def unsandbox[E1](implicit ev: <:<[E, Cause[E1]]): ZPure[W, S1, S2, R, E1, A]

Submerges the full cause of failures of this computation.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, (A, B)]

Combines this computation with the specified computation, passing the updated state from this computation to that computation and combining the results of both into a tuple.

final def zipLeft[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, A]

Combines this computation with the specified computation, passing the updated state from this computation to that computation and returning the result of this computation.

final def zipRight[W1 >: W, S3, R1 <: R, E1 >: E, B](that: ZPure[W1, S2, S3, R1, E1, B]): ZPure[W1, S1, S3, R1, E1, B]

Combines this computation with the specified computation, passing the updated state from this computation to that computation and returning the result of that computation.

final def zipWith[W1 >: W, S3, R1 <: R, E1 >: E, B, C](that: ZPure[W1, S2, S3, R1, E1, B])(f: (A, B) ⇒ C): ZPure[W1, S1, S3, R1, E1, C]

Combines this computation with the specified computation, passing the updated state from this computation to that computation and combining the results of both using the specified function.

final def |||[W1 >: W, S0 <: S1, S3 >: S2, R1, B, E1 >: E, A1 >: A](that: ZPure[W1, S0, S3, R1, E1, A1]): ZPure[W1, S0, S3, Either[R, R1], E1, A1]

A symbolic alias for join.