|
|
|
|
|
| Description |
|
|
| Synopsis |
|
| class UA e where | | | | streamU :: UA a => UArr a -> Stream a | | | unstreamU :: UA a => Stream a -> UArr a | | | toU :: UA e => [e] -> UArr e | | | fromU :: UA e => UArr e -> [e] | | | emptyU :: UA e => UArr e | | | singletonU :: UA e => e -> UArr e | | | consU :: UA e => e -> UArr e -> UArr e | | | snocU :: UA e => UArr e -> e -> UArr e | | | appendU :: UA e => UArr e -> UArr e -> UArr e | | | headU :: UA e => UArr e -> e | | | lastU :: UA e => UArr e -> e | | | tailU :: UA e => UArr e -> UArr e | | | initU :: UA e => UArr e -> UArr e | | | nullU :: UA e => UArr e -> Bool | | | unitsU :: Int -> UArr () | | | lengthU :: UA e => UArr e -> Int | | | mapU :: (UA e, UA e') => (e -> e') -> UArr e -> UArr e' | | | foldU :: UA a => (a -> a -> a) -> a -> UArr a -> a | | | fold1U :: UA a => (a -> a -> a) -> UArr a -> a | | | fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a | | | foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> b | | | foldl1U :: UA a => (a -> a -> a) -> UArr a -> a | | | foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a | | | andU :: UArr Bool -> Bool | | | orU :: UArr Bool -> Bool | | | anyU :: UA e => (e -> Bool) -> UArr e -> Bool | | | allU :: UA e => (e -> Bool) -> UArr e -> Bool | | | sumU :: (Num e, UA e) => UArr e -> e | | | productU :: (Num e, UA e) => UArr e -> e | | | maximumU :: (Ord e, UA e) => UArr e -> e | | | minimumU :: (Ord e, UA e) => UArr e -> e | | | maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e | | | minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e | | | scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr b | | | scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr a | | | scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a | | | scan1U :: UA a => (a -> a -> a) -> UArr a -> UArr a | | | scanResU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a :*: a | | | mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr b | | | replicateU :: UA e => Int -> e -> UArr e | | | replicateEachU :: UA e => Int -> UArr Int -> UArr e -> UArr e | | | takeU :: UA e => Int -> UArr e -> UArr e | | | dropU :: UA e => Int -> UArr e -> UArr e | | | splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e) | | | takeWhileU :: UA e => (e -> Bool) -> UArr e -> UArr e | | | dropWhileU :: UA e => (e -> Bool) -> UArr e -> UArr e | | | elemU :: (Eq e, UA e) => e -> UArr e -> Bool | | | notElemU :: (Eq e, UA e) => e -> UArr e -> Bool | | | filterU :: UA e => (e -> Bool) -> UArr e -> UArr e | | | findU :: UA a => (a -> Bool) -> UArr a -> Maybe a | | | indexU :: UA e => UArr e -> Int -> e | | | findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe Int | | | lookupU :: (Eq a, UA a, UA b) => a -> UArr (a :*: b) -> Maybe b | | | zipU :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b) | | | zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3) | | | unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr b | | | unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3 | | | zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c | | | zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr d | | | fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr a | | | sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr b | | | enumFromToU :: (UA a, Integral a) => a -> a -> UArr a | | | enumFromToFracU :: (UA a, RealFrac a) => a -> a -> UArr a | | | enumFromThenToU :: Int -> Int -> Int -> UArr Int | | | enumFromStepLenU :: Int -> Int -> Int -> UArr Int | | | enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr Int | | | combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a | | | packU :: UA e => UArr e -> UArr Bool -> UArr e | | | indexedU :: UA e => UArr e -> UArr (Int :*: e) | | | repeatU :: UA e => Int -> UArr e -> UArr e | | | unfoldU :: UA a => Int -> (b -> MaybeS (a :*: b)) -> b -> UArr a | | | class UA a => UIO a where | | | | newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e | | | unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e) | | | permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s () | | | atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s () | | | unstreamMU :: UA a => MUArr a s -> Stream a -> ST s Int | | | data a :*: b = !a :*: !b | | | | | fstS :: (a :*: b) -> a | | | sndS :: (a :*: b) -> b | | | pairS :: (a, b) -> a :*: b | | | unpairS :: (a :*: b) -> (a, b) | | | unsafe_pairS :: (a, b) -> a :*: b | | | unsafe_unpairS :: (a :*: b) -> (a, b) | | | curryS :: ((a :*: b) -> c) -> a -> b -> c | | | uncurryS :: (a -> b -> c) -> (a :*: b) -> c | | | | | maybeS :: b -> (a -> b) -> MaybeS a -> b | | | fromMaybeS :: a -> MaybeS a -> a |
|
|
|
| Array classes
|
|
|
Basic operations on representation types
-----------------------------------------
This type class determines the types that can be elements immutable
unboxed arrays. The representation type of these arrays is defined by way
of an associated type. All representation-dependent functions are methods
of this class.
| | | Associated Types | | | | Methods | | | Restrict access to a subrange of the original array (no copying)
| | | | Yield the length of a mutable unboxed array
| | | | Allocate a mutable unboxed array
| | | | Read an element from a mutable unboxed array
| | | | Update an element in a mutable unboxed array
| | | | Copy the contents of an immutable unboxed array into a mutable one
from the specified position on
| | | | Convert a mutable into an immutable unboxed array
|
| |  Instances | |
|
|
| The pure and mutable array types
|
|
| Streaming pure arrays
|
|
|
| Generate a stream from an array, from left to right
|
|
|
| Create an array from a stream, filling it from left to right
|
|
| Conversions to/from lists
|
|
|
Conversion
-----------
Turn a list into a parallel array
|
|
|
| Collect the elements of a parallel array in a list
|
|
| Basic operations on pure arrays
|
|
| Introducing and eliminating UArrs
|
|
|
| Yield an empty array
|
|
|
| Yield a singleton array
|
|
| Basic interface
|
|
|
| Prepend an element to an array
|
|
|
| Append an element to an array
|
|
|
| Concatenate two arrays
|
|
|
|
|
|
|
|
|
|
|
| Test whether the given array is empty
|
|
|
Basic operations on unboxed arrays
-----------------------------------
Yield an array of units
|
|
|
| O(1), length returns the length of a UArr as an Int.
|
|
| Transforming UArrs
|
|
|
| Map a function over an array
|
|
| Reducing UArrs (folds)
|
|
|
| Array reduction that requires an associative combination function with its
unit
|
|
|
| Reduction of a non-empty array which requires an associative combination
function
|
|
|
|
|
| Array reduction proceeding from the left
|
|
|
Array reduction proceeding from the left for non-empty arrays
FIXME: Rewrite for Streams.
foldl1U :: UA a => (a -> a -> a) -> UArr a -> a
{--}
foldl1U f arr = checkNotEmpty (here foldl1U) (lengthU arr) $
foldlU f (arr indexU 0) (sliceU arr 1 (lengthU arr - 1))
|
|
|
|
| Logical operations
|
|
|
|
|
|
|
|
|
|
| Arithmetic operations
|
|
|
| Compute the sum of an array of numerals
|
|
|
| Compute the product of an array of numerals
|
|
|
| Determine the maximum element in an array
|
|
|
| Determine the minimum element in an array
|
|
|
| Determine the maximum element in an array under the given ordering
|
|
|
| Determine the minimum element in an array under the given ordering
|
|
| Building UArrs
|
|
| Scans
|
|
|
| Prefix scan proceedings from left to right
|
|
|
| Prefix scan of a non-empty array proceeding from left to right
|
|
|
| Prefix scan proceeding from left to right that needs an associative
combination function with its unit
|
|
|
| Prefix scan of a non-empty array proceeding from left to right that needs
an associative combination function
|
|
|
|
| Accumulating UArrs
|
|
|
Accumulating map from left to right. Does not return the accumulator.
FIXME: Naming inconsistent with lists.
|
|
| Generating UArrs
|
|
|
| Yield an array where all elements contain the same value
|
|
|
|
| Subarrays
|
|
| Breaking arrays
|
|
|
|
|
|
|
| Split an array into two halves at the given index
|
|
|
| takeWhile, applied to a predicate p and a UArr xs,
returns the longest prefix (possibly empty) of xs of elements that satisfy p.
|
|
|
| dropWhile p xs returns the suffix remaining after takeWhile p xs.
|
|
| Searching Arrays
|
|
| Searching by equality
|
|
|
| Determine whether the given element is in an array
|
|
|
| Negation of elemU
|
|
| Searching with a predicate
|
|
|
| Extract all elements from an array that meet the given predicate
|
|
|
| O(n),fusion. The find function takes a predicate and an array
and returns the first element in the list matching the predicate, or
Nothing if there is no such element.
|
|
| Indexing UArr
|
|
|
| Array indexing
|
|
|
| O(n), fusion, The findIndex function takes a predicate and an array and returns
the index of the first element in the array satisfying the predicate,
or Nothing if there is no such element.
|
|
|
| O(n),fusion. lookup key assocs looks up a key in an array
of pairs treated as an association table.
|
|
| Zipping and unzipping
|
|
|
| Elementwise pairing of array elements.
|
|
|
|
|
| Elementwise unpairing of array elements.
|
|
|
|
|
|
|
|
|
| Yield the first components of an array of pairs.
|
|
|
| Yield the second components of an array of pairs.
|
|
| Enumerations
|
|
|
Yield an enumerated array
FIXME: See comments about enumFromThenToS
|
|
|
|
|
Yield an enumerated array using a specific step
FIXME: See comments about enumFromThenToS
|
|
|
|
|
|
| Low level conversions
|
|
| Low level conversions
|
|
| Copying arrays
|
|
| Packing CStrings and pointers
|
|
| Using UArrs as CStrings
|
|
| I/O with UArrs
|
|
|
|
|
| Extract all elements from an array according to a given flag array
|
|
|
Indexing
---------
Associate each element of the array with its index
|
|
|
| Repeat an array n times
|
|
| Permutations
|
|
| Searching
|
|
| Arrays of pairs
|
|
| Random arrays
|
|
|
|
| I/O
|
|
|
| | Methods | | | | Instances | |
|
|
| Operations on mutable arrays
|
|
|
| Creating unboxed arrays
------------------------
|
|
|
|
|
| Permutations
-------------
|
|
|
|
|
| Fill a mutable array from a stream from left to right and yield
the number of elements written.
|
|
| Strict pairs and sums
|
|
|
| Strict pair
| | Constructors | | | Instances | |
|
|
|
|
|
| Injection and projection functions
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Currying
|
|
| curryS :: ((a :*: b) -> c) -> a -> b -> c | Source |
|
|
| uncurryS :: (a -> b -> c) -> (a :*: b) -> c | Source |
|
|
| Strict Maybe
|
|
|
| Strict Maybe
| | Constructors | | | Instances | |
|
|
|
|
|
|
| Lazy wrapper
|
|
| Class of hyperstrict types
|
|
| Produced by Haddock version 2.4.2 |
