t

scalaz

Apply 

Companion object Apply

trait Apply[F[_]] extends Functor[F]

scalaz.Applicative without point.

Self Type
Apply[F]
Source
Apply.scala

scalaz.Apply.ApplyLaw

Linear Supertypes
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Apply
2. Functor
3. InvariantFunctor
4. AnyRef
5. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

Type Members

1. trait ApplyLaw extends FunctorLaw
2. trait FlippedApply extends Apply[F]
Attributes
protected[this]
3. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
4. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor

Abstract Value Members

1. abstract def ap[A, B](fa: ⇒ F[A])(f: ⇒ F[(A) ⇒ B]): F[B]

Sequence f, then fa, combining their results by function application.

Sequence f, then fa, combining their results by function application.

NB: with respect to apply2 and all other combinators, as well as scalaz.Bind, the f action appears to the *left*. So f should be the "first" F-action to perform. This is in accordance with all other implementations of this typeclass in common use, which are "function first".

2. abstract def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Lift f into F and apply to F[A].

Lift f into F and apply to F[A].

Definition Classes
Functor

Concrete Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. def ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]
5. def ap3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: F[(A, B, C) ⇒ D]): F[D]
6. def ap4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: F[(A, B, C, D) ⇒ E]): F[E]
7. def ap5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: F[(A, B, C, D, E) ⇒ R]): F[R]
8. def ap6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: F[(A, B, C, D, E, FF) ⇒ R]): F[R]
9. def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: F[(A, B, C, D, E, FF, G) ⇒ R]): F[R]
10. def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: F[(A, B, C, D, E, FF, G, H) ⇒ R]): F[R]
11. def apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]

Flipped variant of ap.

12. def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for map.

Alias for map.

Definition Classes
Functor
13. def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F[R]
14. def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F[R]
15. def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K], fl: ⇒ F[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F[R]
16. def apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]
17. def apply3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D): F[D]
18. def apply4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E): F[E]
19. def apply5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ R): F[R]
20. def apply6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: (A, B, C, D, E, FF) ⇒ R): F[R]
21. def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: (A, B, C, D, E, FF, G) ⇒ R): F[R]
22. def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): F[R]
23. def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F[R]
24. def applyApplicative: Applicative[[α]\/[F[α], α]]

Add a unit to any Apply to form an Applicative.

25. def applyLaw
26. val applySyntax: ApplySyntax[F]
27. final def applying1[Z, A1](f: (A1) ⇒ Z)(implicit a1: F[A1]): F[Z]
28. final def applying2[Z, A1, A2](f: (A1, A2) ⇒ Z)(implicit a1: F[A1], a2: F[A2]): F[Z]
29. final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
30. final def applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
31. final def asInstanceOf[T0]: T0
Definition Classes
Any
32. def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]

The composition of Functor F and Bifunctor G, [x, y]F[G[x, y]], is a Bifunctor

The composition of Functor F and Bifunctor G, [x, y]F[G[x, y]], is a Bifunctor

Definition Classes
Functor
33. def clone()
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
34. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]

The composition of Applys F and G, [x]F[G[x]], is a Apply

35. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]

The composition of Functors F and G, [x]F[G[x]], is a Functor

The composition of Functors F and G, [x]F[G[x]], is a Functor

Definition Classes
Functor
36. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
37. def discardLeft[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[B]

Combine fa and fb according to Apply[F] with a function that discards the A(s)

38. def discardRight[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[A]

Combine fa and fb according to Apply[F] with a function that discards the B(s)

39. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
40. def equals(arg0: Any)
Definition Classes
AnyRef → Any
41. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
42. def flip: Apply[F]

An Apply for F in which effects happen in the opposite order.

43. def forever[A, B](fa: F[A]): F[B]

Repeats an applicative action infinitely

44. def fpair[A](fa: F[A]): F[(A, A)]

Twin all As in fa.

Twin all As in fa.

Definition Classes
Functor
45. def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

Pair all As in fa with the result of function application.

Pair all As in fa with the result of function application.

Definition Classes
Functor
46. def functorLaw
Definition Classes
Functor
47. val functorSyntax: FunctorSyntax[F]
Definition Classes
Functor
48. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
49. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
50. def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]

The composition of Functor F and Contravariant G, [x]F[G[x]], is contravariant.

The composition of Functor F and Contravariant G, [x]F[G[x]], is contravariant.

Definition Classes
Functor
51. def invariantFunctorLaw
Definition Classes
InvariantFunctor
52. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
53. final def isInstanceOf[T0]
Definition Classes
Any
54. def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift f into F.

Lift f into F.

Definition Classes
Functor
55. def lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J]) ⇒ F[R]
56. def lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K]) ⇒ F[R]
57. def lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K], F[L]) ⇒ F[R]
58. def lift2[A, B, C](f: (A, B) ⇒ C): (F[A], F[B]) ⇒ F[C]
59. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[A], F[B], F[C]) ⇒ F[D]
60. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F[A], F[B], F[C], F[D]) ⇒ F[E]
61. def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F[A], F[B], F[C], F[D], F[E]) ⇒ F[R]
62. def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF]) ⇒ F[R]
63. def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G]) ⇒ F[R]
64. def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H]) ⇒ F[R]
65. def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I]) ⇒ F[R]
66. def liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[F[A], F[B]]
67. def mapply[A, B](a: A)(f: F[(A) ⇒ B]): F[B]

Lift apply(a), and apply the result to f.

Lift apply(a), and apply the result to f.

Definition Classes
Functor
68. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
69. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
70. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
71. def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]

The product of Applys F and G, [x](F[x], G[x]]), is a Apply

72. def product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

Definition Classes
Functor
73. def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
74. def strengthL[A, B](a: A, f: F[B]): F[(A, B)]

Inject a to the left of Bs in f.

Inject a to the left of Bs in f.

Definition Classes
Functor
75. def strengthR[A, B](f: F[A], b: B): F[(A, B)]

Inject b to the right of As in f.

Inject b to the right of As in f.

Definition Classes
Functor
76. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
77. def toString()
Definition Classes
AnyRef → Any
78. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse1[G]): F[G[B]]
79. def tuple2[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[(A, B)]
80. def tuple3[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C]): F[(A, B, C)]
81. def tuple4[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D]): F[(A, B, C, D)]
82. def tuple5[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E]): F[(A, B, C, D, E)]
83. def unfoldrOpt[S, A, B](seed: S)(f: (S) ⇒ Maybe[(F[A], S)])(implicit R: Reducer[A, B]): Maybe[F[B]]

Unfold seed to the right and combine effects left-to-right, using the given Reducer to combine values.

Unfold seed to the right and combine effects left-to-right, using the given Reducer to combine values. Implementations may override this method to not unfold more than is necessary to determine the result.

84. def void[A](fa: F[A]): F[Unit]

Empty fa of meaningful pure values, preserving its structure.

Empty fa of meaningful pure values, preserving its structure.

Definition Classes
Functor
85. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
86. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
87. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
88. def widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]

Functors are covariant by nature, so we can treat an F[A] as an F[B] if A is a subtype of B.

Functors are covariant by nature, so we can treat an F[A] as an F[B] if A is a subtype of B.

Definition Classes
Functor
89. def xmap[A, B](fa: F[A], f: (A) ⇒ B, g: (B) ⇒ A): F[B]

Converts ma to a value of type F[B] using the provided functions f and g.

Converts ma to a value of type F[B] using the provided functions f and g.

Definition Classes
FunctorInvariantFunctor
90. def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Converts ma to a value of type F[B] using the provided bijection.

Converts ma to a value of type F[B] using the provided bijection.

Definition Classes
InvariantFunctor
91. def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]

Converts ma to a value of type F[B] using the provided isomorphism.

Converts ma to a value of type F[B] using the provided isomorphism.

Definition Classes
InvariantFunctor