extra
API
Generated with
extra/japgolly.scalajs.react.extra/Px

Px

japgolly.scalajs.react.extra.Px$
See thePx companion class
object Px

Attributes

Companion
class
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Px.type

Members list

Type members

Classlikes

object AutoValue

Import this to avoid the need to call .value() on your Pxs.

Import this to avoid the need to call .value() on your Pxs.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
AutoValue.type
sealed abstract class Derivative[A] extends Px[A]

Attributes

Supertypes
class Px[A]
class Object
trait Matchable
class Any
Known subtypes
class DerivativeBase[A, B, C]
class FlatMap[A, B]
class Map[A, B]
sealed abstract class DerivativeBase[A, B, C](xa: Px[A], derive: A => B) extends Derivative[C]

Attributes

Supertypes
class Derivative[C]
class Px[C]
class Object
trait Matchable
class Any
Known subtypes
class FlatMap[A, B]
class Map[A, B]
final case class Extract[A](extract: Px[A] => A) extends AnyVal

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class AnyVal
trait Matchable
class Any
Show all
object Extract

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
Extract.type
final class FlatMap[A, B](xa: Px[A], f: A => Px[B]) extends DerivativeBase[A, Px[B], B]

A Px[B] dependent on the value of some Px[A].

A Px[B] dependent on the value of some Px[A].

Attributes

Supertypes
class DerivativeBase[A, Px[B], B]
class Derivative[B]
class Px[B]
class Object
trait Matchable
class Any
Show all
final class FromThunk[A](thunk: () => A) extends AnyVal

Attributes

Supertypes
class AnyVal
trait Matchable
class Any
final class FromThunkReusability[A](thunk: () => A, reusability: Reusability[A])

Attributes

Supertypes
class Object
trait Matchable
class Any
object ManualCollection

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
trait ManualCollectionF[F[_]]

Attributes

Supertypes
class Object
trait Matchable
class Any
final class Map[A, B](xa: Px[A], f: A => B) extends DerivativeBase[A, B, B]

A value B dependent on the value of some Px[A].

A value B dependent on the value of some Px[A].

Attributes

Supertypes
class DerivativeBase[A, B, B]
class Derivative[B]
class Px[B]
class Object
trait Matchable
class Any
Show all
sealed abstract class Root[A](`__initValue`: () => A) extends Px[A]

Attributes

Supertypes
class Px[A]
class Object
trait Matchable
class Any
Known subtypes
class ThunkM[A]
class Var[A]
final class ThunkM[A](next: () => A, val reusability: Reusability[A]) extends Root[A]

The value of a zero-param function.

The value of a zero-param function.

The M in ThunkM denotes "Manual refresh", meaning that the value will not update until you explicitly call refresh().

Attributes

Supertypes
class Root[A]
class Px[A]
class Object
trait Matchable
class Any
final class Var[A](initialValue: A, val reusability: Reusability[A]) extends Root[A]

A variable in the traditional sense.

A variable in the traditional sense.

Doesn't change until you explicitly call set().

Attributes

Supertypes
class Root[A]
class Px[A]
class Object
trait Matchable
class Any

Types

Value members

Concrete methods

def apply[A](f: => A): FromThunk[A]
def apply10[A, B, C, D, E, F, G, H, I, J, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J])(z: (A, B, C, D, E, F, G, H, I, J) => Z): Px[Z]
def apply11[A, B, C, D, E, F, G, H, I, J, K, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K])(z: (A, B, C, D, E, F, G, H, I, J, K) => Z): Px[Z]
def apply12[A, B, C, D, E, F, G, H, I, J, K, L, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L])(z: (A, B, C, D, E, F, G, H, I, J, K, L) => Z): Px[Z]
def apply13[A, B, C, D, E, F, G, H, I, J, K, L, M, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M) => Z): Px[Z]
def apply14[A, B, C, D, E, F, G, H, I, J, K, L, M, N, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => Z): Px[Z]
def apply15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => Z): Px[Z]
def apply16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => Z): Px[Z]
def apply17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => Z): Px[Z]
def apply18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q], pr: Px[R])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => Z): Px[Z]
def apply19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q], pr: Px[R], ps: Px[S])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => Z): Px[Z]
def apply2[A, B, Z](pa: Px[A], pb: Px[B])(z: (A, B) => Z): Px[Z]
def apply20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q], pr: Px[R], ps: Px[S], pt: Px[T])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => Z): Px[Z]
def apply21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q], pr: Px[R], ps: Px[S], pt: Px[T], pu: Px[U])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => Z): Px[Z]
def apply22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I], pj: Px[J], pk: Px[K], pl: Px[L], pm: Px[M], pn: Px[N], po: Px[O], pp: Px[P], pq: Px[Q], pr: Px[R], ps: Px[S], pt: Px[T], pu: Px[U], pv: Px[V])(z: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => Z): Px[Z]
def apply3[A, B, C, Z](pa: Px[A], pb: Px[B], pc: Px[C])(z: (A, B, C) => Z): Px[Z]
def apply4[A, B, C, D, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D])(z: (A, B, C, D) => Z): Px[Z]
def apply5[A, B, C, D, E, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E])(z: (A, B, C, D, E) => Z): Px[Z]
def apply6[A, B, C, D, E, F, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F])(z: (A, B, C, D, E, F) => Z): Px[Z]
def apply7[A, B, C, D, E, F, G, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G])(z: (A, B, C, D, E, F, G) => Z): Px[Z]
def apply8[A, B, C, D, E, F, G, H, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H])(z: (A, B, C, D, E, F, G, H) => Z): Px[Z]
def apply9[A, B, C, D, E, F, G, H, I, Z](pa: Px[A], pb: Px[B], pc: Px[C], pd: Px[D], pe: Px[E], pf: Px[F], pg: Px[G], ph: Px[H], pi: Px[I])(z: (A, B, C, D, E, F, G, H, I) => Z): Px[Z]
def callback[G[_], A](cb: => G[A])(implicit G: Sync[G]): FromThunk[A]
def constByNeed[A](a: => A): Px[A]
def constByValue[A](a: A): Px[A]
def props[G[_] : Sync, A[_], P, S](s: MountedSimple[G, A, P, S]): FromThunk[P]
def refresh(xs: ThunkM[_]*): Unit

Refresh multiple ThunkMs at once.

Refresh multiple ThunkMs at once.

Attributes

def state[I, G[_] : Sync, S](i: I)(implicit evidence$2: Sync[G], sa: Read[I, G, S]): FromThunk[S]
Generated with