countable-1.0: Countable, Searchable, Finite, Empty classes

Safe HaskellSafe
LanguageHaskell2010

Data.Searchable

Contents

Description

This module also includes these orphan instances:

Synopsis

Documentation

class Searchable a where #

It turns out there are Searchable instances that are not Finite. The (c -> s) instance is based on the algorithm at http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/.

Minimal complete definition

search

Methods

search :: (a -> Maybe b) -> Maybe b #

Instances

Searchable Bool # 

Methods

search :: (Bool -> Maybe b) -> Maybe b #

Searchable Int8 # 

Methods

search :: (Int8 -> Maybe b) -> Maybe b #

Searchable Int16 # 

Methods

search :: (Int16 -> Maybe b) -> Maybe b #

Searchable Int32 # 

Methods

search :: (Int32 -> Maybe b) -> Maybe b #

Searchable Int64 # 

Methods

search :: (Int64 -> Maybe b) -> Maybe b #

Searchable Word8 # 

Methods

search :: (Word8 -> Maybe b) -> Maybe b #

Searchable Word16 # 

Methods

search :: (Word16 -> Maybe b) -> Maybe b #

Searchable Word32 # 

Methods

search :: (Word32 -> Maybe b) -> Maybe b #

Searchable Word64 # 

Methods

search :: (Word64 -> Maybe b) -> Maybe b #

Searchable () # 

Methods

search :: (() -> Maybe b) -> Maybe b #

Searchable None # 

Methods

search :: (None -> Maybe b) -> Maybe b #

Searchable a => Searchable (Maybe a) # 

Methods

search :: (Maybe a -> Maybe b) -> Maybe b #

(Countable c, Searchable s) => Searchable (c -> s) # 

Methods

search :: ((c -> s) -> Maybe b) -> Maybe b #

(Searchable a, Searchable b) => Searchable (Either a b) # 

Methods

search :: (Either a b -> Maybe b) -> Maybe b #

(Searchable a, Searchable b) => Searchable (a, b) # 

Methods

search :: ((a, b) -> Maybe b) -> Maybe b #

forsome :: Searchable a => (a -> Bool) -> Bool #

forevery :: Searchable a => (a -> Bool) -> Bool #

class (Searchable a, Countable a) => Finite a where #

Minimal complete definition

allValues

Methods

allValues :: [a] #

Not necessarily in counting order.

assemble :: forall b f. Applicative f => (a -> f b) -> f (a -> b) #

Instances

Finite Bool # 

Methods

allValues :: [Bool] #

assemble :: Applicative f => (Bool -> f b) -> f (Bool -> b) #

Finite Int8 # 

Methods

allValues :: [Int8] #

assemble :: Applicative f => (Int8 -> f b) -> f (Int8 -> b) #

Finite Int16 # 

Methods

allValues :: [Int16] #

assemble :: Applicative f => (Int16 -> f b) -> f (Int16 -> b) #

Finite Int32 # 

Methods

allValues :: [Int32] #

assemble :: Applicative f => (Int32 -> f b) -> f (Int32 -> b) #

Finite Int64 # 

Methods

allValues :: [Int64] #

assemble :: Applicative f => (Int64 -> f b) -> f (Int64 -> b) #

Finite Word8 # 

Methods

allValues :: [Word8] #

assemble :: Applicative f => (Word8 -> f b) -> f (Word8 -> b) #

Finite Word16 # 

Methods

allValues :: [Word16] #

assemble :: Applicative f => (Word16 -> f b) -> f (Word16 -> b) #

Finite Word32 # 

Methods

allValues :: [Word32] #

assemble :: Applicative f => (Word32 -> f b) -> f (Word32 -> b) #

Finite Word64 # 

Methods

allValues :: [Word64] #

assemble :: Applicative f => (Word64 -> f b) -> f (Word64 -> b) #

Finite () # 

Methods

allValues :: [()] #

assemble :: Applicative f => (() -> f b) -> f (() -> b) #

Finite None # 

Methods

allValues :: [None] #

assemble :: Applicative f => (None -> f b) -> f (None -> b) #

Finite a => Finite (Maybe a) # 

Methods

allValues :: [Maybe a] #

assemble :: Applicative f => (Maybe a -> f b) -> f (Maybe a -> b) #

(Finite a, Finite b) => Finite (a -> b) # 

Methods

allValues :: [a -> b] #

assemble :: Applicative f => ((a -> b) -> f b) -> f ((a -> b) -> b) #

(Finite a, Finite b) => Finite (Either a b) # 

Methods

allValues :: [Either a b] #

assemble :: Applicative f => (Either a b -> f b) -> f (Either a b -> b) #

(Finite a, Finite b) => Finite (a, b) # 

Methods

allValues :: [(a, b)] #

assemble :: Applicative f => ((a, b) -> f b) -> f ((a, b) -> b) #

finiteSearch :: Finite a => (a -> Maybe b) -> Maybe b #

Orphan instances

Finite t => Foldable ((->) t) # 

Methods

fold :: Monoid m => (t -> m) -> m #

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

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

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

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

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

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

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

toList :: (t -> a) -> [a] #

null :: (t -> a) -> Bool #

length :: (t -> a) -> Int #

elem :: Eq a => a -> (t -> a) -> Bool #

maximum :: Ord a => (t -> a) -> a #

minimum :: Ord a => (t -> a) -> a #

sum :: Num a => (t -> a) -> a #

product :: Num a => (t -> a) -> a #

Finite a => Traversable ((->) a) # 

Methods

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

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

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

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

(Searchable a, Eq b) => Eq (a -> b) # 

Methods

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

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

(Show a, Finite a, Show b) => Show (a -> b) # 

Methods

showsPrec :: Int -> (a -> b) -> ShowS #

show :: (a -> b) -> String #

showList :: [a -> b] -> ShowS #

(Finite a, AtLeastOneCountable a, InfiniteCountable b) => InfiniteCountable (a -> b) # 

Methods

countNext :: Maybe (a -> b) -> a -> b #

(Finite a, AtLeastOneCountable b) => AtLeastOneCountable (a -> b) # 

Methods

countFirst :: a -> b #

(Finite a, Countable b) => Countable (a -> b) # 

Methods

countPrevious :: (a -> b) -> Maybe (a -> b) #

countMaybeNext :: Maybe (a -> b) -> Maybe (a -> b) #