Data.ArrayView

fromFoldable :: forall f. Foldable f => f ~> ArrayView

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

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

range :: Int -> Int -> ArrayView Int

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

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

many :: forall a f. Alternative f => Lazy (f (Array a)) => f a -> f (ArrayView a)

null :: forall a. ArrayView a -> Boolean

Operator alias for Data.ArrayView.cons (non-associative / precedence 6)

cons :: forall a. a -> ArrayView a -> ArrayView a

O(n)

snoc :: forall a. ArrayView a -> a -> ArrayView a

O(n)

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

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

head :: forall a. ArrayView a -> Maybe a

last :: forall a. ArrayView a -> Maybe a

tail :: forall a. ArrayView a -> Maybe (ArrayView a)

O(1)

init :: forall a. ArrayView a -> Maybe (ArrayView a)

O(1)

uncons :: forall a. ArrayView a -> Maybe { head :: a, tail :: ArrayView a }

O(1)

unsnoc :: forall a. ArrayView a -> Maybe { init :: ArrayView a, last :: a }

O(1)

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

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

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

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

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

deleteAt :: forall a. Int -> ArrayView a -> Maybe (ArrayView a)

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

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

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

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

alterAt :: forall a. Int -> (a -> Maybe a) -> ArrayView a -> Maybe (ArrayView a)

reverse :: forall a. ArrayView a -> ArrayView a

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

filter :: forall a. (a -> Boolean) -> ArrayView a -> ArrayView a

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

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

mapMaybe :: forall b a. (a -> Maybe b) -> ArrayView a -> ArrayView b

catMaybes :: forall a. ArrayView (Maybe a) -> ArrayView a

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

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

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

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

slice :: forall a. Int -> Int -> ArrayView a -> ArrayView a

O(1)

take :: forall a. Int -> ArrayView a -> ArrayView a

O(1)

takeEnd :: forall a. Int -> ArrayView a -> ArrayView a

O(1)

takeWhile :: forall a. (a -> Boolean) -> ArrayView a -> ArrayView a

See also: span.

drop :: forall a. Int -> ArrayView a -> ArrayView a

O(1)

dropEnd :: forall a. Int -> ArrayView a -> ArrayView a

O(1)

dropWhile :: forall a. (a -> Boolean) -> ArrayView a -> ArrayView a

See also: span.

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

The time complexity of span only depends on the length of the resulting init ArrayView.

group :: forall a. Eq a => ArrayView a -> ArrayView (NonEmptyArrayView a)

group' :: forall a. Ord a => ArrayView a -> ArrayView (NonEmptyArrayView a)

groupBy :: forall a. (a -> a -> Boolean) -> ArrayView a -> ArrayView (NonEmptyArrayView a)

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

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

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

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

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

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

delete :: forall a. Eq a => a -> ArrayView a -> ArrayView a

deleteBy :: forall a. (a -> a -> Boolean) -> a -> ArrayView a -> ArrayView a

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

difference :: forall a. Eq a => ArrayView a -> ArrayView a -> ArrayView a

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

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

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

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

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

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

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

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

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

force :: forall a. ArrayView a -> ArrayView a

Perform deferred slice. This function allows the garbage collector to free unused parts of the array referenced by given ArrayView.

O(n)

force = toArray >>> fromArray

newtype ArrayView a

Instances

• Newtype (ArrayView a) _
• Generic (ArrayView a) _
• (Show a) => Show (ArrayView a)
• (Eq a) => Eq (ArrayView a)
• Eq1 ArrayView
• (Ord a) => Ord (ArrayView a)
• Ord1 ArrayView
• Functor ArrayView
• Apply ArrayView
• Bind ArrayView
• Applicative ArrayView
• Monad ArrayView
• FunctorWithIndex Int ArrayView
• FoldableWithIndex Int ArrayView
• TraversableWithIndex Int ArrayView
• Foldable ArrayView
• Traversable ArrayView
• Unfoldable1 ArrayView
• Unfoldable ArrayView
• Semigroup (ArrayView a)
• Monoid (ArrayView a)
• Alt ArrayView
• Plus ArrayView
• Alternative ArrayView
• Extend ArrayView
• MonadZero ArrayView
• MonadPlus ArrayView
• (ArrayToView a b) => ArrayToView (Array a) (ArrayView b)
• (ArrayToView a b) => ArrayToView (ArrayView a) (Array b)

class ArrayToView a b  where

This typeclass allows to convert any function that operates on Array to a function that operates on ArrayView and vice versa. use only inserts fromArray and toArray in the right places, so don't expect it to increase performance.

Note: either type annotation or partial application of some number of arguments is needed, because otherwise the type inference will not be able to guess the correct type.

import Data.Array as A

-- OK
zipWith :: forall a b c. (a -> b -> c) -> ArrayView a -> ArrayView b -> ArrayView c
zipWith = use (A.zipWith :: (a -> b -> c) -> Array a -> Array b -> Array c)

-- OK
zipWith :: forall a b c. (a -> b -> c) -> ArrayView a -> ArrayView b -> ArrayView c
zipWith f = use (A.zipWith f) -- all three type parameters are tied to `f`

-- Type error
zipWith :: forall a b c. (a -> b -> c) -> ArrayView a -> ArrayView b -> ArrayView c
zipWith = use A.zipWith

Members

• use :: a -> b

Instances

• ArrayToView a a
• (ArrayToView b a, ArrayToView c d) => ArrayToView (a -> c) (b -> d)
• (ArrayToView a b) => ArrayToView (Array a) (ArrayView b)
• (ArrayToView a b) => ArrayToView (ArrayView a) (Array b)
• (ArrayToView a b) => ArrayToView (NonEmptyArray a) (NonEmptyArrayView b)
• (ArrayToView a b) => ArrayToView (NonEmptyArrayView a) (NonEmptyArray b)
• (ArrayToView a b, ArrayToView c d) => ArrayToView (Tuple a c) (Tuple b d)
• (Functor f, ArrayToView a b) => ArrayToView (f a) (f b)

toArray :: ArrayView ~> Array

singleton :: forall a. a -> ArrayView a

length :: forall a. ArrayView a -> Int

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

fromArray :: Array ~> ArrayView

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

Operator alias for Data.ArrayView.Internal.index (left-associative / precedence 8)

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

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

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

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

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

intercalate :: forall m f. 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 m f. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

findMap :: forall f b a. 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 f a. Foldable f => (a -> Boolean) -> f a -> Maybe a

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

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

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

any :: forall f b a. 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 f b a. 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.

scanr :: forall f b a. 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 f b a. 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]