Data.List.NonEmpty

toUnfoldable :: forall f. Unfoldable f => NonEmptyList ~> f

fromFoldable :: forall f a. Foldable f => f a -> Maybe (NonEmptyList a)

fromList :: forall a. List a -> Maybe (NonEmptyList a)

toList :: NonEmptyList ~> List

singleton :: forall a. a -> NonEmptyList a

length :: forall a. NonEmptyList a -> Int

cons :: forall a. a -> NonEmptyList a -> NonEmptyList a

cons' :: forall a. a -> List a -> NonEmptyList a

snoc :: forall a. NonEmptyList a -> a -> NonEmptyList a

snoc' :: forall a. List a -> a -> NonEmptyList a

head :: forall a. NonEmptyList a -> a

last :: forall a. NonEmptyList a -> a

tail :: NonEmptyList ~> List

init :: NonEmptyList ~> List

uncons :: forall a. NonEmptyList a -> { head :: a, tail :: List a }

unsnoc :: forall a. NonEmptyList a -> { init :: List a, last :: a }

Operator alias for Data.List.NonEmpty.index (left-associative / precedence 8)

index :: forall a. NonEmptyList a -> Int -> Maybe a

elemIndex :: forall a. Eq a => a -> NonEmptyList a -> Maybe Int

elemLastIndex :: forall a. Eq a => a -> NonEmptyList a -> Maybe Int

findIndex :: forall a. (a -> Boolean) -> NonEmptyList a -> Maybe Int

findLastIndex :: forall a. (a -> Boolean) -> NonEmptyList a -> Maybe Int

insertAt :: forall a. Int -> a -> NonEmptyList a -> Maybe (NonEmptyList a)

updateAt :: forall a. Int -> a -> NonEmptyList a -> Maybe (NonEmptyList a)

modifyAt :: forall a. Int -> (a -> a) -> NonEmptyList a -> Maybe (NonEmptyList a)

reverse :: forall a. NonEmptyList a -> NonEmptyList a

concat :: forall a. NonEmptyList (NonEmptyList a) -> NonEmptyList a

concatMap :: forall a b. (a -> NonEmptyList b) -> NonEmptyList a -> NonEmptyList b

filter :: forall a. (a -> Boolean) -> NonEmptyList a -> List a

filterM :: forall m a. Monad m => (a -> m Boolean) -> NonEmptyList a -> m (List a)

mapMaybe :: forall a b. (a -> Maybe b) -> NonEmptyList a -> List b

catMaybes :: forall a. NonEmptyList (Maybe a) -> List a

appendFoldable :: forall t a. Foldable t => NonEmptyList a -> t a -> NonEmptyList a

sort :: forall a. Ord a => NonEmptyList a -> NonEmptyList a

sortBy :: forall a. (a -> a -> Ordering) -> NonEmptyList a -> NonEmptyList a

take :: forall a. Int -> NonEmptyList a -> List a

takeWhile :: forall a. (a -> Boolean) -> NonEmptyList a -> List a

drop :: forall a. Int -> NonEmptyList a -> List a

dropWhile :: forall a. (a -> Boolean) -> NonEmptyList a -> List a

span :: forall a. (a -> Boolean) -> NonEmptyList a -> { init :: List a, rest :: List a }

group :: forall a. Eq a => NonEmptyList a -> NonEmptyList (NonEmptyList a)

groupAll :: forall a. Ord a => NonEmptyList a -> NonEmptyList (NonEmptyList a)

groupBy :: forall a. (a -> a -> Boolean) -> NonEmptyList a -> NonEmptyList (NonEmptyList a)

groupAllBy :: forall a. (a -> a -> Ordering) -> NonEmptyList a -> NonEmptyList (NonEmptyList a)

partition :: forall a. (a -> Boolean) -> NonEmptyList a -> { no :: List a, yes :: List a }

nub :: forall a. Ord a => NonEmptyList a -> NonEmptyList a

nubBy :: forall a. (a -> a -> Ordering) -> NonEmptyList a -> NonEmptyList a

nubEq :: forall a. Eq a => NonEmptyList a -> NonEmptyList a

nubByEq :: forall a. (a -> a -> Boolean) -> NonEmptyList a -> NonEmptyList a

union :: forall a. Eq a => NonEmptyList a -> NonEmptyList a -> NonEmptyList a

unionBy :: forall a. (a -> a -> Boolean) -> NonEmptyList a -> NonEmptyList a -> NonEmptyList a

intersect :: forall a. Eq a => NonEmptyList a -> NonEmptyList a -> NonEmptyList a

intersectBy :: forall a. (a -> a -> Boolean) -> NonEmptyList a -> NonEmptyList a -> NonEmptyList a

zipWith :: forall a b c. (a -> b -> c) -> NonEmptyList a -> NonEmptyList b -> NonEmptyList c

zipWithA :: forall m a b c. Applicative m => (a -> b -> m c) -> NonEmptyList a -> NonEmptyList b -> m (NonEmptyList c)

zip :: forall a b. NonEmptyList a -> NonEmptyList b -> NonEmptyList (Tuple a b)

unzip :: forall a b. NonEmptyList (Tuple a b) -> Tuple (NonEmptyList a) (NonEmptyList b)

foldM :: forall m a b. Monad m => (b -> a -> m b) -> b -> NonEmptyList a -> m b

foldMap :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

foldl :: forall f a b. Foldable f => (b -> a -> b) -> b -> f a -> b

foldr :: forall f a b. Foldable f => (a -> b -> b) -> b -> f a -> b

notElem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is not an element of a data structure.

intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For example:

> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"

> intercalate "*" ["a", "b", "c"]
= "a*b*c"

> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]

fold :: forall f m. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

findMap :: forall a b f. Foldable f => (a -> Maybe b) -> f a -> Maybe b

Try to find an element in a data structure which satisfies a predicate mapping.

find :: forall a f. Foldable f => (a -> Boolean) -> f a -> Maybe a

Try to find an element in a data structure which satisfies a predicate.

elem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is an element of a data structure.

any :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

any f is the same as or <<< map f; map a function over the structure, and then get the disjunction of the results.

all :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

all f is the same as and <<< map f; map a function over the structure, and then get the conjunction of the results.

newtype NonEmptyList a

Constructors

• NonEmptyList (NonEmpty List a)

Instances

• Newtype (NonEmptyList a) _
• (Eq a) => Eq (NonEmptyList a)
• (Ord a) => Ord (NonEmptyList a)
• Eq1 NonEmptyList
• Ord1 NonEmptyList
• (Show a) => Show (NonEmptyList a)
• Functor NonEmptyList
• Apply NonEmptyList
• Applicative NonEmptyList
• Bind NonEmptyList
• Monad NonEmptyList
• Alt NonEmptyList
• Extend NonEmptyList
• Comonad NonEmptyList
• Semigroup (NonEmptyList a)
• Foldable NonEmptyList
• Traversable NonEmptyList
• Foldable1 NonEmptyList
• Unfoldable1 NonEmptyList
• FunctorWithIndex Int NonEmptyList
• FoldableWithIndex Int NonEmptyList
• TraversableWithIndex Int NonEmptyList
• Traversable1 NonEmptyList

foldMap1 :: forall t a m. Foldable1 t => Semigroup m => (a -> m) -> t a -> m

traverse1_ :: forall t f a b. Foldable1 t => Apply f => (a -> f b) -> t a -> f Unit

Traverse a data structure, performing some effects encoded by an Apply instance at each value, ignoring the final result.

sequence1_ :: forall t f a. Foldable1 t => Apply f => t (f a) -> f Unit

Perform all of the effects in some data structure in the order given by the Foldable1 instance, ignoring the final result.

for1_ :: forall t f a b. Foldable1 t => Apply f => t a -> (a -> f b) -> f Unit

A version of traverse1_ with its arguments flipped.

This can be useful when running an action written using do notation for every element in a data structure:

fold1 :: forall t m. Foldable1 t => Semigroup m => t m -> m

Fold a data structure, accumulating values in some Semigroup.

sequence1 :: forall t b f. Traversable1 t => Apply f => t (f b) -> f (t b)

traverse1 :: forall t a b f. Traversable1 t => Apply f => (a -> f b) -> t a -> f (t b)

traverse1Default :: forall t a b m. Traversable1 t => Apply m => (a -> m b) -> t a -> m (t b)

A default implementation of traverse1 using sequence1.

scanr :: forall a b f. Traversable f => (a -> b -> b) -> b -> f a -> f b

Fold a data structure from the right, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanr).

scanr (+) 0 [1,2,3] = [6,5,3]
scanr (flip (-)) 10 [1,2,3] = [4,5,7]

scanl :: forall a b f. Traversable f => (b -> a -> b) -> b -> f a -> f b

Fold a data structure from the left, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanl).

scanl (+) 0  [1,2,3] = [1,3,6]
scanl (-) 10 [1,2,3] = [9,7,4]