app -package:tuple-sop

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 :: 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 s e n
brick Brick.Main
The library application abstraction. Your application's operations are provided in an App and then the App is provided to one of the various main functions in this module. An application App s e n is in terms of an application state type s, an application event type e, and a resource name type n. In the simplest case e is unused (left polymorphic or set to ()), but you may define your own event type and use customMain to provide custom events. The state type s is the type of application state to be provided by you and iteratively modified by event handlers. The resource name type n is the type of names you can assign to rendering resources such as viewports and cursor locations. Your application must define this type.
App :: (s -> [Widget n]) -> (s -> [CursorLocation n] -> Maybe (CursorLocation n)) -> (BrickEvent n e -> EventM n s ()) -> EventM n s () -> (s -> AttrMap) -> App s e n
brick Brick.Main