Safe Haskell | Safe-Infered |
---|
Hoogle.Store.All
- type SPut a = ReaderT SPutS IO a
- type SGet a = ReaderT SGetS IO a
- runSPut :: FilePath -> SPut () -> IO ()
- runSGet :: Typeable a => FilePath -> SGet a -> IO a
- data Once a
- fromOnce :: Once a -> a
- once :: a -> Once a
- getDefer :: Typeable a => SGet a -> SGet a
- putDefer :: SPut () -> SPut ()
- class Store a where
- newtype Defer a = Defer {
- fromDefer :: a
- errorSGet :: String -> SGet 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 ()
- putByte :: Word8 -> SPut ()
- getByte :: SGet Word8
- putWord32 :: Word32 -> SPut ()
- getWord32 :: SGet Word32
Documentation
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.
class Store a where
Methods
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
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
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 ()