app -package:brick

app :: ArrowApply a => a (a b c, b) c
base Control.Arrow, base-prelude BasePrelude, ghc-internal GHC.Internal.Control.Arrow, rebase Rebase.Prelude, rhine FRP.Rhine
app :: FastString -> [JStgExpr] -> JStgExpr
ghc GHC.JS.Make
an application expression, see related appS 
app f xs ==> f(xs)
app :: Exp () -> Exp () -> Exp ()
haskell-src-exts Language.Haskell.Exts.Build
Application of expressions by juxtaposition.
app :: Numeric t => Matrix t -> Vector t -> Vector t
hmatrix Numeric.LinearAlgebra.HMatrix
app :: forall m n . (Domain field vec mat, KnownNat m, KnownNat n) => mat m n -> vec n -> vec m
hmatrix Numeric.LinearAlgebra.Static
app :: FastString -> [JStgExpr] -> JStgExpr
ghc-lib-parser GHC.JS.Make
an expression application, see related appS 
app f xs ==> f(xs)
app :: Expr -> [NamedArg Expr] -> Expr
Agda Agda.Syntax.Abstract
app :: Builder -> [Builder] -> Builder
what4 What4.Protocol.SMTWriter
app :: ((es :+: es) ~ es, Mergeable es es es, Monoid r) => Sig s es (a -> b) r -> Sig s es a r -> Sig s es b r
moffy Control.Moffy.NoThreadId
app :: App event (m :: Type -> Type) -> AppData event m VALID
morpheus-graphql-app Data.Morpheus.App
app :: (Sequence sq, Funable f) => Fun s sq f t a b -> a -> Freer s sq f t b
freer-par-monad Control.Monad.Freer.Par
app :: (KnownNat m, KnownNat n, Domain field vec mat, Transposable (mat m n) (mat n m), Backprop (mat m n), Backprop (vec n), Reifies s W) => BVar s (mat m n) -> BVar s (vec n) -> BVar s (vec m)
hmatrix-backprop Numeric.LinearAlgebra.Static.Backprop
app :: IOMcn (IOMcn a b, a) b
io-machine IOMcn
app :: App f s t => f -> s -> t
tuple-sop Data.Tuple.Ops
Applies a monomorphic function to the first element of an n-ary tuple that matches the type of the argument of the function. 
>>> app not ('d',True)
('d',False)
Sometimes it is necessary to specify the result type, such that the function becomes monomorphic >>> app (+1) (True,5) :: (Bool,Integer) (True,6) One may also use appPoly, which doesn't require specifying the result type. However it can only apply functions to the first element of an n-ary tuple.
app :: Monad m => Valor i m (a -> b) -> Valor i m a -> Valor i m b
valor Data.Valor
An alias for <*>.
app :: IO ()
hinfo Hinfo
app :: Application
pandoc-server Text.Pandoc.Server
app :: AppM ()
ws App
pattern App :: forall k2 t k1 a b . () => t ~ a b => TypeRep a -> TypeRep b -> TypeRep t
base Type.Reflection
A type application. For instance, 
typeRep @(Maybe Int) === App (typeRep @Maybe) (typeRep @Int)
Note that this will also match a function type, 
typeRep @(Int# -> Char)
===
App (App arrow (typeRep @Int#)) (typeRep @Char)
where arrow :: TypeRep ((->) :: TYPE IntRep -> Type -> Type).
App :: Expr b -> Arg b -> Expr b
ghc GHC.Core
module GHC.Tc.Gen.App
ghc
App :: l -> Exp l -> Exp l -> Exp l
haskell-src-exts Language.Haskell.Exts.Syntax
ordinary application
module Text.Pandoc.App
pandoc
Does a pandoc conversion based on command-line options.
App :: Expr s a -> Expr s a -> Expr s a
dhall Dhall.Core
App f a                                  ~  f a
data App
clay Clay.Stylesheet