seq -package -parallel

seq :: a -> b -> b
base Prelude
Evaluates its first argument to head normal form, and then returns its second argument as the result.
sequence :: Monad m => [m a] -> m [a]
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and collect the results.
sequence_ :: Monad m => [m a] -> m ()
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and ignore the results.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
base Data.Traversable
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
base Data.Foldable
Evaluate each monadic action in the structure from left to right, and ignore the results.
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
base Data.Traversable
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
base Data.Foldable
Evaluate each action in the structure from left to right, and ignore the results.
sequenceQ :: [Q a] -> Q [a]
template-haskell Language.Haskell.TH.Syntax
data Seq a
containers Data.Sequence
General-purpose finite sequences.
module Data.Sequence
containers Data.Sequence
General purpose finite sequences. Apart from being finite and having strict operations, sequences also differ from lists in supporting a wider variety of operations efficiently. An amortized running time is given for each operation, with n referring to the length of the sequence and i being the integral index used by some operations. These bounds hold even in a persistent (shared) setting. The implementation uses 2-3 finger trees annotated with sizes, as described in section 4.2 of * Ralf Hinze and Ross Paterson, "Finger trees: a simple general-purpose data structure", Journal of Functional Programming 16:2 (2006) pp 197-217. http://www.soi.city.ac.uk/~ross/papers/FingerTree.html Note: Many of these operations have the same names as similar operations on lists in the Prelude. The ambiguity may be resolved using either qualification or the hiding clause.
SeqPacket :: SocketType
network Network.Socket
SOCK_SEQPACKET
module Text.Regex.Posix.Sequence
regex-posix Text.Regex.Posix.Sequence
This provides String instances for RegexMaker and RegexLike based on Text.Regex.Posix.Wrap, and a (RegexContext Regex String String) instance. To use these instance, you would normally import Text.Regex.Posix. You only need to import this module to use the medium level API of the compile, regexec, and execute functions. All of these report error by returning Left values instead of undefined or error or fail.
eILSEQ :: Errno
base Foreign.C.Error
subsequences :: [a] -> [[a]]
base Data.List
The subsequences function returns the list of all subsequences of the argument. > subsequences "abc" == ["","a","b","ab","c","ac","bc","abc"]
ArithSeqE :: Range -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> { [ 1 ,2 .. 10 ] }
arithSeqE :: RangeQ -> ExpQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
type ClauseQ = Q Clause
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
closeQuick :: HStream bufType => HandleStream bufType -> IO ()
HTTP Network.TCP
module Control.DeepSeq
deepseq Control.DeepSeq
This module provides an overloaded function, deepseq, for fully evaluating data structures (that is, evaluating to "Normal Form"). A typical use is to prevent resource leaks in lazy IO programs, by forcing all characters from a file to be read. For example: > import System.IO > import Control.DeepSeq > > main = do > h <- openFile "f" ReadMode > s <- hGetContents h > s `deepseq` hClose h > return s deepseq differs from seq as it traverses data structures deeply, for example, seq will evaluate only to the first constructor in the list: > > [1,2,undefined] `seq` 3 > 3 While deepseq will force evaluation of all the list elements: > > [1,2,undefined] `deepseq` 3 > *** Exception: Prelude.undefined Another common use is to ensure any exceptions hidden within lazy fields of a data structure do not leak outside the scope of the exception handler, or to force evaluation of a data structure in one thread, before passing to another thread (preventing work moving to the wrong threads).
deepseq :: NFData a => a -> b -> b
deepseq Control.DeepSeq
deepseq: fully evaluates the first argument, before returning the second. The name deepseq is used to illustrate the relationship to seq: evaluates the top level of its argument, deepseq traverses the entire data structure evaluating it completely. deepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the parallel package). There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use pseq from Control.Parallel in the parallel package.

Show more results