Interface Applicative<A,App extends Applicative<?,App>>
- Type Parameters:
A
- The type of the parameterApp
- The unification parameter to more tightly type-constrain Applicatives to themselves
- All Superinterfaces:
Functor<A,
App>
- All Known Subinterfaces:
BiMonoidFactory<A,
,B, C> BiPredicate<A,
,B> BiSemigroupFactory<A,
,B, C> Effect<A>
,Fn0<A>
,Fn1<A,
,B> Fn2<A,
,B, C> Fn3<A,
,B, C, D> Fn4<A,
,B, C, D, E> Fn5<A,
,B, C, D, E, F> Fn6<A,
,B, C, D, E, F, G> Fn7<A,
,B, C, D, E, F, G, H> Fn8<A,
,B, C, D, E, F, G, H, I> Iso<S,
,T, A, B> Iso.Simple<S,
,A> Kleisli<A,
,B, M, MB> Lens<S,
,T, A, B> Lens.Simple<S,
,A> Monad<A,
,M> MonadError<E,
,A, M> MonadReader<R,
,A, MR> MonadRec<A,
,M> MonadT<M,
,A, MT, T> MonadWriter<W,
,A, MW> Monoid<A>
,MonoidFactory<A,
,B> Predicate<A>
,Prism<S,
,T, A, B> Prism.Simple<S,
,A> Schema<Values>
,Semigroup<A>
,SemigroupFactory<A,
,B> TypeSafeKey<A,
,B> TypeSafeKey.Simple<A>
- All Known Implementing Classes:
$
,Absent
,AddAll
,All
,Alter
,And
,Any
,AutoBracket
,Between
,Both
,Bracket
,CartesianProduct
,CatMaybes
,Choice2
,Choice2._A
,Choice2._B
,Choice3
,Choice3._A
,Choice3._B
,Choice3._C
,Choice4
,Choice4._A
,Choice4._B
,Choice4._C
,Choice4._D
,Choice5
,Choice5._A
,Choice5._B
,Choice5._C
,Choice5._D
,Choice5._E
,Choice6
,Choice6._A
,Choice6._B
,Choice6._C
,Choice6._D
,Choice6._E
,Choice6._F
,Choice7
,Choice7._A
,Choice7._B
,Choice7._C
,Choice7._D
,Choice7._E
,Choice7._F
,Choice7._G
,Choice8
,Choice8._A
,Choice8._B
,Choice8._C
,Choice8._D
,Choice8._E
,Choice8._F
,Choice8._G
,Choice8._H
,Clamp
,CmpEq
,CmpEqBy
,CmpEqWith
,Coalesce
,Collapse
,Collapse
,Compare
,Compose
,Compose
,Compose
,Concat
,Cons
,Const
,Constantly
,Cycle
,Difference
,Distinct
,Downcast
,Drop
,DropWhile
,Either
,Either.Left
,Either.Right
,EitherT
,Empty
,Endo
,EndoK
,Eq
,Filter
,Find
,First
,Flatten
,FoldLeft
,FoldRight
,Force
,GroupBy
,GT
,GTBy
,GTE
,GTEBy
,GTEWith
,GTWith
,Head
,Id
,Identity
,IdentityT
,IfThenElse
,InGroupsOf
,Init
,Inits
,Intersection
,Intersperse
,Into
,Into1
,Into3
,Into4
,Into5
,Into6
,Into7
,Into8
,IO
,IO.Compose
,Iterate
,IterateT
,Join
,LambdaIterable
,Last
,Last
,Lazy
,Lazy.Compose
,Lazy.Later
,LazyRec
,LazyT
,LeftAll
,LeftAll
,LeftAny
,LeftAny
,LiftA2
,LiftA3
,LiftA4
,LiftA5
,LiftA6
,LiftA7
,LT
,LTBy
,LTE
,LTEBy
,LTEWith
,LTWith
,Magnetize
,MagnetizeBy
,Map
,Market
,Matching
,Max
,MaxBy
,MaxWith
,Maybe
,Maybe.Just
,Maybe.Nothing
,MaybeT
,Merge
,Merge
,MergeHMaps
,MergeMaps
,Min
,MinBy
,MinWith
,Not
,Occurrences
,Or
,Over
,Partition
,Peek
,Peek2
,Pre
,PrependAll
,Present
,PutAll
,RateLimit
,Re
,ReaderT
,RecursiveResult
,RecursiveResult.Recurse
,RecursiveResult.Terminate
,ReduceLeft
,ReduceRight
,Repeat
,Replicate
,Reverse
,RightAll
,RightAll
,RightAny
,RightAny
,RunAll
,RunAll
,SafeT
,ScanLeft
,Sequence
,Set
,SingletonHList
,Size
,Slide
,Snoc
,Sort
,SortBy
,SortWith
,Span
,State
,StateT
,Tagged
,Tail
,Tails
,Take
,TakeWhile
,These
,These._A
,These._B
,These.Both
,Times
,ToArray
,ToCollection
,ToMap
,Trampoline
,Trivial
,Try
,Try.Failure
,Try.Success
,Tuple2
,Tuple3
,Tuple4
,Tuple5
,Tuple6
,Tuple7
,Tuple8
,Tupler2
,Uncons
,Under
,Unfoldr
,Union
,Until
,Upcast
,View
,Writer
,WriterT
,Xor
,Zip
,ZipWith
An interface representing applicative functors - functors that can have their results combined with other functors
of the same instance in a context-free manner.
The same rules that apply to Functor
apply to Applicative
, along with the following
additional 4 laws:
- identity:
v.zip(pureId).equals(v)
- composition:
w.zip(v.zip(u.zip(pureCompose))).equals((w.zip(v)).zip(u))
- homomorphism:
pureX.zip(pureF).equals(pureFx)
- interchange:
pureY.zip(u).equals(u.zip(pure(f -> f.apply(y))))
Functor
, Applicative
instances that do not satisfy all of the functor laws, as well
as the above applicative laws, are not well-behaved and often break down in surprising ways.
For more information, read about Applicative Functors.
-
Method Summary
Modifier and TypeMethodDescriptiondefault <B> Applicative
<B, App> discardL
(Applicative<B, App> appB) Sequence both thisApplicative
andappB
, discarding thisApplicative's
result and returningappB
.default <B> Applicative
<A, App> discardR
(Applicative<B, App> appB) Sequence both thisApplicative
andappB
, discardingappB's
result and returning thisApplicative
.default <B> Applicative
<B, App> Covariantly transmute this functor's parameter using the given mapping function.default <B> Lazy
<? extends Applicative<B, App>> Given alazy
instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.<B> Applicative
<B, App> pure
(B b) Lift the valueb
into this applicative functor.<B> Applicative
<B, App> zip
(Applicative<Fn1<? super A, ? extends B>, App> appFn) Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
-
Method Details
-
pure
Lift the valueb
into this applicative functor.- Type Parameters:
B
- the type of the returned applicative's parameter- Parameters:
b
- the value- Returns:
- an instance of this applicative over b
-
zip
Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.- Type Parameters:
B
- the resulting applicative parameter type- Parameters:
appFn
- the other applicative instance- Returns:
- the mapped applicative
-
lazyZip
default <B> Lazy<? extends Applicative<B,App>> lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, App>> lazyAppFn) Given alazy
instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports. This is useful for applicatives that support lazy evaluation and early termination.- Type Parameters:
B
- the resulting applicative parameter type- Parameters:
lazyAppFn
- the lazy other applicative instance- Returns:
- the mapped applicative
- See Also:
-
discardL
Sequence both thisApplicative
andappB
, discarding thisApplicative's
result and returningappB
. This is generally useful for sequentially performing side-effects.- Type Parameters:
B
- the type of the returned Applicative's parameter- Parameters:
appB
- the other Applicative- Returns:
- appB
-
discardR
Sequence both thisApplicative
andappB
, discardingappB's
result and returning thisApplicative
. This is generally useful for sequentially performing side-effects.- Type Parameters:
B
- the type of appB's parameter- Parameters:
appB
- the other Applicative- Returns:
- this Applicative
-
fmap
Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.
-