Module
Data.Array.NonEmpty
- Package
- purescript-arrays
- Repository
- purescript/purescript-arrays
#fromNonEmpty Source
fromNonEmpty :: forall a. NonEmpty Array a -> NonEmptyArray a
#toArray Source
toArray :: forall a. NonEmptyArray a -> Array a
#toNonEmpty Source
toNonEmpty :: forall a. NonEmptyArray a -> NonEmpty Array a
#fromFoldable Source
fromFoldable :: forall f a. Foldable f => f a -> Maybe (NonEmptyArray a)
#fromFoldable1 Source
fromFoldable1 :: forall f a. Foldable1 f => f a -> NonEmptyArray a
#toUnfoldable Source
toUnfoldable :: forall f a. Unfoldable f => NonEmptyArray a -> f a
#toUnfoldable1 Source
toUnfoldable1 :: forall f a. Unfoldable1 f => NonEmptyArray a -> f a
#singleton Source
singleton :: forall a. a -> NonEmptyArray a
#replicate Source
replicate :: forall a. Int -> a -> NonEmptyArray a
Replicate an item at least once
#some Source
some :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (NonEmptyArray a)
#length Source
length :: forall a. NonEmptyArray a -> Int
#cons Source
cons :: forall a. a -> NonEmptyArray a -> NonEmptyArray a
#cons' Source
cons' :: forall a. a -> Array a -> NonEmptyArray a
#snoc Source
snoc :: forall a. NonEmptyArray a -> a -> NonEmptyArray a
#snoc' Source
snoc' :: forall a. Array a -> a -> NonEmptyArray a
#appendArray Source
appendArray :: forall a. NonEmptyArray a -> Array a -> NonEmptyArray a
#insert Source
insert :: forall a. Ord a => a -> NonEmptyArray a -> NonEmptyArray a
#insertBy Source
insertBy :: forall a. (a -> a -> Ordering) -> a -> NonEmptyArray a -> NonEmptyArray a
#head Source
head :: forall a. NonEmptyArray a -> a
#last Source
last :: forall a. NonEmptyArray a -> a
#tail Source
tail :: forall a. NonEmptyArray a -> Array a
#init Source
init :: forall a. NonEmptyArray a -> Array a
#uncons Source
uncons :: forall a. NonEmptyArray a -> { head :: a, tail :: Array a }
#unsnoc Source
unsnoc :: forall a. NonEmptyArray a -> { init :: Array a, last :: a }
#elemLastIndex Source
elemLastIndex :: forall a. Eq a => a -> NonEmptyArray a -> Maybe Int
#findLastIndex Source
findLastIndex :: forall a. (a -> Boolean) -> NonEmptyArray a -> Maybe Int
#insertAt Source
insertAt :: forall a. Int -> a -> NonEmptyArray a -> Maybe (NonEmptyArray a)
#updateAt Source
updateAt :: forall a. Int -> a -> NonEmptyArray a -> Maybe (NonEmptyArray a)
#updateAtIndices Source
updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> NonEmptyArray a -> NonEmptyArray a
#modifyAt Source
modifyAt :: forall a. Int -> (a -> a) -> NonEmptyArray a -> Maybe (NonEmptyArray a)
#modifyAtIndices Source
modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> NonEmptyArray a -> NonEmptyArray a
#intersperse Source
intersperse :: forall a. a -> NonEmptyArray a -> NonEmptyArray a
#reverse Source
reverse :: forall a. NonEmptyArray a -> NonEmptyArray a
#concat Source
concat :: forall a. NonEmptyArray (NonEmptyArray a) -> NonEmptyArray a
#concatMap Source
concatMap :: forall a b. (a -> NonEmptyArray b) -> NonEmptyArray a -> NonEmptyArray b
#partition Source
partition :: forall a. (a -> Boolean) -> NonEmptyArray a -> { no :: Array a, yes :: Array a }
#splitAt Source
splitAt :: forall a. Int -> NonEmptyArray a -> { after :: Array a, before :: Array a }
#filterA Source
filterA :: forall a f. Applicative f => (a -> f Boolean) -> NonEmptyArray a -> f (Array a)
#mapWithIndex Source
mapWithIndex :: forall a b. (Int -> a -> b) -> NonEmptyArray a -> NonEmptyArray b
#foldl1 Source
foldl1 :: forall a. (a -> a -> a) -> NonEmptyArray a -> a
#foldr1 Source
foldr1 :: forall a. (a -> a -> a) -> NonEmptyArray a -> a
#foldMap1 Source
foldMap1 :: forall a m. Semigroup m => (a -> m) -> NonEmptyArray a -> m
#fold1 Source
fold1 :: forall m. Semigroup m => NonEmptyArray m -> m
#intercalate Source
intercalate :: forall a. Semigroup a => a -> NonEmptyArray a -> a
#scanl Source
scanl :: forall a b. (b -> a -> b) -> b -> NonEmptyArray a -> NonEmptyArray b
#scanr Source
scanr :: forall a b. (a -> b -> b) -> b -> NonEmptyArray a -> NonEmptyArray b
#sort Source
sort :: forall a. Ord a => NonEmptyArray a -> NonEmptyArray a
#sortBy Source
sortBy :: forall a. (a -> a -> Ordering) -> NonEmptyArray a -> NonEmptyArray a
#sortWith Source
sortWith :: forall a b. Ord b => (a -> b) -> NonEmptyArray a -> NonEmptyArray a
#span Source
span :: forall a. (a -> Boolean) -> NonEmptyArray a -> { init :: Array a, rest :: Array a }
#group Source
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 Source
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]]
`
#group' Source
group' :: forall a. Warn (Text "\'group\'\' is deprecated, use \'groupAll\' instead") => Ord a => NonEmptyArray a -> NonEmptyArray (NonEmptyArray a)
Deprecated previous name of groupAll
.
#groupBy Source
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 Source
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 Source
nub :: forall a. Ord a => NonEmptyArray a -> NonEmptyArray a
#nubBy Source
nubBy :: forall a. (a -> a -> Ordering) -> NonEmptyArray a -> NonEmptyArray a
#nubEq Source
nubEq :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a
#nubByEq Source
nubByEq :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> NonEmptyArray a
#union Source
union :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a -> NonEmptyArray a
#union' Source
union' :: forall a. Eq a => NonEmptyArray a -> Array a -> NonEmptyArray a
#unionBy Source
unionBy :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> NonEmptyArray a -> NonEmptyArray a
#unionBy' Source
unionBy' :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> Array a -> NonEmptyArray a
#difference Source
difference :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a -> Array a
#difference' Source
difference' :: forall a. Eq a => NonEmptyArray a -> Array a -> Array a
#intersect Source
intersect :: forall a. Eq a => NonEmptyArray a -> NonEmptyArray a -> Array a
#intersect' Source
intersect' :: forall a. Eq a => NonEmptyArray a -> Array a -> Array a
#intersectBy Source
intersectBy :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> NonEmptyArray a -> Array a
#intersectBy' Source
intersectBy' :: forall a. (a -> a -> Boolean) -> NonEmptyArray a -> Array a -> Array a
#zipWith Source
zipWith :: forall a b c. (a -> b -> c) -> NonEmptyArray a -> NonEmptyArray b -> NonEmptyArray c
#zipWithA Source
zipWithA :: forall m a b c. Applicative m => (a -> b -> m c) -> NonEmptyArray a -> NonEmptyArray b -> m (NonEmptyArray c)
#zip Source
zip :: forall a b. NonEmptyArray a -> NonEmptyArray b -> NonEmptyArray (Tuple a b)
#unzip Source
unzip :: forall a b. NonEmptyArray (Tuple a b) -> Tuple (NonEmptyArray a) (NonEmptyArray b)
#foldM Source
foldM :: forall m a b. Monad m => (b -> a -> m b) -> b -> NonEmptyArray a -> m b
#foldRecM Source
foldRecM :: forall m a b. MonadRec m => (b -> a -> m b) -> b -> NonEmptyArray a -> m b
#unsafeIndex Source
unsafeIndex :: forall a. Partial => NonEmptyArray a -> Int -> a
Re-exports from Data.Array.NonEmpty.Internal
#NonEmptyArray Source
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