par :: a -> b -> b
base GHC.Conc.Sync, base GHC.Conc
par :: a -> b -> b
parallel Control.Parallel
Indicates that it may be beneficial to evaluate the first argument in parallel with the second. Returns the value of the second argument. a `par` b is exactly equivalent semantically to b. par is generally used when the value of a is likely to be required later, but not immediately. Also it is a good idea to ensure that a is not a trivial computation, otherwise the cost of spawning it in parallel overshadows the benefits obtained by running it in parallel. Note that actual parallelism is only supported by certain implementations (GHC with the -threaded option, and GPH, for now). On other implementations, par a b = b.
parens :: ReadPrec a -> ReadPrec a
base Text.Read
(parens p) parses "P", "(P0)", "((P0))", etc, p parses "P" in the current precedence context and parses "P0" in precedence context zero
parseVersion :: ReadP Version
base Data.Version
A parser for versions in the format produced by showVersion.
partition :: (a -> Bool) -> [a] -> ([a], [a])
base Data.List
The partition function takes a predicate a list and returns the pair of lists of elements which do and do not satisfy the predicate, respectively; i.e., > partition p xs == (filter p xs, filter (not . p) xs)
partitionEithers :: [Either a b] -> ([a], [b])
base Data.Either
Partitions a list of Either into two lists All the Left elements are extracted, in order, to the first component of the output. Similarly the Right elements are extracted to the second component of the output.
package para
A paragraph formatting utility.  Provided with input text that is arbitrarily split amongst several strings, this utility will reformat the text into paragraphs which do not exceed the specified width.  Paragraphs are delimited by blank lines in the input. Version 1.1
package paragon
Paragon suite Version 0.1.28
paragraph :: Html -> Html
html Text.Html, xhtml Text.XHtml.Strict, xhtml Text.XHtml.Frameset, xhtml Text.XHtml.Transitional
package parallel
This package provides a library for parallel programming. Version
package parallel-io
This package provides combinators for sequencing IO actions onto a thread pool. The thread pool is guaranteed to contain no more unblocked threads than a user-specified upper limit, thus minimizing contention. Furthermore, the parallel combinators can be used reentrantly - your parallel actions can spawn more parallel actions - without violating this property of the thread pool. The package is inspired by the thread Thanks to Neil Mitchell and Bulat Ziganshin for some of the code this package is based on. Version 0.3.3
package parallel-tasks
This library is useful for running a large amount of parallel tasks that run on top of the IO monad, executing them in batches from a work queue. It has several features aimed at monitoring the progress of the tasks and tries to be reasonably efficient (in space and time) for large numbers (millions) of tasks.  There is also caching support available so that the results of running the task can be preserved between runs of the same program, which is useful for doing scientific analysis. Version
package parallel-tree-search
This Haskell library provides an implementation of parallel search based on the search tree provided by the package tree-monad. Version 0.4.1
param :: Html
html Text.Html, xhtml Text.XHtml.Strict, xhtml Text.XHtml.Frameset, xhtml Text.XHtml.Transitional
package parameterized-data
This library provides an implementation of parameterized types using type-level computations to implement the type parameters and emulate dependent types. Right now only fixed-sized vectors are provided. A tutorial on how to use them can be found at Version 0.1.5
parBuffer :: Int -> Strategy a -> Strategy [a]
parallel Control.Parallel.Strategies
Like evalBuffer but evaluates the list elements in parallel when pushing them into the buffer.
package parco
General parser combinators that will work with any parser combinator library.  At the moment, the contents of the library is not particularly structured, and it is extended as I find it necessary. Version 0.1
package parco-attoparsec
Parser monad instance for Attoparsec.  You can easily define this yourself, but it is provided here for convenience. Version 0.1
package parco-parsec
Parser monad instance for Parsec.  You can easily define this yourself, but it is provided here for convenience. Version 0.1
package parcom-lib
Parcom provides parser combinator functionality in a string-type-agnostic way; it supports strict ByteStrings (with Word8 tokens) and any list type (with the element type as the token type) out-of-the-box, including plain old String. Any other stream-of-tokens type can be hooked into the library; unlike Parsec, none of the built-in parsers assumes char-like tokens. Version
package parconc-examples
parens :: Doc -> Doc
pretty Text.PrettyPrint.HughesPJ, pretty Text.PrettyPrint
parens :: Doc -> Doc
template-haskell Language.Haskell.TH.PprLib
Wrap document in (...)
parens :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
parsec Text.Parsec.Token, parsec Text.ParserCombinators.Parsec.Token
Lexeme parser parens p parses p enclosed in parenthesis, returning the value of p.
parensE :: ExpQ -> ExpQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
parensIf :: Bool -> Doc -> Doc
template-haskell Language.Haskell.TH.Ppr
parensP :: PatQ -> PatQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
parentWindow :: GettableStateVar (Maybe Window)
GLUT Graphics.UI.GLUT.Window
Contains the current window\'s parent. If the current window is a top-level window, Nothing is returned.
parList :: Strategy a -> Strategy [a]
parallel Control.Parallel.Strategies
Evaluate each element of a list in parallel according to given strategy. Equivalent to parTraversable at the list type.
parListChunk :: Int -> Strategy a -> Strategy [a]
parallel Control.Parallel.Strategies
Divides a list into chunks, and applies the strategy evalList strat to each chunk in parallel. It is expected that this function will be replaced by a more generic clustering infrastructure in the future. If the chunk size is 1 or less, parListChunk is equivalent to parList
parListN :: Int -> Strategy a -> Strategy [a]
parallel Control.Parallel.Strategies
Like evalListN but evaluates the first n elements in parallel.
parListNth :: Int -> Strategy a -> Strategy [a]
parallel Control.Parallel.Strategies
Like evalListN but evaluates the nth element in parallel.
parListSplitAt :: Int -> Strategy [a] -> Strategy [a] -> Strategy [a]
parallel Control.Parallel.Strategies
Like evalListSplitAt but evaluates both sublists in parallel.
parMap :: Strategy b -> (a -> b) -> [a] -> [b]
parallel Control.Parallel.Strategies
A combination of parList and map, encapsulating a common pattern: > parMap strat f = withStrategy (parList strat) . map f
parPair :: Strategy a -> Strategy b -> Strategy (a, b)
parallel Control.Parallel.Strategies
DEPRECATED: renamed to parTuple2
package parport
This is a simple library that lets you read and write pins on the parallel port. It is mainly intended for controlling and regulating hardware. Version 0.0.0
parS :: [[StmtQ]] -> StmtQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
parse :: Stream s Identity t => Parsec s () a -> SourceName -> s -> Either ParseError a
parsec Text.Parsec.Prim, parsec Text.ParserCombinators.Parsec.Prim
parse p filePath input runs a parser p over Identity without user state. The filePath is only used in error messages and may be the empty string. Returns either a ParseError (Left) or a value of type a (Right). > main = case (parse numbers "" "11, 2, 43") of > Left err -> print err > Right xs -> print (sum xs) > > numbers = commaSep integer
package parse-dimacs
A DIMACS CNF parser library, implemented with Parsec 3, using ByteStrings. DIMACS CNF is a file format for describing constraint problems in conjunctive normal form. Version 1.3
package parse-help
see http:github.comgregwebscmdargs-help Version 0.0

Show more results