ap

appendFile :: FilePath -> String -> 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]])

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

app :: ArrowApply a => a (a b c, b) c

base Control.Arrow

AppendMode :: IOMode

base System.IO

appEndo :: Endo a -> a -> a

base Data.Monoid

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 <*>.

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.

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.

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).

aP_STACK_SPLIM :: Int

base GHC.Constants

package apelsin

package

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

package appar

package

A simple applicative parser in Parsec style Version 0.1.4

AppE :: Exp -> Exp -> Exp

template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH

> { f x }

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

O_APPEND

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.

AppendOnWrite :: FdOption

unix System.Posix.IO.ByteString, unix System.Posix.IO

O_APPEND

package ApplePush

package

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

package

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 0.2.0.1

applet :: Html -> Html

html Text.Html, xhtml Text.XHtml.Transitional

package applicative-extras

package

Some instances for applicative functors and type-level composition. Forkable on github. Version 0.1.8

package applicative-numbers

package

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 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 "ApplicativeNumeric-inc.hs" #define APPLICATIVE Vec3 #include "ApplicativeNumeric-inc.hs" #define APPLICATIVE Vec4 #include "ApplicativeNumeric-inc.hs" @ 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.0.9

package applicative-quoters

package

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). Version 0.1.0.5

Applied :: NameIs

template-haskell Language.Haskell.TH.Syntax

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

package

Utility to perform approximate randomization tests. Version 0.0.3

package approximate-equality

package

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 :: Type -> Type -> Type

template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH

> T a b

appT :: TypeQ -> TypeQ -> TypeQ

template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH

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.