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.

Exact lookup

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

   hledger-web	Hledger.Web.Import

   (++) 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. type family (xs :: [k]) ++ (ys :: [k]) :: [k]

   monoidal-functors	Control.Category.Tensor.Expr

   No documentation available.

3. (++) :: forall (f :: Type -> Type) (n :: Nat) (m :: Nat) a . (CFreeMonoid f, Dom f a) => Sized f n a -> Sized f m a -> Sized f (n + m) a

   sized	Data.Sized

   Infix version of append. Since 0.7.0.0

4. (++) :: Unboxable a => Vector a -> Vector a -> Vector a

   unboxing-vector	Data.Vector.Unboxing

   No documentation available.

5. (++) :: forall (n :: Nat) (m :: Nat) a . SNatI n => Vec n a -> Vec m a -> Vec (Plus n m) a

   vec	Data.Vec.DataFamily.SpineStrict

   Append two Vec.

   >>> ('a' ::: 'b' ::: VNil) ++ ('c' ::: 'd' ::: VNil)
   'a' ::: 'b' ::: 'c' ::: 'd' ::: VNil
   

6. (++) :: forall (n :: Nat) a (m :: Nat) . Vec n a -> Vec m a -> Vec (Plus n m) a

   vec	Data.Vec.Lazy

   Append two Vec.

   >>> ('a' ::: 'b' ::: VNil) ++ ('c' ::: 'd' ::: VNil)
   'a' ::: 'b' ::: 'c' ::: 'd' ::: VNil
   

7. (++) :: forall (n :: Nat) (m :: Nat) a . SNatI n => Vec n a -> Vec m a -> Vec (Plus n m) a

   vec	Data.Vec.Lazy.Inline

   Append two Vec.

   >>> ('a' ::: 'b' ::: VNil) ++ ('c' ::: 'd' ::: VNil)
   'a' ::: 'b' ::: 'c' ::: 'd' ::: VNil
   

8. type family (a :: [k]) ++ (b :: [k]) :: [k]

   wakame	Wakame.Utils

   >>> :kind! '[Bool, Int] ++ '[]
   '[Bool, Int] ++ '[] :: [*]
   = '[Bool, Int]
   
   >>> :kind! '[Bool, Int] ++ '[Char, Word]
   '[Bool, Int] ++ '[Char, Word] :: [*]
   = '[Bool, Int, Char, Word]
   

9. (++) :: Monoid m => m -> m -> m

   classy-prelude-yesod	ClassyPrelude.Yesod

   No documentation available.

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

    constrained-categories	Control.Category.Constrained.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]
    

Page 9 of many | Previous | Next