Int -> a -> [a] -base

chunksOf :: Int -> Text -> [Text]
text Data.Text
O(n) Splits a Text into components of length k. The last element may be shorter than the other chunks, depending on the length of the input. Examples: > chunksOf 3 "foobarbaz" == ["foo","bar","baz"] > chunksOf 4 "haskell.org" == ["hask","ell.","org"]
vectorOf :: Int -> Gen a -> Gen [a]
QuickCheck Test.QuickCheck.Gen, QuickCheck Test.QuickCheck
Generates a list of the given length.
elemAt :: Int -> Set a -> a
containers Data.Set
O(log n). Retrieve an element by its index, i.e. by its zero-based index in the sorted sequence of elements. If the index is out of range (less than zero, greater or equal to size of the set), error is called. > elemAt 0 (fromList [5,3]) == 3 > elemAt 1 (fromList [5,3]) == 5 > elemAt 2 (fromList [5,3]) Error: index out of range
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.
pseq :: a -> b -> b
parallel Control.Parallel
Semantically identical to seq, but with a subtle operational difference: seq is strict in both its arguments, so the compiler may, for example, rearrange a `seq` b into b `seq` a `seq` b. This is normally no problem when using seq to express strictness, but it can be a problem when annotating code for parallelism, because we need more control over the order of evaluation; we may want to evaluate a before b, because we know that b has already been sparked in parallel with par. This is why we have pseq. In contrast to seq, pseq is only strict in its first argument (as far as the compiler is concerned), which restricts the transformations that the compiler can do, and ensures that the user can retain control of the evaluation order.
after :: Extract source => Int -> source -> source
regex-base Text.Regex.Base.RegexLike
before :: Extract source => Int -> source -> source
regex-base Text.Regex.Base.RegexLike
findWithDefault :: a -> Key -> IntMap a -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(min(n,W)). The expression (findWithDefault def k map) returns the value at key k or returns def when the key is not an element of the map. > findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x' > findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'
index :: Seq a -> Int -> a
containers Data.Sequence
O(log(min(i,n-i))). The element at the specified position, counting from 0. The argument should thus be a non-negative integer less than the size of the sequence. If the position is out of range, index fails with an error.
sp :: (Graph gr, Real b) => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.SP
esp :: Graph gr => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.BFS
number :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
short :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
drop :: Int -> ByteString -> ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(1) drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs.
take :: Int -> ByteString -> ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(1) take n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n > length xs.
unsafeDrop :: Int -> ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of drop which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
unsafeTake :: Int -> ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of take which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
drop :: Int -> Text -> Text
text Data.Text
O(n) drop n, applied to a Text, returns the suffix of the Text after the first n characters, or the empty Text if n is greater than the length of the Text. Subject to fusion.
dropWord16 :: Int -> Text -> Text
text Data.Text.Unsafe
O(1) Unchecked drop of k Word16s from the front of a Text.
replicate :: Int -> Text -> Text
text Data.Text
O(n*m) replicate n t is a Text consisting of the input t repeated n times.

Show more results