Step

Value Members

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

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. def *>[StateIn1 <: StateIn, Env1 <: Env, Params1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, Params1, Err1, Output2]): Step[StateIn1, StateOut2, Env1, Params1, Err1, Output2]

   

4. def <&>[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2]): Step[StateIn1, (StateOut, StateOut2), Env1, In1, Err1, (Value, Output2)]

   

5. def <*[StateIn1 <: StateIn, Env1 <: Env, Params1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, Params1, Err1, Output2]): Step[StateIn1, StateOut, Env1, Params1, Err1, Value]

   

6. def <*>[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2]): Step[StateIn1, (StateOut, StateOut2), Env1, In1, Err1, (Value, Output2)]

   

7. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

8. def >>>[SOut2, Env1 <: Env, Err1 >: Err, Output2](that: Step[StateOut, SOut2, Env1, Value, Err1, Output2]): Step[StateIn, SOut2, Env1, Params, Err1, Output2]

   

   Connect this Step to the given Step.

   Connect this Step to the given Step. By connecting the output state of this Step to the input state of the other Step and by connecting the output value of this Step to the input of the other.

9. def adaptParameters[Input0](func: (Input0) ⇒ Params): Step[StateIn, StateOut, Env, Input0, Err, Value]

   

   Adapts the input provided to the Step using the provided function.

10. def andThen[SOut2, Env1 <: Env, Err1 >: Err, Output2](that: Step[StateOut, SOut2, Env1, Value, Err1, Output2]): Step[StateIn, SOut2, Env1, Params, Err1, Output2]

    

11. def andThenEffect[Err1 >: Err, StateOut2, Output2](thatEffect: ZIO[Value, Err1, StepOutputs[StateOut2, Output2]]): Step[StateIn, StateOut2, Env, Params, Err1, Output2]

    

12. def as[Out2](out: ⇒ Out2): Step[StateIn, StateOut, Env, Params, Err, Out2]

    

    Maps the success value of this flow to the specified constant value.

13. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

14. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

15. def delay(duration: Duration): Step[StateIn, StateOut, Env with Clock, Params, Err, Value]

    

16. def describe(description: String): Step[StateIn, StateOut, Env, Params, Err, Value]

    

17. val description: Option[String]

    

18. val effect: ZIO[StepContext[Env, StateIn, Params], Err, StepOutputs[StateOut, Value]]

    

19. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

20. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

21. def flatMap[S, Env1 <: Env, P <: Params, Err1 >: Err, B](func: (Value) ⇒ Step[StateOut, S, Env1, P, Err1, B]): Step[StateIn, S, Env1, P, Err1, B]

    

22. def flatten[S, Env1 <: Env, P <: Params, Err1 >: Err, B](implicit ev: <:<[Value, Step[StateOut, S, Env1, P, Err1, B]]): Step[StateIn, S, Env1, P, Err1, B]

    

23. def flipOutputs: Step[StateIn, Value, Env, Params, Err, StateOut]

    

24. def fork: ForkedStep[StateIn, StateOut, Env, Params, Err, Value]

    

25. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

26. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

27. def map[Out2](fn: (Value) ⇒ Out2): Step[StateIn, StateOut, Env, Params, Err, Out2]

    

28. def mapEffect[Out2](fn: (Value) ⇒ Out2)(implicit ev: <:<[Err, Throwable]): Step[StateIn, StateOut, Env, Params, Throwable, Out2]

    

29. def mapError[Err2](onError: (Err) ⇒ Err2): Step[StateIn, StateOut, Env, Params, Err2, Value]

    

30. def mapOutputChannels[StateOut2, Output2](func: (StepOutputs[StateOut, Value]) ⇒ StepOutputs[StateOut2, Output2]): Step[StateIn, StateOut2, Env, Params, Err, Output2]

    

31. def mapOutputs[StateOut2, Output2](func: (StateOut, Value) ⇒ (StateOut2, Output2)): Step[StateIn, StateOut2, Env, Params, Err, Output2]

    

32. def mapState[SOut2](fn: (StateOut) ⇒ SOut2): Step[StateIn, SOut2, Env, Params, Err, Value]

    

33. val name: Option[String]

    

34. def named(name: String): Step[StateIn, StateOut, Env, Params, Err, Value]

    

35. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

36. final def notify(): Unit

    

    Definition Classes

    AnyRef

37. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

38. def orElse[StateIn1 <: StateIn, Env1 <: Env, Params1 <: Params, Err2, StateOut2 >: StateOut, Value2 >: Value](that: ⇒ Step[StateIn1, StateOut2, Env1, Params1, Err2, Value2])(implicit ev: CanFail[Err]): Step[StateIn1, StateOut2, Env1, Params1, Err2, Value2]

    

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

39. def orElseEither[StateIn1 <: StateIn, Env1 <: Env, Params1 <: Params, Err2, ThatState >: StateOut, ThatValue](that: ⇒ Step[StateIn1, ThatState, Env1, Params1, Err2, ThatValue])(implicit ev: CanFail[Err]): Step[StateIn1, Either[StateOut, ThatState], Env1, Params1, Err2, Either[Value, ThatValue]]

    

    Returns a step that will produce the value of this step, unless it fails, in which case, it will produce the value of the specified step.

40. def orElseFail[State >: StateOut, Err1](error: Err1)(implicit ev: CanFail[Err]): Step[StateIn, StateOut, Env, Params, Err1, Value]

    

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

41. def orElseSucceed[State >: StateOut, Value1 >: Value](state: ⇒ State, value: ⇒ Value1)(implicit ev: CanFail[Err]): Step[StateIn, State, Env, Params, Nothing, Value1]

    

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

42. def repeatN(n: Int): Step[StateIn, StateOut, Env, Params, Err, Value]

    

    Repeats the step the specified number of times.

43. def repeatUntil(statePredicate: (StateOut) ⇒ Boolean)(valuePredicate: (Value) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

44. def repeatUntil(f: (StepOutputs[StateOut, Value]) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

45. def repeatWhile(f: (StepOutputs[StateOut, Value]) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

46. def repeatWhileState(f: (StateOut) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

47. def repeatWhileValue(f: (Value) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

48. def retryN(n: Int)(implicit ev: CanFail[Err]): Step[StateIn, StateOut, Env, Params, Err, Value]

    

49. def retryWhile(f: (StepOutputs[StateOut, Value]) ⇒ Boolean): Step[StateIn, StateOut, Env, Params, Err, Value]

    

50. def run(input: Params, initialState: StateIn): ZIO[Env, Err, StepOutputs[StateOut, Value]]

    

51. def run(input: Params)(implicit evAnyState: <:<[Unit, StateIn]): ZIO[Env, Err, StepOutputs[StateOut, Value]]

    

52. def run(implicit evAnyInput: <:<[Any, Params], evAnyState: <:<[Any, StateIn]): ZIO[Env, Err, StepOutputs[StateOut, Value]]

    

53. def shiftStateToOutput: Step[StateIn, Unit, Env, Params, Err, (StateOut, Value)]

    

54. def stateAs[StateOut2](stateOut: ⇒ StateOut2): Step[StateIn, StateOut2, Env, Params, Err, Value]

    

    Maps the output state value of this step to the specified constant value.

55. def stateAsValue: Step[StateIn, StateOut, Env, Params, Err, StateOut]

    

    Takes the output state and makes it also available as the result value of this flow.

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

    

    Definition Classes

    AnyRef

57. def tap[Env1 <: Env, Err1 >: Err](func: (StateOut, Value) ⇒ ZIO[Env1, Err1, Any]): Step[StateIn, StateOut, Env1, Params, Err1, Value]

    

58. def tapState[Env1 <: Env, Err1 >: Err](func: (StateOut) ⇒ ZIO[Env1, Err1, Any]): Step[StateIn, StateOut, Env1, Params, Err1, Value]

    

59. def tapValue[Env1 <: Env, Err1 >: Err](func: (Value) ⇒ ZIO[Env1, Err1, Any]): Step[StateIn, StateOut, Env1, Params, Err1, Value]

    

60. def transformEff[StateOut2, Output2](func: (StateOut, Value) ⇒ (StateOut2, Output2))(implicit ev: <:<[Err, Throwable]): Step[StateIn, StateOut2, Env, Params, Throwable, Output2]

    

61. def valueAsState: Step[StateIn, Value, Env, Params, Err, Value]

    

    Make the state and the output value the same by making the state equal to the output.

62. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

64. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

65. def zip[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2]): Step[StateIn1, (StateOut, StateOut2), Env1, In1, Err1, (Value, Output2)]

    

66. def zipPar[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2]): Step[StateIn1, (StateOut, StateOut2), Env1, In1, Err1, (Value, Output2)]

    

67. def zipWith[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2, FinalState, FinalOutput](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2])(f: (StepOutputs[StateOut, Value], StepOutputs[StateOut2, Output2]) ⇒ StepOutputs[FinalState, FinalOutput]): Step[StateIn1, FinalState, Env1, In1, Err1, FinalOutput]

    

68. def zipWithPar[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2, FinalState, FinalOutput](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2])(f: (StepOutputs[StateOut, Value], StepOutputs[StateOut2, Output2]) ⇒ StepOutputs[FinalState, FinalOutput]): Step[StateIn1, FinalState, Env1, In1, Err1, FinalOutput]

    

69. def |+|[StateIn1 <: StateIn, Env1 <: Env, In1 <: Params, Err1 >: Err, StateOut2, Output2](that: Step[StateIn1, StateOut2, Env1, In1, Err1, Output2]): Step[StateIn1, (StateOut, StateOut2), Env1, In1, Err1, (Value, Output2)]