Data.Raz.Core.Internal

Documentation

type Lev = Int

type Cnt = Int

data Dir

Constructors

L

R

Instances

Eq Dir

Methods

(==) :: Dir -> Dir -> Bool

(/=) :: Dir -> Dir -> Bool

Ord Dir

Methods

compare :: Dir -> Dir -> Ordering

(<) :: Dir -> Dir -> Bool

(<=) :: Dir -> Dir -> Bool

(>) :: Dir -> Dir -> Bool

(>=) :: Dir -> Dir -> Bool

max :: Dir -> Dir -> Dir

min :: Dir -> Dir -> Dir

Read Dir

Methods

readsPrec :: Int -> ReadS Dir

readList :: ReadS [Dir]

readPrec :: ReadPrec Dir

readListPrec :: ReadPrec [Dir]

Show Dir

Methods

showsPrec :: Int -> Dir -> ShowS

show :: Dir -> String

showList :: [Dir] -> ShowS

data Tree a

Constructors

Empty

Leaf a

Bin !Lev !Cnt !(Tree a) !(Tree a)

Instances

Functor Tree

Methods

fmap :: (a -> b) -> Tree a -> Tree b

(<$) :: a -> Tree b -> Tree a

Foldable Tree

Methods

fold :: Monoid m => Tree m -> m

foldMap :: Monoid m => (a -> m) -> Tree a -> m

foldr :: (a -> b -> b) -> b -> Tree a -> b

foldr' :: (a -> b -> b) -> b -> Tree a -> b

foldl :: (b -> a -> b) -> b -> Tree a -> b

foldl' :: (b -> a -> b) -> b -> Tree a -> b

foldr1 :: (a -> a -> a) -> Tree a -> a

foldl1 :: (a -> a -> a) -> Tree a -> a

toList :: Tree a -> [a]

null :: Tree a -> Bool

length :: Tree a -> Int

elem :: Eq a => a -> Tree a -> Bool

maximum :: Ord a => Tree a -> a

minimum :: Ord a => Tree a -> a

sum :: Num a => Tree a -> a

product :: Num a => Tree a -> a

Traversable Tree

Methods

traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b)

sequenceA :: Applicative f => Tree (f a) -> f (Tree a)

mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b)

sequence :: Monad m => Tree (m a) -> m (Tree a)

Eq a => Eq (Tree a)

Methods

(==) :: Tree a -> Tree a -> Bool

(/=) :: Tree a -> Tree a -> Bool

Ord a => Ord (Tree a)

Methods

compare :: Tree a -> Tree a -> Ordering

(<) :: Tree a -> Tree a -> Bool

(<=) :: Tree a -> Tree a -> Bool

(>) :: Tree a -> Tree a -> Bool

(>=) :: Tree a -> Tree a -> Bool

max :: Tree a -> Tree a -> Tree a

min :: Tree a -> Tree a -> Tree a

Read a => Read (Tree a)

Methods

readsPrec :: Int -> ReadS (Tree a)

readList :: ReadS [Tree a]

readPrec :: ReadPrec (Tree a)

readListPrec :: ReadPrec [Tree a]

Show a => Show (Tree a)

Methods

showsPrec :: Int -> Tree a -> ShowS

show :: Tree a -> String

showList :: [Tree a] -> ShowS

data TList a

Constructors

Nil

Cons a !(TList a)

Level Lev !(TList a)

Tree !(Tree a) !(TList a)

Instances

Functor TList

Methods

fmap :: (a -> b) -> TList a -> TList b

(<$) :: a -> TList b -> TList a

Foldable TList

Methods

fold :: Monoid m => TList m -> m

foldMap :: Monoid m => (a -> m) -> TList a -> m

foldr :: (a -> b -> b) -> b -> TList a -> b

foldr' :: (a -> b -> b) -> b -> TList a -> b

foldl :: (b -> a -> b) -> b -> TList a -> b

foldl' :: (b -> a -> b) -> b -> TList a -> b

foldr1 :: (a -> a -> a) -> TList a -> a

foldl1 :: (a -> a -> a) -> TList a -> a

toList :: TList a -> [a]

null :: TList a -> Bool

length :: TList a -> Int

elem :: Eq a => a -> TList a -> Bool

maximum :: Ord a => TList a -> a

minimum :: Ord a => TList a -> a

sum :: Num a => TList a -> a

product :: Num a => TList a -> a

Traversable TList

Methods

traverse :: Applicative f => (a -> f b) -> TList a -> f (TList b)

sequenceA :: Applicative f => TList (f a) -> f (TList a)

mapM :: Monad m => (a -> m b) -> TList a -> m (TList b)

sequence :: Monad m => TList (m a) -> m (TList a)

Eq a => Eq (TList a)

Methods

(==) :: TList a -> TList a -> Bool

(/=) :: TList a -> TList a -> Bool

Ord a => Ord (TList a)

Methods

compare :: TList a -> TList a -> Ordering

(<) :: TList a -> TList a -> Bool

(<=) :: TList a -> TList a -> Bool

(>) :: TList a -> TList a -> Bool

(>=) :: TList a -> TList a -> Bool

max :: TList a -> TList a -> TList a

min :: TList a -> TList a -> TList a

type Raz a = (TList a, a, TList a)

randomLevel :: MonadRandom m => m Lev

singleton :: a -> Raz a

empty :: MonadRandom m => a -> m (Raz a)

size :: Tree a -> Cnt

trim :: Dir -> TList a -> TList a

trim' :: Dir -> Tree a -> TList a -> TList a

viewC :: Raz a -> a

view :: Dir -> Raz a -> a

view' :: Dir -> TList a -> a

alterC :: a -> Raz a -> Raz a

adjustC :: (a -> a) -> Raz a -> Raz a

adjustC' :: (a -> a) -> Raz a -> Raz a

alter :: Dir -> a -> Raz a -> Raz a

alter' :: Dir -> a -> TList a -> TList a

insert :: MonadRandom m => Dir -> a -> Raz a -> m (Raz a)

remove :: Dir -> Raz a -> Raz a

remove' :: Dir -> TList a -> (a, TList a)

removeC :: Dir -> Raz a -> Raz a

move :: Dir -> Raz a -> Raz a

move' :: Dir -> TList a -> TList a -> Raz a

focus :: Int -> Tree a -> Raz a

focus' :: Int -> TList a -> TList a -> Tree a -> Raz a

focusL :: Tree a -> Raz a

focusL' :: TList a -> Tree a -> Raz a

focusR :: Tree a -> Raz a

focusR' :: TList a -> Tree a -> Raz a

joinSides :: Tree a -> Tree a -> Tree a

headAsTree :: TList a -> Tree a

tail :: TList a -> TList a

grow :: Dir -> TList a -> Tree a

grow' :: Dir -> Tree a -> TList a -> Tree a

unfocus :: Raz a -> Tree a

fromList :: MonadRandom m => [a] -> m (Tree a)

fromList' :: MonadRandom m => TList a -> [a] -> m (Tree a)

push :: Lev -> TList a -> TList a

fold :: TList a -> Tree a

bin :: Lev -> Tree a -> Tree a -> Tree a

Combinators

insertAt' :: MonadRandom m => Dir -> Int -> a -> Tree a -> m (Tree a)

Displaying Raz

showRaz :: (a -> String) -> Raz a -> String

treeToList :: Dir -> Tree a -> [a] -> [a]

halfToList :: Dir -> TList a -> [a] -> [a]

showTree :: (a -> String) -> Tree a -> String