ap :: Monad m => m (a -> b) -> m a -> m b
base Control.Monad
In many situations, the liftM operations can be replaced by uses of ap, which promotes function application. > return f `ap` x1 `ap` ... `ap` xn is equivalent to > liftMn f x1 x2 ... xn
ap :: Graph gr => gr a b -> [Node]
fgl Data.Graph.Inductive.Query.ArtPoint
Finds the articulation points for a connected undirected graph, by using the low numbers criteria: a) The root node is an articulation point iff it has two or more children. b) An non-root node v is an articulation point iff there exists at least one child w of v such that lowNumber(w) >= dfsNumber(v).
appendFile :: FilePath -> String -> IO ()
base Prelude, base System.IO
The computation appendFile file str function appends the string str, to the file file. Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first. > main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
app :: ArrowApply a => a (a b c, b) c
base Control.Arrow
appEndo :: Endo a -> a -> a
base Data.Monoid
approxRational :: RealFrac a => a -> a -> Rational
base Data.Ratio
approxRational, applied to two real fractional numbers x and epsilon, returns the simplest rational number within epsilon of x. A rational number y is said to be simpler than another y' if * abs (numerator y) <= abs (numerator y'), and * denominator y <= denominator y'. Any real interval contains a unique simplest rational; in particular, note that 0/1 is the simplest rational of all.
package apache-md5
Haskell implementation of Apache HTTP server specific MD5 digest algorithm that uses OpenSSL MD5() function. README and ChangeLog can be found in source code package and on GitHub: * https://github.com/trskop/apache-md5/blob/master/README.md * https://github.com/trskop/apache-md5/blob/master/ChangeLog.md Version
package apelsin
A gtk2hs server and clan browser for the open source game Tremulous http://tremulous.net. Both Tremulous 1.1 and GPP are supported. Features filtering, player search, a list of online clan members, a clan list and basic perferences. Version 1.2.3
package appar
A simple applicative parser in Parsec style Version 0.1.4
appE :: ExpQ -> ExpQ -> ExpQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
append :: ByteString -> ByteString -> ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(n) Append two ByteStrings
append :: ByteString -> ByteString -> ByteString
bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
O(n\c)/ Append two ByteStrings
append :: OpenFileFlags -> Bool
unix System.Posix.IO.ByteString, unix System.Posix.IO
append :: Text -> Text -> Text
text Data.Text
O(n) Appends one Text to the other by copying both of them into a new Text. Subject to fusion.
append :: Text -> Text -> Text
text Data.Text.Lazy
O(n\c)/ Appends one Text to another. Subject to fusion.
appendFile :: FilePath -> ByteString -> IO ()
bytestring Data.ByteString, bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
Append a ByteString to a file.
appendFile :: FilePath -> Text -> IO ()
text Data.Text.IO, text Data.Text.Lazy.IO
Write a string the end of a file.
appK :: Kind -> Kind -> Kind
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
applet :: Html -> Html
html Text.Html, xhtml Text.XHtml.Transitional
package applicative-extras
Some instances for applicative functors and type-level composition. Forkable on github. Version 0.1.8
package applicative-numbers
Any applicative functor can be given numeric instances in a boilerplate way. The applicative-numbers package provides an include file that makes it a snap to define these instances. See Data.Numeric.Function for an example. Project wiki page: http://haskell.org/haskellwiki/applicative-numbers Copyright 2009-2013 Conal Elliott; BSD3 license. Instances of Num classes for applicative functors.  To be #include'd after defining APPLICATIVE as the applicative functor name and CONSTRAINTS as a list of constraints, which must carry its own trailing comma if non-empty. The APPLICATIVE symbol gets #undef'd at the end of the include file, so that multiple includes are convenient. For instance, @ #define INSTANCE_Ord #define INSTANCE_Enum #define APPLICATIVE Vec2 #include &quot;ApplicativeNumeric-inc.hs&quot; #define APPLICATIVE Vec3 #include &quot;ApplicativeNumeric-inc.hs&quot; #define APPLICATIVE Vec4 #include &quot;ApplicativeNumeric-inc.hs&quot; @ You'll also have to import pure and liftA2 from Control.Applicative and specify the FlexibleContexts language extension (due to an implementation hack). Some instances are generated only if a corresponding CPP symbol is defined: INSTANCE_Eq, INSTANCE_Ord, INSTANCE_Show, INSTANCE_Enum Version 0.1.2
package applicative-quoters
Quasiquoters taken from Matt Morrow's haskell-src-meta to implement Conor McBride's idiom brackets, and a do-notation that only requires Applicative (and is correspondingly less powerful). applicative-quoters currently has no maintainer: if it is broken and you want it to be fixed, then fix it! Version
apply :: Fun a b -> (a -> b)
QuickCheck Test.QuickCheck.Function
apply :: GT m g a -> m g -> m (a, g)
fgl Data.Graph.Inductive.Query.Monad
apply' :: Monad m => GT m g a -> g -> m (a, g)
fgl Data.Graph.Inductive.Query.Monad
applyWith :: Monad m => (a -> b) -> GT m g a -> m g -> m (b, g)
fgl Data.Graph.Inductive.Query.Monad
applyWith' :: Monad m => (a -> b) -> GT m g a -> g -> m (b, g)
fgl Data.Graph.Inductive.Query.Monad
package approx-rand-test
Functions and utilities to perform paired and unpaired approximate randomization tests (Noreen, 1989). The utilities can also draw histograms of the applications of the test statistic to the randomized samples. For support for more file formats, install the package with the -withCairo flag. Version 0.2.1
package approximate
This package provides approximate discrete values and numbers. Version 0.2
package approximate-equality
The purpose of this module is to provide newtype wrappers that allow one to effectively override the equality operator of a value so that it is approximate rather than exact. The wrappers use type annotations to specify the tolerance; the Digits type constructor has been provided for specifying the tolerance using type-level natural numbers.  Instances for all of the classes in the numerical hierarchy have been provided for the wrappers, so the wrapped values can mostly be used in the same way as the original values. (In fact, most of the time one doesn't even have to wrap the starting values, since expressions such as (1+sqrt 2/3) are automatically wrapped thanks to the fromIntegral method of the Num typeclass.) See the documentation for Data.Eq.Approximate for more detailed information on how to use this package. New in version 1.1:  Added explicit Show constraints to the Show instances, as the Num class in the newest version of GHC (wisely) no longer includes Show as a constraint. Version 1.1
appsE :: [ExpQ] -> ExpQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
appT :: TypeQ -> TypeQ -> TypeQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
AppendMode :: IOMode
base System.IO
class Functor f => Applicative f
base Control.Applicative
A functor with application. Instances should satisfy the following laws: * identity pure id <*> v = v * composition pure (.) <*> u <*> v <*> w = u <*> (v <*> w) * homomorphism pure f <*> pure x = pure (f x) * interchange u <*> pure y = pure ($ y) <*> u * ignore left value u *> v = pure (const id) <*> u <*> v * ignore right value u <* v = pure const <*> u <*> v The Functor instance should satisfy > fmap f x = pure f <*> x If f is also a Monad, define pure = return and (<*>) = ap. Minimal complete definition: pure and <*>.
module Control.Applicative
base Control.Applicative
This module describes a structure intermediate between a functor and a monad: it provides pure expressions and sequencing, but no binding. (Technically, a strong lax monoidal functor.) For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html. This interface was introduced for parsers by Niklas Röjemo, because it admits more sharing than the monadic interface. The names here are mostly based on recent parsing work by Doaitse Swierstra. This class is also useful with instances of the Data.Traversable.Traversable class.
base GHC.Constants
AppE :: Exp -> Exp -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> { f x }
AppendOnWrite :: FdOption
unix System.Posix.IO.ByteString, unix System.Posix.IO
package ApplePush
This library provides an interface to send notifications with the Apple Push Notification Service. Note: Your connection to Apple's Push Notification service must be secured with SSL. Currently, Haskell's support for SSL is incomplete, therefore you should use an SSL tunnel to connect your application to the push service, such as                       stunnel. Version 0.1
package AppleScript
This package enables you to compile and execute AppleScript code from Haskell, and provides support for this AppleScript code to call back into Haskell. To get started, see Foreign.AppleScript.Rich. Version
Applied :: NameIs
template-haskell Language.Haskell.TH.Syntax
AppT :: Type -> Type -> Type
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> T a b
April :: Month
old-time System.Time
module Graphics.Rendering.OpenGL.GL.Texturing.Application
OpenGL Graphics.Rendering.OpenGL.GL.Texturing.Application
This module corresponds to section 3.8.15 (Texture Application) of the OpenGL 2.1 specs.
concatMap :: (a -> [b]) -> [a] -> [b]
base Prelude, base Data.List
Map a function over a list and concatenate the results.
fmap :: Functor f => (a -> b) -> f a -> f b
base Prelude, base Data.Functor, base Control.Monad, base Control.Monad.Instances
map :: (a -> b) -> [a] -> [b]
base Prelude, base Data.List
map f xs is the list obtained by applying f to each element of xs, i.e., > map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] > map f [x1, x2, ...] == [f x1, f x2, ...]
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
base Prelude, base Control.Monad
mapM f is equivalent to sequence . map f.
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
base Prelude, base Control.Monad
mapM_ f is equivalent to sequence_ . map f.
class Arrow a => ArrowApply a
base Control.Arrow
Some arrows allow application of arrow inputs to other inputs.
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
base Data.Foldable
Map a function over all the elements of a container and concatenate the resulting lists.
dynApp :: Dynamic -> Dynamic -> Dynamic
base Data.Dynamic
dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
base Data.Dynamic
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
base Data.Traversable
This function may be used as a value for fmap in a Functor instance.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
base Data.Foldable
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
base Data.Traversable
This function may be used as a value for Data.Foldable.foldMap in a Foldable instance.
gmapM :: (Data a, Monad m) => (forall d. Data d => d -> m d) -> a -> m a
base Data.Data
gmapMo :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
base Data.Data
gmapMp :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
base Data.Data
gmapQ :: Data a => (forall d. Data d => d -> u) -> a -> [u]
base Data.Data

Show more results