:: [a] -> a -> [a]

ghc GHC.Utils.Misc, deriving-compat Data.Deriving.Via.Internal, ghc-lib-parser GHC.Utils.Misc

Replace the last element of a list with another element.

Append an element to the end of a list, takes O(n) time.

snoc "tes" 't' == "test"
\xs x -> unsnoc (snoc xs x) == Just (xs,x)

snoc :: [a] -> a -> [a]

Agda Agda.Utils.List

Append a single element at the end. Time: O(length); use only on small lists.

snoc :: [a] -> a -> [a]

kvitable Data.KVITable.Internal.Helpers

replicate :: [a] -> b -> [b]

utility-ht Data.List.Match

Specialisation of $>.

snoc :: Vector v a => v a -> a -> v a

rio RIO.Vector

O(n) Append an element

($>) :: Functor f => f a -> b -> f b

base Data.Functor, ghc-internal GHC.Internal.Data.Functor

Flipped version of <$.

Examples

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing

>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309

>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

($>) :: Functor f => f a -> b -> f b

Flipped version of <$.

Examples

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing

>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309

>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

($>) :: Functor f => f a -> b -> f b

relude Relude.Functor.Reexport

Flipped version of <$. @since base-4.7.0.0

Examples

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing

>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309

>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

($>) :: Functor f => f a -> b -> f b

rio RIO.Prelude

Flipped version of <$. Using ApplicativeDo: 'as $> b' can be understood as the do expression

do as
pure b

with an inferred Functor constraint.

Examples

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing

>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309

>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

replicate :: Functor f => f a -> b -> f b

non-empty Data.NonEmpty.Match

the same as ($>)

replace :: Functor f => f a -> b -> f b

network-house Net.Utils

skipRet :: Monad m => m b -> a -> m a

yjtools Control.Monad.Tools

decomposeVarPositionalInf :: C a => [a] -> a -> [a]

numeric-prelude Algebra.IntegralDomain

approximate :: C a => [a] -> a -> [a]

numeric-prelude MathObj.PowerSeries.Core

decomposeVarPositional :: (C a, C a) => [a] -> a -> [a]

numeric-prelude Algebra.IntegralDomain

decomposeVarPositional [b0,b1,b2,...] x decomposes x into a positional representation with mixed bases x0 + b0*(x1 + b1*(x2 + b2*x3)) E.g. decomposeVarPositional (repeat 10) 123 == [3,2,1]

approximateCoeffVector :: C a v => [v] -> a -> [v]

numeric-prelude MathObj.PowerSeries.Core

approximateArgVector :: (C a v, C v) => [a] -> v -> [v]

numeric-prelude MathObj.PowerSeries.Core

polyinteg :: Fractional a => [a] -> a -> [a]

dsp Polynomial.Basic

Polynomial integration

(^*) :: (Functor f, Num a) => f a -> a -> f a

linear Linear.Vector, Rasterific Graphics.Rasterific.Linear

Compute the right scalar product

>>> V2 3 4 ^* 2
V2 6 8

(^/) :: (Functor f, Floating a) => f a -> a -> f a

Rasterific Graphics.Rasterific.Linear

Compute division by a scalar on the right.

polypow :: (Num a, Integral b) => [a] -> b -> [a]

dsp Polynomial.Basic

Raise a polynomial to a non-negative integer power

intersperse :: a -> [a] -> [a]

base Data.List

The intersperse function takes an element and a list and `intersperses' that element between the elements of the list.

Laziness

intersperse has the following properties

>>> take 1 (intersperse undefined ('a' : undefined))
"a"

>>> take 2 (intersperse ',' ('a' : undefined))
"a*** Exception: Prelude.undefined

Examples

>>> intersperse ',' "abcde"
"a,b,c,d,e"

>>> intersperse 1 [3, 4, 5]
[3,1,4,1,5]

cons :: a -> [a] -> [a]

extra Data.List.Extra Extra

Append an element to the start of a list, an alias for (:).

cons 't' "est" == "test"
\x xs -> uncons (cons x xs) == Just (x,xs)

intersperse :: a -> [a] -> [a]

protolude Protolude

The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,

>>> intersperse ',' "abcde"
"a,b,c,d,e"

intersperse has the following laziness properties:

>>> take 1 (intersperse undefined ('a' : undefined))
"a"

>>> take 2 (intersperse ',' ('a' : undefined))
"a*** Exception: Prelude.undefined