hoogle

Safe HaskellSafe-Infered

Hoogle.Store.All

Synopsis

Documentation

type SPut a = ReaderT SPutS IO a

type SGet a = ReaderT SGetS IO a

runSGet :: Typeable a => FilePath -> SGet a -> IO a

data Once a

All once values are equal with respect to keyOnce If you create it with once it will have the same key. If two are loaded from a file they are equal.

Instances

Typeable1 Once 
Eq a => Eq (Once a) 
Ord a => Ord (Once a) 
Show a => Show (Once a) 
(Typeable a, Store a) => Store (Once a) 

fromOnce :: Once a -> a

once :: a -> Once a

getDefer :: Typeable a => SGet a -> SGet a

class Store a where

Methods

put :: a -> SPut ()

get :: SGet a

getList :: Int -> SGet [a]

putList :: [a] -> SPut ()

size :: a -> Maybe Int

Instances

Store Bool 
Store Char 
Store Int 
Store Int32 
Store Word8 
Store Word32 
Store () 
Store ByteString 
Store TagStr 
Store Docs 
Store Type 
Store TypeSig 
Store Entry 
Store EntryInfo 
Store Items 
Store SuggestItem 
Store Suggest 
Store Alias 
Store Aliases 
Store Instances 
Store Node 
Store Graph 
Store Graphs 
Store TypeSearch 
Store DataBase 
Store Identity 
Store a => Store [a] 
Store a => Store (Maybe a) 
(Typeable a, Store a) => Store (Once a) 
(Typeable a, Store a) => Store (Defer a) 
(Typeable a, Store a) => Store (SubstrSearch a) 
(Store a, Store b) => Store (Either a b) 
(Store a, Store b) => Store (a, b) 
(Ix i, Store i, Store e) => Store (Array i e) 
(Typeable k, Typeable v, Ord k, Store k, Store v) => Store (Map k v) 
(Store a, Store b, Store c) => Store (a, b, c) 

newtype Defer a

Constructors

Defer 

Fields

fromDefer :: a
 

Instances

Eq a => Eq (Defer a) 
Ord a => Ord (Defer a) 
Show a => Show (Defer a) 
(Typeable a, Store a) => Store (Defer a) 

get0 :: Monad m => a -> m a

get1 :: Store t => (t -> b) -> ReaderT SGetS IO b

get2 :: (Store t1, Store t) => (t -> t1 -> b) -> ReaderT SGetS IO b

get3 :: (Store t2, Store t1, Store t) => (t -> t1 -> t2 -> b) -> ReaderT SGetS IO b

get4 :: (Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> b) -> ReaderT SGetS IO b

get5 :: (Store t4, Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> t4 -> b) -> ReaderT SGetS IO b

get6 :: (Store t5, Store t4, Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> t4 -> t5 -> b) -> ReaderT SGetS IO b

get7 :: (Store t6, Store t5, Store t4, Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> b) -> ReaderT SGetS IO b

get8 :: (Store t7, Store t6, Store t5, Store t4, Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t7 -> b) -> ReaderT SGetS IO b

get9 :: (Store t8, Store t7, Store t6, Store t5, Store t4, Store t3, Store t2, Store t1, Store t) => (t -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t7 -> t8 -> b) -> ReaderT SGetS IO b

put0 :: SPut ()

put1 :: Store a => a -> SPut ()

put2 :: (Store a1, Store a) => a -> a1 -> ReaderT SPutS IO ()

put3 :: (Store a2, Store a1, Store a) => a -> a1 -> a2 -> ReaderT SPutS IO ()

put4 :: (Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> ReaderT SPutS IO ()

put5 :: (Store a4, Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> a4 -> ReaderT SPutS IO ()

put6 :: (Store a5, Store a4, Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> ReaderT SPutS IO ()

put7 :: (Store a6, Store a5, Store a4, Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> ReaderT SPutS IO ()

put8 :: (Store a7, Store a6, Store a5, Store a4, Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> ReaderT SPutS IO ()

put9 :: (Store a8, Store a7, Store a6, Store a5, Store a4, Store a3, Store a2, Store a1, Store a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> ReaderT SPutS IO ()