Alib

Code adapted from: http://web.engr.oregonstate.edu/~erwig/meta/

Documentation (and further updates in technique) forthcoming.

Constructors (Emitters) and Destructors (Absorbers) -- Functions

cRose :: a

dRose :: a

nat :: SymA I Int

evn :: SymA I Int

halves :: SymA I Int

nat2 :: (IxI -> Bool) -> (IxI -> IxI) -> A () (II Int) IxI

rng :: A (I Int) (II Int) Int

rng' :: A () (II Int) Int

count :: A (II a Int) I Int

prod :: A (II Int Int) I Int

summ :: A (II Int Int) I Int

bool :: BinA Bool Bool

boolAnd :: BinA Bool Bool

Familar Data Structures

set :: (Num a, Eq a) => BinA a [a]

list :: BinA a [a]

queue :: BinA a [a]

pqueue :: Ord a => BinA a [a]

pqueueH :: Ord a => BinA a (Heap a)

jPqueueH :: Ord a => JoinA a Heap

jQueue :: JoinA a []

jList :: JoinA a []

jPqueue :: Ord a => JoinA a []

bag :: Ord a => BinA a (FiniteMap a Int)

arr :: Ord i => (a -> a -> a) -> BinA (i, a) (FiniteMap i a)

fork :: Ord a => A (II a [a]) (IIV [a]) [a]

final :: A (II a (Maybe a)) Id (Maybe a)

combine :: A (IIV [a] [a]) (II a) [a]

tree :: SymA (IIV a) (Tree a)

rose :: SymA (Power a) (Rose a)

graph :: BinA (Context a b) (Graph a b)

type LinGraph a b = II (Context a b) (Graph a b)

cGraph :: LinGraph a b -> Graph a b

22 data structures in 22 lines

stack :: BinA a [a]

jStack :: JoinA a []

Helpers (Selectors, Appends (with swap))

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

rest :: Eq a => [a] -> [a]

append213 :: [a] -> [a] -> [a] -> [a]

Helpers (Accumulation and Splitting)

accum :: Ord o => (a -> a -> a) -> (o, a) -> FiniteMap o a -> FiniteMap o a

add :: (Ord o, Num a) => o -> FiniteMap o a -> FiniteMap o a

split_bag :: (Ord o, Eq a, Num a) => FiniteMap o a -> (o, FiniteMap o a)

split_arr :: Ord o => FiniteMap o a -> ((o, a), FiniteMap o a)

Constructors (Emitters) and Destructors (Absorbers) -- Type Signatures

cNat :: I Int -> Int

construct (resp. destroy) a I of Naturals using Ints.

dNat :: Int -> I Int

construct (resp. destroy) a I of Naturals using Ints. | construct (resp. destroy) a II of as using Lists

cList :: II a [a] -> [a]

dList :: [a] -> II a [a]

construct (resp. destroy) a II of as using base Lists

dPqueue :: Ord a => [a] -> II a [a]

destroy priority queue (a II over base Lists)

dPqueueH :: Ord a => Heap a -> II a (Heap a)

destroy priority queue heap (a II (Bifunctor) over Heaps) | construct (resp. destroy) a II of two Naturals using Ints.

cProd :: II Int Int -> Int

dProd :: Int -> II Int Int

construct (resp. destroy) a II of two Naturals using Ints.

type IxI

Arguments

 = (Int, Int)

a simple type for pairs of integers (not used yet!)

Rose Trees

data Rose a

Constructors

Null

Nd a [Rose a]

Instances

Show a => Show (Rose a)

type Forest a = [Rose a]

forest' :: PowA a (Rose a)

forest :: A (Id [Rose a]) (II [a]) [Rose a]

Rose Tree Smart Constructors

isNull :: Rose a -> Bool

cut :: Rose a -> (a, [Rose a])

root :: Rose a -> a

kids :: Rose t -> [Rose t]

Linear Graphs (not really complete)

bufGraph :: JoinA c f -> (c -> Node) -> (c -> Context a b -> [c]) -> A () (II (MContext a b)) (f c, Graph a b)

Utilities

q1 :: (t, x, y, z) -> t

q2 :: (t, x, y, z) -> x

q23 :: (t, x, y, z) -> (x, y)

q4 :: (t, x, y, z) -> z

o :: (b1 -> c) -> (a -> b -> b1) -> a -> b -> c

curried composition

o :: forall a f g b. (b -> a) -> (f -> g -> b) -> f -> g -> a

Extra! (perhaps not needed)

data NoK o

Constructors

No

OK o

(><) :: (t -> t2) -> (t1 -> t3) -> (t, t1) -> (t2, t3)

(/\) :: (t2 -> t) -> (t2 -> t1) -> t2 -> (t, t1)