Hoogle Search

Within LTS Haskell 24.33 (ghc-9.10.3)

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

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

    dimensional Numeric.Units.Dimensional.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]

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

    distribution-opensuse OpenSuse.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]

  3. (+|) :: [a] -> [a] -> [a]

    extrapolate Test.Extrapolate

    Lazily interleaves two lists, switching between elements of the two. Union/sum of the elements in the lists. 

    [x,y,z,...] +| [a,b,c,...]  =  [x,a,y,b,z,c,...]

  4. (+|) :: [a] -> [a] -> [a]

    extrapolate Test.Extrapolate.Core

    Lazily interleaves two lists, switching between elements of the two. Union/sum of the elements in the lists. 

    [x,y,z,...] +| [a,b,c,...]  =  [x,a,y,b,z,c,...]

  5. (+++) :: Ord a => [a] -> [a] -> [a]

    extrapolate Test.Extrapolate.Utils

    No documentation available.

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

    faktory Faktory.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]

  7. type family (xs :: [α]) ++ (ys :: [α]) :: [α]

    fixed-vector-hetero Data.Vector.HFixed.Class

    Concaternation of type level lists.

  8. type family (xs :: [α]) ++ (ys :: [α]) :: [α]

    fixed-vector-hetero Data.Vector.HFixed.TypeFuns

    Concaternation of type level lists.

  9. (++) :: [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]

  10. (+=.) :: forall v typ . PersistField typ => EntityField v typ -> typ -> Update v

    hledger-web Hledger.Web.Import

    Assign a field by addition (+=).

    Examples

    addAge :: MonadIO m => ReaderT SqlBackend m ()
addAge = updateWhere [UserName ==. "SPJ" ] [UserAge +=. 1]
    The above query when applied on dataset-1, will produce this: 
    +-----+-----+---------+
|id   |name |age      |
+-----+-----+---------+
|1    |SPJ  |40 -> 41 |
+-----+-----+---------+
|2    |Simon|41       |
+-----+-----+---------+

Page 31 of many | Previous | Next