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

applyEnd :: forall a. WrapRule a -> Doc a

applyDir :: forall a dir args. IsSymbol dir => Proxy dir -> args -> a -> ApplyDirective dir args a

Apply a directive

applyPoly :: forall a. Eq a => Semiring a => Polynomial (Square a) -> Square a -> Square a

Polynomial application

applyWrap :: forall srf fm fs msg sta a. DataUI srf fm fs msg sta a -> DataUI srf fm fs (fm msg) (fs sta) a

applyCons :: forall f a. Apply f => f a -> f (Array a) -> f (Array a)

applyImpl :: forall a b. AffList (a -> b) -> AffList a -> AffList b