EdisonCore-1.3.1.1: A library of efficent, purely-functional data structures (Core Implementations)

Copyright | Copyright (c) 1998, 2008 Chris Okasaki
License | MIT; see COPYRIGHT file for terms and conditions
Maintainer | robdockins AT fastmail DOT fm
Stability | internal (unstable)
Portability | GHC, Hugs (MPTC and FD)
Safe Haskell | None
Language | Haskell2010

Data.Edison.Seq.Defaults

Description

This module provides default implementations of many of the sequence operations. It is used to fill in implementations and is not intended for end users.

# Documentation

rconsUsingAppend :: Sequence s => a -> s a -> s a #

rconsUsingFoldr :: Sequence s => a -> s a -> s a #

appendUsingFoldr :: Sequence s => s a -> s a -> s a #

rviewDefault :: (Monad m, Sequence s) => s a -> m (a, s a) #

rtailUsingLview :: Sequence s => s a -> s a #

rtailMUsingLview :: (Monad m, Sequence s) => s a -> m (s a) #

concatUsingFoldr :: Sequence s => s (s a) -> s a #

reverseUsingReverseOnto :: Sequence s => s a -> s a #

reverseUsingLists :: Sequence s => s a -> s a #

reverseOntoUsingFoldl :: Sequence s => s a -> s a -> s a #

reverseOntoUsingReverse :: Sequence s => s a -> s a -> s a #

fromListUsingCons :: Sequence s => [a] -> s a #

toListUsingFoldr :: Sequence s => s a -> [a] #

mapUsingFoldr :: Sequence s => (a -> b) -> s a -> s b #

concatMapUsingFoldr :: Sequence s => (a -> s b) -> s a -> s b #

foldrUsingLists :: Sequence s => (a -> b -> b) -> b -> s a -> b #

foldr'UsingLists :: Sequence s => (a -> b -> b) -> b -> s a -> b #

foldlUsingLists :: Sequence s => (b -> a -> b) -> b -> s a -> b #

foldl'UsingLists :: Sequence s => (b -> a -> b) -> b -> s a -> b #

foldr1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

foldr1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

foldl1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

foldl1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

fold1UsingFold :: Sequence s => (a -> a -> a) -> s a -> a #

fold1'UsingFold' :: Sequence s => (a -> a -> a) -> s a -> a #

foldr1UsingLview :: Sequence s => (a -> a -> a) -> s a -> a #

foldr1'UsingLview :: Sequence s => (a -> a -> a) -> s a -> a #

foldl1UsingFoldl :: Sequence s => (a -> a -> a) -> s a -> a #

foldl1'UsingFoldl' :: Sequence s => (a -> a -> a) -> s a -> a #

reducerUsingReduce1 :: Sequence s => (a -> a -> a) -> a -> s a -> a #

reducer'UsingReduce1' :: Sequence s => (a -> a -> a) -> a -> s a -> a #

reducelUsingReduce1 :: Sequence s => (a -> a -> a) -> a -> s a -> a #

reducel'UsingReduce1' :: Sequence s => (a -> a -> a) -> a -> s a -> a #

reduce1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

reduce1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a #

copyUsingLists :: Sequence s => Int -> a -> s a #

inBoundsUsingDrop :: Sequence s => Int -> s a -> Bool #

inBoundsUsingLookupM :: Sequence s => Int -> s a -> Bool #

inBoundsUsingSize :: Sequence s => Int -> s a -> Bool #

lookupUsingLookupM :: Sequence s => Int -> s a -> a #

lookupUsingDrop :: Sequence s => Int -> s a -> a #

lookupWithDefaultUsingLookupM :: Sequence s => a -> Int -> s a -> a #

lookupWithDefaultUsingDrop :: Sequence s => a -> Int -> s a -> a #

lookupMUsingDrop :: (Monad m, Sequence s) => Int -> s a -> m a #

filterUsingLview :: Sequence s => (a -> Bool) -> s a -> s a #

filterUsingLists :: Sequence s => (a -> Bool) -> s a -> s a #

filterUsingFoldr :: Sequence s => (a -> Bool) -> s a -> s a #

partitionUsingLists :: Sequence s => (a -> Bool) -> s a -> (s a, s a) #

partitionUsingFoldr :: Sequence s => (a -> Bool) -> s a -> (s a, s a) #

updateUsingAdjust :: Sequence s => Int -> a -> s a -> s a #

updateUsingSplitAt :: Sequence s => Int -> a -> s a -> s a #

adjustUsingLists :: Sequence s => (a -> a) -> Int -> s a -> s a #

adjustUsingSplitAt :: Sequence s => (a -> a) -> Int -> s a -> s a #

mapWithIndexUsingLists :: Sequence s => (Int -> a -> b) -> s a -> s b #

foldrWithIndexUsingLists :: Sequence s => (Int -> a -> b -> b) -> b -> s a -> b #

foldrWithIndex'UsingLists :: Sequence s => (Int -> a -> b -> b) -> b -> s a -> b #

foldlWithIndexUsingLists :: Sequence s => (b -> Int -> a -> b) -> b -> s a -> b #

foldlWithIndex'UsingLists :: Sequence s => (b -> Int -> a -> b) -> b -> s a -> b #

takeUsingLists :: Sequence s => Int -> s a -> s a #

takeUsingLview :: Sequence s => Int -> s a -> s a #

dropUsingLists :: Sequence s => Int -> s a -> s a #

dropUsingLtail :: Sequence s => Int -> s a -> s a #

splitAtDefault :: Sequence s => Int -> s a -> (s a, s a) #

splitAtUsingLview :: Sequence s => Int -> s a -> (s a, s a) #

subseqDefault :: Sequence s => Int -> Int -> s a -> s a #

takeWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> s a #

dropWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> s a #

splitWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> (s a, s a) #

zipUsingLview :: Sequence s => s a -> s b -> s (a, b) #

zip3UsingLview :: Sequence s => s a -> s b -> s c -> s (a, b, c) #

zipWithUsingLview :: Sequence s => (a -> b -> c) -> s a -> s b -> s c #

zipWith3UsingLview :: Sequence s => (a -> b -> c -> d) -> s a -> s b -> s c -> s d #

zipUsingLists :: Sequence s => s a -> s b -> s (a, b) #

zip3UsingLists :: Sequence s => s a -> s b -> s c -> s (a, b, c) #

zipWithUsingLists :: Sequence s => (a -> b -> c) -> s a -> s b -> s c #

zipWith3UsingLists :: Sequence s => (a -> b -> c -> d) -> s a -> s b -> s c -> s d #

unzipUsingLists :: Sequence s => s (a, b) -> (s a, s b) #

unzipUsingFoldr :: Sequence s => s (a, b) -> (s a, s b) #

unzip3UsingLists :: Sequence s => s (a, b, c) -> (s a, s b, s c) #

unzip3UsingFoldr :: Sequence s => s (a, b, c) -> (s a, s b, s c) #

unzipWithUsingLists :: Sequence s => (a -> b) -> (a -> c) -> s a -> (s b, s c) #

unzipWithUsingFoldr :: Sequence s => (a -> b) -> (a -> c) -> s a -> (s b, s c) #

unzipWith3UsingLists :: Sequence s => (a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d) #

unzipWith3UsingFoldr :: Sequence s => (a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d) #

showsPrecUsingToList :: (Show a, Sequence s) => Int -> s a -> ShowS #

readsPrecUsingFromList :: (Read a, Sequence s) => Int -> ReadS (s a) #

defaultCompare :: (Ord a, Sequence s) => s a -> s a -> Ordering #

dropMatch :: (Eq a, MonadPlus m) => [a] -> [a] -> m [a] #

tokenMatch :: MonadPlus m => String -> String -> m String #

readSParens :: ReadS a -> ReadS a #

maybeParens :: ReadS a -> ReadS a #