final case class CallbackKleisli[A, B](run: (A) ⇒ CallbackTo[B]) extends AnyVal with Product with Serializable

A => CallbackTo[B] aka Kleisli[CallbackTo, A, B] aka ReaderT[A, CallbackTo, B].

Never heard of Kleisli? Basically, a "Kleisli triple" is a function with the shape A => M[B]. In this case, the M is hard-coded to CallbackTo.

This is hard-coded to CallbackTo for the same reasons as CallbackOption and for the same reasons that CallbackTo exists.

Since

1.2.0

Linear Supertypes
Serializable, Serializable, Product, Equals, AnyVal, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. CallbackKleisli
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. AnyVal
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new CallbackKleisli(run: (A) ⇒ CallbackTo[B])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. def *>[C](next: CallbackKleisli[A, C]): CallbackKleisli[A, C]

    Alias for >>.

    Alias for >>.

    Where >> is often associated with Monads, *> is often associated with Applicatives.

    Annotations
    @inline()
  4. def <*[C](next: CallbackKleisli[A, C]): CallbackKleisli[A, B]

    Sequence actions, discarding the value of the second argument.

  5. def <<[C](prev: CallbackKleisli[A, C]): CallbackKleisli[A, B]

    Sequence a CallbackKleisli to run before this, discarding any value produced by it.

    Sequence a CallbackKleisli to run before this, discarding any value produced by it.

    Annotations
    @inline()
  6. def <<?[C](prev: Option[CallbackKleisli[A, C]]): CallbackKleisli[A, B]

    Convenient version of << that accepts an Option

  7. def <=<[C](prev: CallbackKleisli[C, A]): CallbackKleisli[C, B]
    Annotations
    @inline()
  8. def <|(t: (B) ⇒ Any): CallbackKleisli[A, B]

    Alias for tap.

    Alias for tap.

    Annotations
    @inline()
  9. def =<<(a: CallbackTo[A]): CallbackTo[B]
  10. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  11. def >=>[C](next: CallbackKleisli[B, C]): CallbackKleisli[A, C]
  12. def >>[C](next: CallbackKleisli[A, C]): CallbackKleisli[A, C]

    Sequence a CallbackKleisli to run after this, discarding any value produced by this.

  13. def >>=[C](f: (B) ⇒ CallbackKleisli[A, C]): CallbackKleisli[A, C]

    Alias for flatMap.

    Alias for flatMap.

    Annotations
    @inline()
  14. def andThen[C](next: CallbackKleisli[B, C]): CallbackKleisli[A, C]
    Annotations
    @inline()
  15. def apply(a: A): CallbackTo[B]
    Annotations
    @inline()
  16. def asCallback: CallbackTo[(A) ⇒ B]
  17. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  18. def attempt: CallbackKleisli[A, Either[Throwable, B]]

    Wraps this callback in a try-catch and returns either the result or the exception if one occurs.

  19. def attemptTry: CallbackKleisli[A, Try[B]]

    Wraps this callback in a scala Try with catches what it considers non-fatal errors.

    Wraps this callback in a scala Try with catches what it considers non-fatal errors.

    Use attempt to catch everything.

  20. def compose[C](prev: CallbackKleisli[C, A]): CallbackKleisli[C, B]
    Annotations
    @inline()
  21. def contramap[C](f: (C) ⇒ A): CallbackKleisli[C, B]
  22. def contramapCB[C](f: (C) ⇒ CallbackTo[A]): CallbackKleisli[C, B]
  23. def dimap[C, D](f: (C) ⇒ A, g: (B) ⇒ D): CallbackKleisli[C, D]
    Annotations
    @inline()
  24. def flatMap[C](f: (B) ⇒ CallbackKleisli[A, C]): CallbackKleisli[A, C]
  25. def flatTap[C](t: (B) ⇒ CallbackKleisli[A, C]): CallbackKleisli[A, B]
  26. def getClass(): Class[_ <: AnyVal]
    Definition Classes
    AnyVal → Any
  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. def map[C](f: (B) ⇒ C): CallbackKleisli[A, C]
  29. def mapCB[C](f: (CallbackTo[B]) ⇒ CallbackTo[C]): CallbackKleisli[A, C]
  30. def narrow[C <: A]: CallbackKleisli[C, B]
  31. def ret[C](c: C): CallbackKleisli[A, C]

    Discard the callback's return value, return a given value instead.

    Discard the callback's return value, return a given value instead.

    ret, short for return.

  32. val run: (A) ⇒ CallbackTo[B]
  33. def strongL[R]: CallbackKleisli[(A, R), (B, R)]
  34. def strongR[L]: CallbackKleisli[(L, A), (L, B)]
  35. def tap(t: (B) ⇒ Any): CallbackKleisli[A, B]

    When the callback result becomes available, perform a given side-effect with it.

  36. def toCallback(a: CallbackTo[A]): CallbackTo[B]
  37. def toJsFn: Function1[A, B]
  38. def underlyingRepr: (A) ⇒ CallbackTo[B]
    Annotations
    @inline()
  39. def unless(test: (A) ⇒ Boolean): CallbackKleisli[A, Option[B]]
    Annotations
    @inline()
  40. def unless_(test: (A) ⇒ Boolean): CallbackKleisli[A, Unit]
    Annotations
    @inline()
  41. def void: CallbackKleisli[A, Unit]

    Discard the value produced by this callback.

  42. def voidExplicit[C](implicit ev: <:<[B, C]): CallbackKleisli[A, Unit]

    Discard the value produced by this callback.

    Discard the value produced by this callback.

    This method allows you to be explicit about the type you're discarding (which may change in future).

    Annotations
    @inline()
  43. def when(test: (A) ⇒ Boolean): CallbackKleisli[A, Option[B]]
  44. def when_(test: (A) ⇒ Boolean): CallbackKleisli[A, Unit]
  45. def widen[C >: B]: CallbackKleisli[A, C]
  46. def zip[C](cb: CallbackKleisli[A, C]): CallbackKleisli[A, (B, C)]
  47. def |>[C](f: (B) ⇒ C): CallbackKleisli[A, C]

    Alias for map.

    Alias for map.

    Annotations
    @inline()

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyVal

Inherited from Any

Ungrouped