base-4.3.0.0: Basic libraries

Portabilitynon-portable (GHC Extensions) Basic implementation of Parallel Arrays. This module has two functions: (1) It defines the interface to the parallel array extension of the Prelude and (2) it provides a vanilla implementation of parallel arrays that does not require to flatten the array code. The implementation is not very optimised.
Stabilityinternal
MaintainerManuel M. T. Chakravarty <chak@cse.unsw.edu.au>

GHC.PArr

Description

 

Synopsis

Documentation

mapP :: (a -> b) -> [:a:] -> [:b:]

(+:+) :: [:a:] -> [:a:] -> [:a:]

filterP :: (a -> Bool) -> [:a:] -> [:a:]

concatP :: [:[:a:]:] -> [:a:]

concatMapP :: (a -> [:b:]) -> [:a:] -> [:b:]

nullP :: [:a:] -> Bool

lengthP :: [:a:] -> Int

(!:) :: [:a:] -> Int -> a

foldlP :: (a -> b -> a) -> a -> [:b:] -> a

foldl1P :: (a -> a -> a) -> [:a:] -> a

scanlP :: (a -> b -> a) -> a -> [:b:] -> [:a:]

scanl1P :: (a -> a -> a) -> [:a:] -> [:a:]

foldrP :: (a -> b -> b) -> b -> [:a:] -> b

foldr1P :: (a -> a -> a) -> [:a:] -> a

scanrP :: (a -> b -> b) -> b -> [:a:] -> [:b:]

scanr1P :: (a -> a -> a) -> [:a:] -> [:a:]

singletonP :: a -> [:a:]

emptyP :: [:a:]

replicateP :: Int -> a -> [:a:]

takeP :: Int -> [:a:] -> [:a:]

dropP :: Int -> [:a:] -> [:a:]

splitAtP :: Int -> [:a:] -> ([:a:], [:a:])

takeWhileP :: (a -> Bool) -> [:a:] -> [:a:]

dropWhileP :: (a -> Bool) -> [:a:] -> [:a:]

spanP :: (a -> Bool) -> [:a:] -> ([:a:], [:a:])

breakP :: (a -> Bool) -> [:a:] -> ([:a:], [:a:])

reverseP :: [:a:] -> [:a:]

andP :: [:Bool:] -> Bool

orP :: [:Bool:] -> Bool

anyP :: (a -> Bool) -> [:a:] -> Bool

allP :: (a -> Bool) -> [:a:] -> Bool

elemP :: Eq a => a -> [:a:] -> Bool

notElemP :: Eq a => a -> [:a:] -> Bool

lookupP :: Eq a => a -> [:(a, b):] -> Maybe b

sumP :: Num a => [:a:] -> a

productP :: Num a => [:a:] -> a

maximumP :: Ord a => [:a:] -> a

minimumP :: Ord a => [:a:] -> a

zipP :: [:a:] -> [:b:] -> [:(a, b):]

zip3P :: [:a:] -> [:b:] -> [:c:] -> [:(a, b, c):]

zipWithP :: (a -> b -> c) -> [:a:] -> [:b:] -> [:c:]

zipWith3P :: (a -> b -> c -> d) -> [:a:] -> [:b:] -> [:c:] -> [:d:]

unzipP :: [:(a, b):] -> ([:a:], [:b:])

unzip3P :: [:(a, b, c):] -> ([:a:], [:b:], [:c:])

enumFromToP :: Enum a => a -> a -> [:a:]

enumFromThenToP :: Enum a => a -> a -> a -> [:a:]

toP :: [a] -> [:a:]

fromP :: [:a:] -> [a]

sliceP :: Int -> Int -> [:e:] -> [:e:]

foldP :: (e -> e -> e) -> e -> [:e:] -> e

fold1P :: (e -> e -> e) -> [:e:] -> e

permuteP :: [:Int:] -> [:e:] -> [:e:]

bpermuteP :: [:Int:] -> [:e:] -> [:e:]

dpermuteP :: [:Int:] -> [:e:] -> [:e:] -> [:e:]

crossP :: [:a:] -> [:b:] -> [:(a, b):]

crossMapP :: [:a:] -> (a -> [:b:]) -> [:(a, b):]

Compute a cross of an array and the arrays produced by the given function for the elements of the first array.

indexOfP :: (a -> Bool) -> [:a:] -> [:Int:]