Seq -parallel

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. 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
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.
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.
package seqloc
Handle sequence locations for bioinformatics Version
package seqloc-datafiles
Read and write BED and GTF format genome annotations Version
sequenceQ :: [Q a] -> Q [a]
template-haskell Language.Haskell.TH.Syntax
package sequential-index
Sequential index numbers between 0.0 and 1.0 that allow arbitrarily inserting new numbers in between. They can possibly used for disk-based and other special containers, where adding a new element without changing the indexes of the other elements is important. Conceptually, SequentialIndex denotes a path to an element in an imaginary binary tree. However, leafs can only be on the right side of their parent. I.e. the path must end with a '1' (or be the path to the root node, 0.0). 1.0 denotes the invalid node. Version
package sequor
A sequence labeler based on Collins's sequence perceptron. Version 0.4.2
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"]
package alsa-seq
This package provides access to ALSA sequencer (MIDI support). For audio support see alsa-pcm. Included are some simple example programs. For more example programs including a GUI, see the alsa-gui programs. Version
package alsa-seq-tests
Tests for the ALSA sequencer library. Version 0.1

Show more results