t

# SemigroupApply 

#### trait SemigroupApply extends Apply[[α]F]

Attributes
protected[this]
Source
Semigroup.scala
Linear Supertypes
Apply[[α]F], ApplyParent[[α]F], Functor[[α]F], InvariantFunctor[[α]F], AnyRef, Any
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. SemigroupApply
2. Apply
3. ApplyParent
4. Functor
5. InvariantFunctor
6. AnyRef
7. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait ApplyLaw extends FunctorLaw
Definition Classes
Apply
2. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
3. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor

### 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 ap[A, B](fa: ⇒ F)(f: ⇒ F): F

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".

Definition Classes
SemigroupApplyApply
5. def ap2[A, B, C](fa: ⇒ F, fb: ⇒ F)(f: F): F
Definition Classes
Apply
6. def ap3[A, B, C, D](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F)(f: F): F
Definition Classes
Apply
7. def ap4[A, B, C, D, E](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F)(f: F): F
Definition Classes
Apply
8. def ap5[A, B, C, D, E, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F)(f: F): F
Definition Classes
Apply
9. def ap6[A, B, C, D, E, FF, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F)(f: F): F
Definition Classes
Apply
10. def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F)(f: F): F
Definition Classes
Apply
11. def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F)(f: F): F
Definition Classes
Apply
12. def apF[A, B](f: ⇒ F): (F) ⇒ F

Flipped variant of `ap`.

Flipped variant of `ap`.

Definition Classes
Apply
13. def apply[A, B](fa: F)(f: (A) ⇒ B): F

Alias for `map`.

Alias for `map`.

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

Add a unit to any Apply to form an Applicative.

Add a unit to any Apply to form an Applicative.

Definition Classes
Apply
26. def applyLaw
Definition Classes
Apply
27. val applySyntax: ApplySyntax[[α]F]
Definition Classes
Apply
28. final def asInstanceOf[T0]: T0
Definition Classes
Any
29. def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F]

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
30. def clone()
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
31. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F]

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

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

Definition Classes
Apply
32. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F]

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
33. def counzip[A, B](a: \/[F, F]): F
Definition Classes
Functor
34. def discardLeft[A, B](fa: ⇒ F, fb: ⇒ F): F

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

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

Definition Classes
ApplyParent
35. def discardRight[A, B](fa: ⇒ F, fb: ⇒ F): F

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

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

Definition Classes
ApplyParent
36. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
37. def equals(arg0: Any)
Definition Classes
AnyRef → Any
38. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
39. def flip: Apply[[α]F]

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

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

Definition Classes
ApplyParent
40. def forever[A, B](fa: F): F

Repeats an applicative action infinitely

Repeats an applicative action infinitely

Definition Classes
ApplyParent
41. def fpair[A](fa: F): F

Twin all `A`s in `fa`.

Twin all `A`s in `fa`.

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

Pair all `A`s in `fa` with the result of function application.

Pair all `A`s in `fa` with the result of function application.

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

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
48. def invariantFunctorLaw
Definition Classes
InvariantFunctor
49. val invariantFunctorSyntax: InvariantFunctorSyntax[[α]F]
Definition Classes
InvariantFunctor
50. final def isInstanceOf[T0]
Definition Classes
Any
51. def lift[A, B](f: (A) ⇒ B): (F) ⇒ F

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
52. 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, F, F, F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
53. 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, F, F, F, F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
54. 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, F, F, F, F, F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
55. def lift2[A, B, C](f: (A, B) ⇒ C): (F, F) ⇒ F
Definition Classes
Apply
56. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F, F, F) ⇒ F
Definition Classes
Apply
57. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F, F, F, F) ⇒ F
Definition Classes
Apply
58. def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F, F, F, F, F) ⇒ F
Definition Classes
Apply
59. def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
60. def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
61. def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F, F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
62. def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F, F, F, F, F, F, F, F, F) ⇒ F
Definition Classes
Apply
63. def map[A, B](fa: F)(f: (A) ⇒ B): F

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

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

Definition Classes
SemigroupApplyFunctor
64. def mapply[A, B](a: A)(f: F): F

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

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

Definition Classes
Functor
65. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
66. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
67. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
68. 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

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

Definition Classes
Apply
69. 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
70. def sequence1[A, G[_]](as: G[F])(implicit arg0: Traverse1[G]): F
Definition Classes
Apply
71. def strengthL[A, B](a: A, f: F): F

Inject `a` to the left of `B`s in `f`.

Inject `a` to the left of `B`s in `f`.

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

Inject `b` to the right of `A`s in `f`.

Inject `b` to the right of `A`s in `f`.

Definition Classes
Functor
73. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
74. def toString()
Definition Classes
AnyRef → Any
75. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F)(implicit G: Traverse1[G]): F
Definition Classes
Apply
76. def tuple2[A, B](fa: ⇒ F, fb: ⇒ F): F
Definition Classes
Apply
77. def tuple3[A, B, C](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F): F
Definition Classes
Apply
78. def tuple4[A, B, C, D](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F): F
Definition Classes
Apply
79. def tuple5[A, B, C, D, E](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F): F
Definition Classes
Apply
80. def void[A](fa: F): F

Empty `fa` of meaningful pure values, preserving its structure.

Empty `fa` of meaningful pure values, preserving its structure.

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

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
85. def xmap[A, B](fa: F, f: (A) ⇒ B, g: (B) ⇒ A): F

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
86. def xmapb[A, B](ma: F)(b: Bijection[A, B]): F

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
87. def xmapi[A, B](ma: F)(iso: Isomorphism.<=>[A, B]): F

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