Search results
The Apply
class provides the (<*>)
which is used to apply a function
to an argument under a type constructor.
Apply
can be used to lift functions of two or more arguments to work on
values wrapped with the type constructor f
. It might also be understood
in terms of the lift2
function:
lift2 :: forall f a b c. Apply f => (a -> b -> c) -> f a -> f b -> f c
lift2 f a b = f <$> a <*> b
(<*>)
is recovered from lift2
as lift2 ($)
. That is, (<*>)
lifts
the function application operator ($)
to arguments wrapped with the
type constructor f
.
Put differently...
foo =
functionTakingNArguments <$> computationProducingArg1
<*> computationProducingArg2
<*> ...
<*> computationProducingArgN
Instances must satisfy the following law in addition to the Functor
laws:
- Associative composition:
(<<<) <$> f <*> g <*> h = f <*> (g <*> h)
Formally, Apply
represents a strong lax semi-monoidal endofunctor.
apply :: forall f a b. Apply f => f (a -> b) -> f a -> f b
apply :: forall a b. (a -> b) -> a -> b
Applies a function to an argument. This is primarily used as the operator
($)
which allows parentheses to be omitted in some cases, or as a
natural way to apply a chain of composed functions to a value.
Polymorphic Type application
For example...
APPLY Maybe Int == Maybe $ Int == Maybe Int
apply :: forall m a b x y z. IxApply m => m x y (a -> b) -> m y z a -> m x z b
apply :: App -> Application -> Effect Unit
Apply App actions to existent Express.js application
apply :: forall c f v1 v0. HasApply c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v0 v1) => f (c v0 v1) -> c (f v0) (f v1)
apply :: forall c f v1 v0. HasApply c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v0 v1) => f (c v0 v1) -> f v0 -> f v1
apply :: forall b a. NotJSPromise a => NotJSPromise b => PromiseSpec (a -> b) -> PromiseSpec a -> PromiseSpec b
apply a function to a value inside promise specs
apply :: forall b a. Jet (Atomic (a -> b)) -> Jet (Atomic a) -> Jet (Atomic b)
Combine two Atomic
values in an applicative style.
apply :: forall b a. Iso a b -> a -> Maybe b
apply :: forall e. Server e -> Server -> RestifyM e Unit
Apply Server actions to a Restify server.
apply :: forall r. Array (Setting UnresolvedValue) -> Run (CHILD_PROCESS + ENVIRONMENT + r) Unit
Applies the specified settings to the environment.
apply :: forall b a f. f -> Array a -> b
apply :: forall b a m r. Format m r (a -> b) -> a -> Format m r b
Apply the first argument of the formatter, without unwrapping it to a plain ol' function.
apply :: forall f b a. ProductFunctor f => f a -> f b -> f (Tuple a b)
apply :: forall t1 f x y a b. Semigroupal Function t1 Tuple Tuple f => Functor (f (t1 x y)) => f x (a -> b) -> f y a -> f (t1 x y) b
apply :: forall f a b. Semigroupal Function Tuple Tuple f => Functor f => f (a -> b) -> f a -> f b
apply :: forall t1 t2 f a1 b1 a2 b2 a b. Semigroupal Function t1 t2 Tuple Tuple f => Functor (f (t1 a1 b1) (t2 a2 b2)) => f a1 a2 (a -> b) -> f b1 b2 a -> f (t1 a1 b1) (t2 a2 b2) b
apply :: forall a c b. HasApply a => a (b -> c) -> a b -> a c
apply :: forall f m a b. Parallel f m => m (a -> b) -> m a -> m b
apply :: forall a b f. Codensity f (a -> b) -> Codensity f a -> Codensity f b
apply :: forall a b f g. (g ~> f) -> Ran f g (a -> b) -> Ran f g a -> Ran f g b
apply :: forall e. Router e -> Router -> RestifyM e Unit
Apply Router actions to a Restify router.
apply :: forall r dom img. Expr r dom => Expr r img => Z3Function r dom img -> dom -> img
apply :: forall r dom img. Fn2 (Z3Function r dom img) dom img
applyN :: forall a. (a -> a) -> Int -> a -> a
applyN f n
applies the function f
to its argument n
times.
If n is less than or equal to 0, the function is not applied.
applyN (_ + 1) 10 0 == 10
apply_ :: forall b a s w r. Semigroup w => RWS r w s (a -> b) -> RWS r w s a -> RWS r w s b
applyR :: forall b a r. Reader r (a -> b) -> Reader r a -> Reader r b
applyS :: forall b a. Behavior (a -> b) -> Stream a -> Stream b
This function is similar to apply
for behaviors except the last argument
is a stream instead of a behaviors. Whenever the stream has an occurrence
the function at the behavior is applied to the value of the occurrence.
This function has an operator alias <~>
. The operator is intended to work
in tandem with <$>
and <*>
. As an example, assume that f3
is a
function of three arguments, that b1
and b2
are two behaviors, and that
s
is a stream.` Then the function can be applied to the two behaviors and
the stream in the following way.
f3 <$> b1 <*> b2 <~> s
With the above code, whenever s
has an occurrence the value of b1
,
b2
, and the value of the occurrence will be applied to f3
and its
return value will be the value of the occurrence in the resulting stream.
Semantically.
applyS b s = map (\{time, a} -> {time, a: (b time) a}) s
applyS :: forall b a s. State s (a -> b) -> State s a -> State s b
applyW :: forall b a w. Semigroup w => Writer w (a -> b) -> Writer w a -> Writer w b
apply2 :: forall r dom1 dom2 img. Expr r dom1 => Expr r dom2 => Expr r img => Z3Function2 r dom1 dom2 img -> dom1 -> dom2 -> img
apply2 :: forall r dom1 dom2 img. Fn3 (Z3Function2 r dom1 dom2 img) dom1 dom2 img
applyS :: forall @f @a @b. Select f => f (a -> b) -> f a -> f b
apply
implemented in terms of select
applyOp :: forall event a b. Applicative event => event a -> event (a -> b) -> event b
applyTo :: forall f this a b. f -> this -> a -> b
Apply a function to a this object with the given arguments
applyTo :: forall res list row a. RowToList row list => RFold (ApplyS a) list row (Builder (Record ()) (Record res)) => a -> Record row -> Record res