Module

Data.NonEmpty

This module defines a generic non-empty data structure, which adds an additional element to any container type.

#NonEmpty 

data NonEmpty :: (Type -> Type) -> Type -> Typedata NonEmpty f a

A non-empty container of elements of type a.

import Data.NonEmpty

nonEmptyArray :: NonEmpty Array Int
nonEmptyArray = NonEmpty 1 [2,3]

import Data.List(List(..), (:))

nonEmptyList :: NonEmpty List Int
nonEmptyList = NonEmpty 1 (2 : 3 : Nil)

Constructors

Instances

#singleton 

singleton :: forall f a. Plus f => a -> NonEmpty f a

Create a non-empty structure with a single value.

import Prelude

singleton 1 == 1 :| []
singleton 1 == 1 :| Nil

#(:|)

Operator alias for Data.NonEmpty.NonEmpty (right-associative / precedence 5)

An infix synonym for NonEmpty.

nonEmptyArray :: NonEmpty Array Int
nonEmptyArray = 1 :| [2,3]

nonEmptyList :: NonEmpty List Int
nonEmptyList = 1 :| 2 : 3 : Nil

#foldl1 

foldl1 :: forall f a. Foldable f => Warn (Text "\'Data.NonEmpty.foldl1\' is deprecated, use \'Data.Semigroup.Foldable.foldl1\' instead") => (a -> a -> a) -> NonEmpty f a -> a

Fold a non-empty structure, collecting results using a binary operation.

Deprecated, use 'Data.Semigroup.Foldable.foldl1' instead

foldl1 (+) (1 :| [2, 3]) == 6

#fromNonEmpty 

fromNonEmpty :: forall f a r. (a -> f a -> r) -> NonEmpty f a -> r

Apply a function that takes the first element and remaining elements as arguments to a non-empty container.

For example, return the remaining elements multiplied by the first element:

fromNonEmpty (\x xs -> map (_ * x) xs) (3 :| [2, 1]) == [6, 3]

#oneOf 

oneOf :: forall f a. Alternative f => NonEmpty f a -> f a

Returns the alt (<|>) result of:

  • The first element lifted to the container of the remaining elements.
  • The remaining elements.
import Data.Maybe(Maybe(..))

oneOf (1 :| Nothing) == Just 1
oneOf (1 :| Just 2) == Just 1

oneOf (1 :| [2, 3]) == [1,2,3]

#head 

head :: forall f a. NonEmpty f a -> a

Get the 'first' element of a non-empty container.

head (1 :| [2, 3]) == 1

#tail 

tail :: forall f a. NonEmpty f a -> f a

Get everything but the 'first' element of a non-empty container.

tail (1 :| [2, 3]) == [2, 3]

Modules