Data.Array.NonEmpty

fromArray :: forall a. Array a -> Maybe (NonEmptyArray a)

fromNonEmpty :: forall a. NonEmpty Array a -> NonEmptyArray a

toArray :: forall a. NonEmptyArray a -> Array a

toNonEmpty :: forall a. NonEmptyArray a -> NonEmpty Array a

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

fromFoldable1 :: forall f a. Foldable1 f => f a -> NonEmptyArray a

toUnfoldable :: forall f a. Unfoldable f => NonEmptyArray a -> f a

toUnfoldable1 :: forall f a. Unfoldable1 f => NonEmptyArray a -> f a

singleton :: forall a. a -> NonEmptyArray a

Operator alias for Data.Array.NonEmpty.range (non-associative / precedence 8)

range :: Int -> Int -> NonEmptyArray Int

replicate :: forall a. Int -> a -> NonEmptyArray a

Replicate an item at least once

some :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (NonEmptyArray a)

length :: forall a. NonEmptyArray a -> Int

Operator alias for Data.Array.NonEmpty.cons (right-associative / precedence 6)

cons :: forall a. a -> NonEmptyArray a -> NonEmptyArray a

cons' :: forall a. a -> Array a -> NonEmptyArray a

snoc :: forall a. NonEmptyArray a -> a -> NonEmptyArray a

snoc' :: forall a. Array a -> a -> NonEmptyArray a

appendArray :: forall a. NonEmptyArray a -> Array a -> NonEmptyArray a

insert :: forall a. Ord a => a -> NonEmptyArray a -> NonEmptyArray a

insertBy :: forall a. (a -> a -> Ordering) -> a -> NonEmptyArray a -> NonEmptyArray a

head :: forall a. NonEmptyArray a -> a

last :: forall a. NonEmptyArray a -> a

tail :: forall a. NonEmptyArray a -> Array a

init :: forall a. NonEmptyArray a -> Array a

uncons :: forall a. NonEmptyArray a -> { head :: a, tail :: Array a }

unsnoc :: forall a. NonEmptyArray a -> { init :: Array a, last :: a }

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

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

elem :: forall a. Eq a => a -> NonEmptyArray a -> Boolean

notElem :: forall a. Eq a => a -> NonEmptyArray a -> Boolean

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

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

find :: forall a. (a -> Boolean) -> NonEmptyArray a -> Maybe a

findMap :: forall a b. (a -> Maybe b) -> NonEmptyArray a -> Maybe b

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

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

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

deleteAt :: forall a. Int -> NonEmptyArray a -> Maybe (Array a)

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

updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> NonEmptyArray a -> NonEmptyArray a

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

modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> NonEmptyArray a -> NonEmptyArray a

alterAt :: forall a. Int -> (a -> Maybe a) -> NonEmptyArray a -> Maybe (Array a)

intersperse :: forall a. a -> NonEmptyArray a -> NonEmptyArray a

reverse :: forall a. NonEmptyArray a -> NonEmptyArray a

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

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

filter :: forall a. (a -> Boolean) -> NonEmptyArray a -> Array a

partition :: forall a. (a -> Boolean) -> NonEmptyArray a -> { no :: Array a, yes :: Array a }

splitAt :: forall a. Int -> NonEmptyArray a -> { after :: Array a, before :: Array a }

filterA :: forall a f. Applicative f => (a -> f Boolean) -> NonEmptyArray a -> f (Array a)

mapMaybe :: forall a b. (a -> Maybe b) -> NonEmptyArray a -> Array b

catMaybes :: forall a. NonEmptyArray (Maybe a) -> Array a

mapWithIndex :: forall a b. (Int -> a -> b) -> NonEmptyArray a -> NonEmptyArray b

foldl1 :: forall a. (a -> a -> a) -> NonEmptyArray a -> a

foldr1 :: forall a. (a -> a -> a) -> NonEmptyArray a -> a

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

fold1 :: forall m. Semigroup m => NonEmptyArray m -> m

intercalate :: forall a. Semigroup a => a -> NonEmptyArray a -> a

transpose :: forall a. NonEmptyArray (NonEmptyArray a) -> NonEmptyArray (NonEmptyArray a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose 
  (NonEmptyArray [ NonEmptyArray [1, 2, 3]
                 , NonEmptyArray [4, 5, 6]
                 ]) == 
  (NonEmptyArray [ NonEmptyArray [1, 4]
                 , NonEmptyArray [2, 5]
                 , NonEmptyArray [3, 6]
                 ])

If some of the rows are shorter than the following rows, their elements are skipped:

transpose 
  (NonEmptyArray [ NonEmptyArray [10, 11]
                 , NonEmptyArray [20]
                 , NonEmptyArray [30, 31, 32]
                 ]) == 
  (NomEmptyArray [ NonEmptyArray [10, 20, 30]
                 , NonEmptyArray [11, 31]
                 , NonEmptyArray [32]
                 ])

transpose' :: forall a. NonEmptyArray (Array a) -> Maybe (NonEmptyArray (Array a))

transpose' is identical to transpose other than that the inner arrays are each a standard Array and not a NonEmptyArray. However, the result is wrapped in a Maybe to cater for the case where the inner Array is empty and must return Nothing.

scanl :: forall a b. (b -> a -> b) -> b -> NonEmptyArray a -> NonEmptyArray b

scanr :: forall a b. (a -> b -> b) -> b -> NonEmptyArray a -> NonEmptyArray b

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

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

sortWith :: forall a b. Ord b => (a -> b) -> NonEmptyArray a -> NonEmptyArray a

slice :: forall a. Int -> Int -> NonEmptyArray a -> Array a

take :: forall a. Int -> NonEmptyArray a -> Array a

takeEnd :: forall a. Int -> NonEmptyArray a -> Array a

takeWhile :: forall a. (a -> Boolean) -> NonEmptyArray a -> Array a

drop :: forall a. Int -> NonEmptyArray a -> Array a

dropEnd :: forall a. Int -> NonEmptyArray a -> Array a

dropWhile :: forall a. (a -> Boolean) -> NonEmptyArray a -> Array a

span :: forall a. (a -> Boolean) -> NonEmptyArray a -> { init :: Array a, rest :: Array a }

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

Group equal, consecutive elements of an array into arrays.

group (NonEmptyArray [1, 1, 2, 2, 1]) ==
  NonEmptyArray [NonEmptyArray [1, 1], NonEmptyArray [2, 2], NonEmptyArray [1]]

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

Group equal elements of an array into arrays.

groupAll (NonEmptyArray [1, 1, 2, 2, 1]) ==
  NonEmptyArray [NonEmptyArray [1, 1, 1], NonEmptyArray [2, 2]]
`

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

Group equal, consecutive elements of an array into arrays, using the specified equivalence relation to determine equality.

groupBy (\a b -> odd a && odd b) (NonEmptyArray [1, 3, 2, 4, 3, 3])
   = NonEmptyArray [NonEmptyArray [1, 3], NonEmptyArray [2], NonEmptyArray [4], NonEmptyArray [3, 3]]

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

Group equal elements of an array into arrays, using the specified comparison function to determine equality.

groupAllBy (comparing Down) (NonEmptyArray [1, 3, 2, 4, 3, 3])
   = NonEmptyArray [NonEmptyArray [4], NonEmptyArray [3, 3, 3], NonEmptyArray [2], NonEmptyArray [1]]

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

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

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

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

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

union' :: forall a. Eq a => NonEmptyArray a -> Array a -> NonEmptyArray a

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

unionBy' :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> Array a -> NonEmptyArray a

delete :: forall a. Eq a => a -> NonEmptyArray a -> Array a

deleteBy :: forall a. (a -> a -> Boolean) -> a -> NonEmptyArray a -> Array a

Operator alias for Data.Array.NonEmpty.difference (non-associative / precedence 5)

difference :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a -> Array a

difference' :: forall a. Eq a => NonEmptyArray a -> Array a -> Array a

intersect :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a -> Array a

intersect' :: forall a. Eq a => NonEmptyArray a -> Array a -> Array a

intersectBy :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> NonEmptyArray a -> Array a

intersectBy' :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> Array a -> Array a

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

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

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

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

any :: forall a. (a -> Boolean) -> NonEmptyArray a -> Boolean

all :: forall a. (a -> Boolean) -> NonEmptyArray a -> Boolean

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

foldRecM :: forall m a b. MonadRec m => (b -> a -> m b) -> b -> NonEmptyArray a -> m b

unsafeIndex :: forall a. Partial => NonEmptyArray a -> Int -> a

newtype NonEmptyArray a

An array that is known not to be empty.

You can use the constructor to create a NonEmptyArray that isn't non-empty, breaking the guarantee behind this newtype. It is provided as an escape hatch mainly for the Data.Array.NonEmpty and Data.Array modules. Use this at your own risk when you know what you are doing.

Instances

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