Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. (++) :: [a] -> [a] -> [a]

    constrained-categories Control.Category.Hask

    (++) appends two lists, i.e., 

    [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
    If the first list is not finite, the result is the first list.

    Performance considerations

    This function takes linear time in the number of elements of the first list. Thus it is better to associate repeated applications of (++) to the right (which is the default behaviour): xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs. For the same reason concat = foldr (++) [] has linear performance, while foldl (++) [] is prone to quadratic slowdown

    Examples

    >>> [1, 2, 3] ++ [4, 5, 6]
[1,2,3,4,5,6]

    >>> [] ++ [1, 2, 3]
[1,2,3]

    >>> [3, 2, 1] ++ []
[3,2,1]

  2. (++) :: Typed a => [a] -> Stream a -> Stream a

    copilot-language Copilot.Language.Operators.Temporal

    Prepend a fixed number of samples to a stream. The elements to be appended at the beginning of the stream must be limited, that is, the list must have finite length. Prepending elements to a stream may increase the memory requirements of the generated programs (which now must hold the same number of elements in memory for future processing).

  3. type family (as :: [k]) ++ (bs :: [k]) :: [k]

    generic-data-functions Generic.Data.Function.Common.Generic.Meta

    Append for type-level lists.

  4. (++) :: forall (u :: Type -> Type) a (v :: Type -> Type) b . (Vector u a, Vector v b) => Vector u v (a, b) -> Vector u v (a, b) -> Vector u v (a, b)

    hybrid-vectors Data.Vector.Hybrid

    O(m+n) Concatenate two vectors

  5. type (a1 :: [a]) ++ (b :: [a]) = Append a1 b

    incipit-core IncipitCore

    Convenience type alias for concatenating two effect rows.

  6. (++) :: [a] -> [a] -> [a]

    listsafe Data.List.Safe

    (++) appends two lists, i.e., 

    [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
    If the first list is not finite, the result is the first list.

    Performance considerations

    This function takes linear time in the number of elements of the first list. Thus it is better to associate repeated applications of (++) to the right (which is the default behaviour): xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs. For the same reason concat = foldr (++) [] has linear performance, while foldl (++) [] is prone to quadratic slowdown

    Examples

    >>> [1, 2, 3] ++ [4, 5, 6]
[1,2,3,4,5,6]

    >>> [] ++ [1, 2, 3]
[1,2,3]

    >>> [3, 2, 1] ++ []
[3,2,1]

  7. (++) :: [a] -> [a] -> [a]

    xmonad-contrib XMonad.Config.Prime

    (++) appends two lists, i.e., 

    [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
    If the first list is not finite, the result is the first list.

    Performance considerations

    This function takes linear time in the number of elements of the first list. Thus it is better to associate repeated applications of (++) to the right (which is the default behaviour): xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs. For the same reason concat = foldr (++) [] has linear performance, while foldl (++) [] is prone to quadratic slowdown

    Examples

    >>> [1, 2, 3] ++ [4, 5, 6]
[1,2,3,4,5,6]

    >>> [] ++ [1, 2, 3]
[1,2,3]

    >>> [3, 2, 1] ++ []
[3,2,1]

  8. (++) :: [a] -> [a] -> [a]

    xmonad-contrib XMonad.Prelude

    (++) appends two lists, i.e., 

    [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
    If the first list is not finite, the result is the first list.

    Performance considerations

    This function takes linear time in the number of elements of the first list. Thus it is better to associate repeated applications of (++) to the right (which is the default behaviour): xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs. For the same reason concat = foldr (++) [] has linear performance, while foldl (++) [] is prone to quadratic slowdown

    Examples

    >>> [1, 2, 3] ++ [4, 5, 6]
[1,2,3,4,5,6]

    >>> [] ++ [1, 2, 3]
[1,2,3]

    >>> [3, 2, 1] ++ []
[3,2,1]

  9. (+++) :: ArrowChoice a => a b c -> a b' c' -> a (Either b b') (Either c c')

    base Control.Arrow

    Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor. The default definition may be overridden with a more efficient version if desired.

  10. (+++) :: ReadP a -> ReadP a -> ReadP a

    base Text.ParserCombinators.ReadP

    Symmetric choice.

Page 10 of many | Previous | Next