Data.Raz.Sequence.Internal

Types

data Seq' g a

Constructors

Seq' !g !(Tree a)

Instances

Functor (Seq' g)

Methods

fmap :: (a -> b) -> Seq' g a -> Seq' g b

(<$) :: a -> Seq' g b -> Seq' g a

Applicative (Seq' StdGen)

pure :: a -> Impure (Seq a)
(<*>) :: Seq (a -> b) -> Seq a -> Seq b

Methods

pure :: a -> Seq' StdGen a

(<*>) :: Seq' StdGen (a -> b) -> Seq' StdGen a -> Seq' StdGen b

(*>) :: Seq' StdGen a -> Seq' StdGen b -> Seq' StdGen b

(<*) :: Seq' StdGen a -> Seq' StdGen b -> Seq' StdGen a

Foldable (Seq' g)

Methods

fold :: Monoid m => Seq' g m -> m

foldMap :: Monoid m => (a -> m) -> Seq' g a -> m

foldr :: (a -> b -> b) -> b -> Seq' g a -> b

foldr' :: (a -> b -> b) -> b -> Seq' g a -> b

foldl :: (b -> a -> b) -> b -> Seq' g a -> b

foldl' :: (b -> a -> b) -> b -> Seq' g a -> b

foldr1 :: (a -> a -> a) -> Seq' g a -> a

foldl1 :: (a -> a -> a) -> Seq' g a -> a

toList :: Seq' g a -> [a]

null :: Seq' g a -> Bool

length :: Seq' g a -> Int

elem :: Eq a => a -> Seq' g a -> Bool

maximum :: Ord a => Seq' g a -> a

minimum :: Ord a => Seq' g a -> a

sum :: Num a => Seq' g a -> a

product :: Num a => Seq' g a -> a

Traversable (Seq' g)

Methods

traverse :: Applicative f => (a -> f b) -> Seq' g a -> f (Seq' g b)

sequenceA :: Applicative f => Seq' g (f a) -> f (Seq' g a)

mapM :: Monad m => (a -> m b) -> Seq' g a -> m (Seq' g b)

sequence :: Monad m => Seq' g (m a) -> m (Seq' g a)

Eq a => Eq (Seq' g a)

Methods

(==) :: Seq' g a -> Seq' g a -> Bool

(/=) :: Seq' g a -> Seq' g a -> Bool

Ord a => Ord (Seq' g a)

Methods

compare :: Seq' g a -> Seq' g a -> Ordering

(<) :: Seq' g a -> Seq' g a -> Bool

(<=) :: Seq' g a -> Seq' g a -> Bool

(>) :: Seq' g a -> Seq' g a -> Bool

(>=) :: Seq' g a -> Seq' g a -> Bool

max :: Seq' g a -> Seq' g a -> Seq' g a

min :: Seq' g a -> Seq' g a -> Seq' g a

Show a => Show (Seq' g a)

Methods

showsPrec :: Int -> Seq' g a -> ShowS

show :: Seq' g a -> String

showList :: [Seq' g a] -> ShowS

Synonyms

The actual type signatures of functions in this module are as general as possible. Alternative signatures may appear in comments:

• a purely informative "enriched" type with Impure and Splittable marking certain implementation details;
• a specialization at type Seq that parallels the Data.Sequence API.

type Seq = Seq' StdGen

The sequence type with a default generator.

type Impure a = a

A type synonym for documentation. Marks uses of unsafePerformIO.

type Splittable g = RandomGen g

A type synonym for documentation. Marks functions that only use the split method of random generators.

Construction

Since RAZ makes use of randomness, a pure implementation will leak in the interface (e.g., via MonadRandom constraints or explicit generator passing).

In order to provide the same interface as Data.Sequence from containers, we cheat by requesting a random generator via unsafePerformIO and storing it alongside the sequence when constructing it.

Functions that transform existing sequences can then be implemented purely.

Alternative construction functions (empty', singleton', fromList') are provided for compatibility with other random generators.

empty :: Seq a

empty :: Impure (Seq a)

O(1). The empty sequence.

singleton :: a -> Seq a

singleton :: a -> Impure (Seq a)

O(1). A singleton sequence.

fromList :: [a] -> Seq a

fromList :: [a] -> Impure (Seq a)

O(n). Create a sequence from a finite list of elements.

The inverse toList is given by the Foldable instance of Seq.

fromFunction :: Int -> (Int -> a) -> Seq a

fromFunction :: Int -> (Int -> a) -> Impure (Seq a)
fromFunction n f = fromList (fmap f [0 .. n - 1])

O(n).

(<|) :: RandomGen g => a -> Seq' g a -> Seq' g a

(<|) :: a -> Seq a -> Seq a

(|>) :: RandomGen g => Seq' g a -> a -> Seq' g a

(|>) :: Seq a -> a -> Seq a

(><) :: RandomGen g => Seq' g a -> Seq' g a -> Seq' g a

(><) :: Seq a -> Seq a -> Seq a

empty' :: g -> Seq' g a

O(1). The empty sequence.

singleton' :: g -> a -> Seq' g a

O(1). A singleton sequence.

fromList' :: RandomGen g => g -> [a] -> Seq' g a

Repetition

replicate :: Int -> a -> Seq a

replicate :: Int -> a -> Impure (Seq a)

O(n).

replicateA :: Applicative f => Int -> f a -> f (Seq a)

replicateA :: Applicative f => Int -> f a -> f (Impure (Seq a))

O(n).

replicateM :: Monad m => Int -> m a -> m (Seq a)

replicateM :: Monad m => Int -> m a -> m (Impure (Seq a))

O(n).

cycleTaking :: RandomGen g => Int -> Seq' g a -> Seq' g a

cycleTaking :: Int -> Seq a -> Seq a

O(k).

Iterative construction

iterateN :: Int -> (a -> a) -> a -> Seq a

iterateN :: Int -> (a -> a) -> a -> Impure (Seq a)

O(n).

unfoldr :: (b -> Maybe (a, b)) -> b -> Seq a

unfoldr :: (b -> Maybe (a, b)) -> b -> Impure (Seq a)

O(n), where n is the length of the output sequence.

unfoldl :: (b -> Maybe (b, a)) -> b -> Seq a

unfoldl :: (b -> Maybe (b, a)) -> b -> Impure (Seq a)

O(n), where n is the length of the output sequence.

Deconstruction

Queries

null :: Seq' g a -> Bool

null :: Seq a -> Bool

O(1). Is this the empty sequence?

length :: Seq' g a -> Int

length :: Seq a -> Int

O(1). The number of elements in the sequence.

Views

data ViewL' g a

Constructors

EmptyL

a :< (Seq' g a)

viewl :: Seq' g a -> ViewL' g a

Sublists

tails :: RandomGen g => Seq' g a -> Seq' g (Seq' g a)

tails :: Splittable g => Seq' g a -> Seq' g (Seq' g a)
tails :: Seq a -> Seq (Seq a)

Sequential searches

takeWhileL :: (a -> Bool) -> Seq' g a -> Seq' g a

takeWhileL :: (a -> Bool) -> Seq a -> Seq a

takeWhileR :: (a -> Bool) -> Seq' g a -> Seq' g a

takeWhileR :: (a -> Bool) -> Seq a -> Seq a

dropWhileL :: (a -> Bool) -> Seq' g a -> Seq' g a

dropWhileL :: (a -> Bool) -> Seq a -> Seq a

dropWhileR :: (a -> Bool) -> Seq' g a -> Seq' g a

dropWhileR :: (a -> Bool) -> Seq a -> Seq a

spanl :: RandomGen g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)

spanl :: Splittable g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)
spanl :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

spanr :: RandomGen g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)

spanr :: Splittable g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)
spanr :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

breakl :: RandomGen g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)

breakl :: Splittable g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)
breakl :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

breakr :: RandomGen g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)

breakr :: Splittable g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)
breakr :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

partition :: RandomGen g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)

partition :: Splittable g => (a -> Bool) -> Seq' g a -> (Seq' g a, Seq' g a)
partition :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

filter :: (a -> Bool) -> Seq' g a -> Seq' g a

filter :: (a -> Bool) -> Seq a -> Seq a

Indexing

lookup :: Int -> Seq' g a -> Maybe a

lookup :: Int -> Seq a -> Maybe a

(?!) :: Seq' g a -> Int -> Maybe a

(?!) :: Seq a -> Int -> Maybe a

index :: Seq' g a -> Int -> a

index :: Seq a -> Int -> a

adjust :: (a -> a) -> Int -> Seq' g a -> Seq' g a

adjust :: (a -> a) -> Int -> Seq a -> Seq a

adjust' :: (a -> a) -> Int -> Seq' g a -> Seq' g a

adjust' :: (a -> a) -> Int -> Seq a -> Seq a

update :: Int -> a -> Seq' g a -> Seq' g a

update :: Int -> a -> Seq a -> Seq a

take :: Int -> Seq' g a -> Seq' g a

take :: Int -> Seq a -> Seq a

drop :: Int -> Seq' g a -> Seq' g a

drop :: Int -> Seq a -> Seq a

insertAt :: RandomGen g => Int -> a -> Seq' g a -> Seq' g a

insertAt :: Int -> a -> Seq a -> Seq a

deleteAt :: Int -> Seq' g a -> Seq' g a

deleteAt :: Int -> Seq a -> Seq a

splitAt :: RandomGen g => Int -> Seq' g a -> (Seq' g a, Seq' g a)

splitAt :: Splittable g => Int -> Seq' g a -> (Seq' g a, Seq' g a)
splitAt :: Int -> Seq a -> (Seq a, Seq a)

Transformations

mapWithIndex :: (Int -> a -> b) -> Seq' g a -> Seq' g b

mapWithIndex :: (Int -> a -> b) -> Seq a -> Seq b

traverseWithIndex :: Applicative f => (Int -> a -> f b) -> Seq' g a -> f (Seq' g b)

traverseWithIndex :: Applicative f => (Int -> a -> f b) -> Seq a -> Seq b

Zips

zip :: Seq' g a -> Seq' g b -> Seq' g (a, b)

zip :: Seq a -> Seq b -> Seq (a, b)

zipWith :: (a -> b -> c) -> Seq' g a -> Seq' g b -> Seq' g c

zipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

Random generator manipulation

splitSeq :: Splittable g => Seq' g a -> (Seq' g a, Seq' g a)

refreshSeq :: Seq' g a -> Impure (Seq a)

Put a fresh generator.

createSeq :: Tree a -> Impure (Seq a)

Wrap a Tree into a Seq.

seqBind :: Seq' g a -> (Tree a -> Rand g (Tree b)) -> Seq' g b

seqDnib :: (Tree a -> Rand g (Tree b)) -> Seq' g a -> Seq' g b

seqRun :: g -> Rand g (Tree a) -> Seq' g a

seqLift :: (Tree a -> Tree b) -> Seq' g a -> Seq' g b

seqLift2 :: (Tree a -> Tree b -> Tree c) -> Seq' g a -> Seq' g b -> Seq' g c

seqLiftSplit :: Splittable g => (Tree a -> (Tree b, Tree c)) -> Seq' g a -> (Seq' g b, Seq' g c)

seqApply :: (Tree a -> b) -> Seq' g a -> b

seqLens :: Functor f => (Tree a -> f (Tree b)) -> Seq' g a -> f (Seq' g b)