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

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)

applyPick :: forall input err a. input -> PickE input err a -> ValidatedE err a

Task.mapN -> liftN

applyFirst :: forall a b f. Apply f => f a -> f b -> f a

Combine two effectful actions, keeping only the result of the first.

The Apply instance allows functions contained within a Just to transform a value contained within a Just using the apply operator:

Just f <*> Just x == Just (f x)

Nothing values are left untouched:

Just f <*> Nothing == Nothing
Nothing <*> Just x == Nothing

Combining Functor's <$> with Apply's <*> can be used transform a pure function to take Maybe-typed arguments so f :: a -> b -> c becomes f :: Maybe a -> Maybe b -> Maybe c:

f <$> Just x <*> Just y == Just (f x y)

The Nothing-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Nothing means the whole result becomes Nothing also:

f <$> Nothing <*> Just y == Nothing
f <$> Just x <*> Nothing == Nothing
f <$> Nothing <*> Nothing == Nothing

The Apply instance allows functions to transform the contents of a Tuple with the <*> operator whenever there is a Semigroup instance for the fst component, so:

(Tuple a1 f) <*> (Tuple a2 x) == Tuple (a1 <> a2) (f x)

applyMaybe :: forall f a b. Apply f => Compactable f => f (a -> Maybe b) -> f a -> f b

applyThird :: forall x y z a. (y -> z -> x -> a) -> x -> y -> z -> a

\f x y z -> f y z x

applyFirst :: forall v1 v0 f c. HasApply c f => HasConst c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (f v0) => ObjectOf c (f v1) => ObjectOf c (c v1 v0) => ObjectOf c (f (c v1 v0)) => ObjectOf c (c v0 (c v1 v0)) => ObjectOf c (c (f v1) (f v0)) => ObjectOf c (c (f v1) (f v0)) => ObjectOf c (f (c v0 (c v1 v0))) => ObjectOf c (c (f v0) (f (c v1 v0))) => Restrictable Function c => Slackable c => f v0 -> c (f v1) (f v0)

applyFirst :: forall v1 v0 f c. HasApply c f => HasConst c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v0) => f v0 -> f v1 -> f v0

applyFirst :: forall a d. Syntax d => d a -> d Unit -> d a

This variant of <*> ignores its right result. In contrast to its counterpart derived from the Apply class, the ignored parts have type d Unit rather than d b because otherwise information relevant for pretty-printing would be lost.

applyPatch :: forall eff. Element -> View (dom :: DOM | eff) -> ViewChanges (dom :: DOM | eff) -> Eff (dom :: DOM | eff) Unit

Apply a set of ViewChanges to the DOM, under the given Node, which should be the same as the one initially passed to render.

The second argument is the most-recently rendered View, i.e. the one which should correspond to the current state of the DOM.

Note: in order to correctly remove event listeners, the View passed in must contain the same event listeners as those last attached, by reference. In practice, this means that the View passed into this function should be obtained using the patch function.

See the implementation of the run function for an example.

applyTuple :: forall f a b. Apply f => f a -> f b -> f (a /\ b)

applySecond :: forall a b f. Apply f => f a -> f b -> f b

Combine two effectful actions, keeping only the result of the second.

The Apply instance allows functions contained within a Right to transform a value contained within a Right using the (<*>) operator:

Right f <*> Right x == Right (f x)

Left values are left untouched:

Left f <*> Right x == Left f
Right f <*> Left y == Left y

Combining Functor's <$> with Apply's <*> can be used to transform a pure function to take Either-typed arguments so f :: a -> b -> c becomes f :: Either l a -> Either l b -> Either l c:

f <$> Right x <*> Right y == Right (f x y)

The Left-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Left means the whole result becomes Left also, taking the first Left value found:

f <$> Left x <*> Right y == Left x
f <$> Right x <*> Left y == Left y
f <$> Left x <*> Left y == Left x

Runs effects in parallel, combining their results.

applyEither :: forall f a l r. Apply f => Compactable f => f (a -> Either l r) -> f a -> { left :: f l, right :: f r }

applyFourth :: forall w x y z a. (x -> y -> z -> w -> a) -> w -> x -> y -> z -> a

\f w x y z -> f x y z w

applyMethod :: forall o a b. String -> o -> a -> b

Lookup and apply the method with the given name on the given object to the given this and an array or pseudoarray of arguments

applySecond :: forall x y a. (y -> x -> a) -> x -> y -> a

\f x y -> f y x

(flip)

applySecond :: forall v1 v0 f c. HasApply c f => HasConst c => HasIdentity c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (f v0) => ObjectOf c (f v1) => ObjectOf c (c v1 v1) => ObjectOf c (f (c v1 v1)) => ObjectOf c (c v0 (c v1 v1)) => ObjectOf c (c (f v1) (f v1)) => ObjectOf c (f (c v0 (c v1 v1))) => ObjectOf c (c (f v0) (f (c v1 v1))) => ObjectOf c (c (c v1 v1) (c v0 (c v1 v1))) => Restrictable Function c => Slackable c => f v0 -> c (f v1) (f v1)

applySecond :: forall v1 v0 f c. HasApply c f => HasConst c => HasIdentity c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v1) => ObjectOf c (c v0 (c v1 v1)) => ObjectOf c (c (c v1 v1) (c v0 (c v1 v1))) => f v0 -> f v1 -> f v1

applyDataUi :: forall html fm fs msg1 msg2 sta1 sta2 a1 a2. { extract :: Extract sta1 a1 -> Extract sta2 a2, init :: Init sta1 a1 -> Init sta2 a2, name :: String, update :: Update msg1 sta1 -> Update msg2 sta2, view :: View html msg1 sta1 -> View html msg2 sta2 } -> DataUI html fm fs msg1 sta1 a1 -> DataUI html fm fs msg2 sta2 a2

applyConfig :: forall a. JsonConfig -> { maxX :: Int, maxY :: Int } -> Map a Pos -> Map a EnrichedPos

applyEither :: forall e a b. Semigroup e => Either e (a -> b) -> Either e a -> Either e b

applyMatrix :: P5 -> Number -> Number -> Number -> Number -> Number -> Number -> (Effect Unit)

p5js.org documentation

applyPolicy :: forall m. MonadAff m => RetryPolicyM m -> RetryStatus -> m (Maybe RetryStatus)

Apply policy on status to see what the decision would be. 'Nothing' implies no retry, 'Just' returns updated status.

The Apply instance allows functions contained within a Ok to transform a value contained within a Ok using the (<*>) operator:

Ok f <*> Ok x == Ok (f x)

Error values are left untouched:

Error f <*> Ok x == Error x
Ok f <*> Error y == Error y

Combining Functor's <$> with Apply's <*> can be used to transform a pure function to take Result-typed arguments so f :: a -> b -> c becomes f :: Result l a -> Result l b -> Result l c:

f <$> Ok x <*> Ok y == Ok (f x y)

The Error-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Error means the whole result becomes Error also, taking the first Error value found:

f <$> Error x <*> Ok y == Error x
f <$> Ok x <*> Error y == Error y
f <$> Error x <*> Error y == Error x

applySecond :: forall a d. Syntax d => d Unit -> d a -> d a

This variant of <*> ignores its left result. In contrast to its counterpart derived from the Apply class, the ignored parts have type d Unit rather than d b because otherwise information relevant for pretty-printing would be lost.