twee-0.1: An equational theorem prover

Safe HaskellNone
LanguageHaskell2010

Twee.Queue

Synopsis

Documentation

class Heuristic h where Source #

Minimal complete definition

insert, remove

Methods

insert :: Ord a => a -> h a -> h a Source #

remove :: Ord a => h a -> Maybe (a, h a) Source #

reinsert :: Ord a => a -> h a -> h a Source #

members :: Ord a => h a -> [a] Source #

Instances

Heuristic Heap Source # 

Methods

insert :: Ord a => a -> Heap a -> Heap a Source #

remove :: Ord a => Heap a -> Maybe (a, Heap a) Source #

reinsert :: Ord a => a -> Heap a -> Heap a Source #

members :: Ord a => Heap a -> [a] Source #

Heuristic FIFO Source # 

Methods

insert :: Ord a => a -> FIFO a -> FIFO a Source #

remove :: Ord a => FIFO a -> Maybe (a, FIFO a) Source #

reinsert :: Ord a => a -> FIFO a -> FIFO a Source #

members :: Ord a => FIFO a -> [a] Source #

Heuristic h => Heuristic (Mix h) Source # 

Methods

insert :: Ord a => a -> Mix h a -> Mix h a Source #

remove :: Ord a => Mix h a -> Maybe (a, Mix h a) Source #

reinsert :: Ord a => a -> Mix h a -> Mix h a Source #

members :: Ord a => Mix h a -> [a] Source #

(Heuristic h1, Heuristic h2) => Heuristic (Either1 h1 h2) Source # 

Methods

insert :: Ord a => a -> Either1 h1 h2 a -> Either1 h1 h2 a Source #

remove :: Ord a => Either1 h1 h2 a -> Maybe (a, Either1 h1 h2 a) Source #

reinsert :: Ord a => a -> Either1 h1 h2 a -> Either1 h1 h2 a Source #

members :: Ord a => Either1 h1 h2 a -> [a] Source #

data FIFO a Source #

Constructors

FIFO [a] [a] 

Instances

Heuristic FIFO Source # 

Methods

insert :: Ord a => a -> FIFO a -> FIFO a Source #

remove :: Ord a => FIFO a -> Maybe (a, FIFO a) Source #

reinsert :: Ord a => a -> FIFO a -> FIFO a Source #

members :: Ord a => FIFO a -> [a] Source #

Show a => Show (FIFO a) Source # 

Methods

showsPrec :: Int -> FIFO a -> ShowS #

show :: FIFO a -> String #

showList :: [FIFO a] -> ShowS #

data Either1 h1 h2 a Source #

Constructors

Left1 (h1 a) 
Right1 (h2 a) 

Instances

(Heuristic h1, Heuristic h2) => Heuristic (Either1 h1 h2) Source # 

Methods

insert :: Ord a => a -> Either1 h1 h2 a -> Either1 h1 h2 a Source #

remove :: Ord a => Either1 h1 h2 a -> Maybe (a, Either1 h1 h2 a) Source #

reinsert :: Ord a => a -> Either1 h1 h2 a -> Either1 h1 h2 a Source #

members :: Ord a => Either1 h1 h2 a -> [a] Source #

(Show (h2 a), Show (h1 a)) => Show (Either1 h1 h2 a) Source # 

Methods

showsPrec :: Int -> Either1 h1 h2 a -> ShowS #

show :: Either1 h1 h2 a -> String #

showList :: [Either1 h1 h2 a] -> ShowS #

data Mix h a Source #

Constructors

Mix 

Fields

Instances

Heuristic h => Heuristic (Mix h) Source # 

Methods

insert :: Ord a => a -> Mix h a -> Mix h a Source #

remove :: Ord a => Mix h a -> Maybe (a, Mix h a) Source #

reinsert :: Ord a => a -> Mix h a -> Mix h a Source #

members :: Ord a => Mix h a -> [a] Source #

Show (h a) => Show (Mix h a) Source # 

Methods

showsPrec :: Int -> Mix h a -> ShowS #

show :: Mix h a -> String #

showList :: [Mix h a] -> ShowS #

emptyMix :: Int -> Int -> h a -> h a -> Mix h a Source #

data Queue h a Source #

Constructors

Queue 

Fields

Instances

Show (h a) => Show (Queue h a) Source # 

Methods

showsPrec :: Int -> Queue h a -> ShowS #

show :: Queue h a -> String #

showList :: [Queue h a] -> ShowS #

class Ord a => Labels a where Source #

Minimal complete definition

labels

Methods

labels :: a -> [Label] Source #

Instances

Labels (Passive f) Source # 

Methods

labels :: Passive f -> [Label] Source #

Labels (CPs f) Source # 

Methods

labels :: CPs f -> [Label] Source #

Labels (CP f) Source # 

Methods

labels :: CP f -> [Label] Source #

empty :: h a -> Queue h a Source #

emptyFrom :: Queue q a -> Queue q a Source #

enqueue :: (Heuristic h, Labels a) => a -> Queue h a -> Queue h a Source #

reenqueue :: (Heuristic h, Labels a) => a -> Queue h a -> Queue h a Source #

dequeue :: (Heuristic h, Labels a) => Queue h a -> Maybe (a, Queue h a) Source #

queueSize :: (Heuristic h, Labels a) => Queue h a -> Int Source #

toList :: (Heuristic h, Labels a) => Queue h a -> [a] Source #

newLabel :: Queue h a -> (Label, Queue h a) Source #

deleteLabel :: Label -> Queue h a -> Queue h a Source #

data Labelled a Source #

Constructors

Labelled 

Fields

Instances

Functor Labelled Source # 

Methods

fmap :: (a -> b) -> Labelled a -> Labelled b #

(<$) :: a -> Labelled b -> Labelled a #

Eq (Labelled a) Source # 

Methods

(==) :: Labelled a -> Labelled a -> Bool #

(/=) :: Labelled a -> Labelled a -> Bool #

Ord (Labelled a) Source # 

Methods

compare :: Labelled a -> Labelled a -> Ordering #

(<) :: Labelled a -> Labelled a -> Bool #

(<=) :: Labelled a -> Labelled a -> Bool #

(>) :: Labelled a -> Labelled a -> Bool #

(>=) :: Labelled a -> Labelled a -> Bool #

max :: Labelled a -> Labelled a -> Labelled a #

min :: Labelled a -> Labelled a -> Labelled a #

Show a => Show (Labelled a) Source # 

Methods

showsPrec :: Int -> Labelled a -> ShowS #

show :: Labelled a -> String #

showList :: [Labelled a] -> ShowS #

Pretty a => Pretty (Labelled a) Source # 
Symbolic a => Symbolic (Labelled a) Source # 
type ConstantOf (Labelled a) Source # 

moveLabel :: Functor f => Labelled (f a) -> f (Labelled a) Source #

data Heap a :: * -> * #

A min-heap of values of type a.

Instances

Foldable Heap 

Methods

fold :: Monoid m => Heap m -> m #

foldMap :: Monoid m => (a -> m) -> Heap a -> m #

foldr :: (a -> b -> b) -> b -> Heap a -> b #

foldr' :: (a -> b -> b) -> b -> Heap a -> b #

foldl :: (b -> a -> b) -> b -> Heap a -> b #

foldl' :: (b -> a -> b) -> b -> Heap a -> b #

foldr1 :: (a -> a -> a) -> Heap a -> a #

foldl1 :: (a -> a -> a) -> Heap a -> a #

toList :: Heap a -> [a] #

null :: Heap a -> Bool #

length :: Heap a -> Int #

elem :: Eq a => a -> Heap a -> Bool #

maximum :: Ord a => Heap a -> a #

minimum :: Ord a => Heap a -> a #

sum :: Num a => Heap a -> a #

product :: Num a => Heap a -> a #

Heuristic Heap Source # 

Methods

insert :: Ord a => a -> Heap a -> Heap a Source #

remove :: Ord a => Heap a -> Maybe (a, Heap a) Source #

reinsert :: Ord a => a -> Heap a -> Heap a Source #

members :: Ord a => Heap a -> [a] Source #

Eq (Heap a) 

Methods

(==) :: Heap a -> Heap a -> Bool #

(/=) :: Heap a -> Heap a -> Bool #

(Ord a, Data a) => Data (Heap a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Heap a -> c (Heap a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Heap a) #

toConstr :: Heap a -> Constr #

dataTypeOf :: Heap a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Heap a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Heap a)) #

gmapT :: (forall b. Data b => b -> b) -> Heap a -> Heap a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Heap a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Heap a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Heap a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Heap a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Heap a -> m (Heap a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Heap a -> m (Heap a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Heap a -> m (Heap a) #

Ord (Heap a) 

Methods

compare :: Heap a -> Heap a -> Ordering #

(<) :: Heap a -> Heap a -> Bool #

(<=) :: Heap a -> Heap a -> Bool #

(>) :: Heap a -> Heap a -> Bool #

(>=) :: Heap a -> Heap a -> Bool #

max :: Heap a -> Heap a -> Heap a #

min :: Heap a -> Heap a -> Heap a #

(Ord a, Read a) => Read (Heap a) 
Show a => Show (Heap a) 

Methods

showsPrec :: Int -> Heap a -> ShowS #

show :: Heap a -> String #

showList :: [Heap a] -> ShowS #

Monoid (Heap a) 

Methods

mempty :: Heap a #

mappend :: Heap a -> Heap a -> Heap a #

mconcat :: [Heap a] -> Heap a #