Apecs.Stores

Documentation

data Map c

A map from Data.Intmap.Strict. O(log(n)) for most operations. Yields safe runtime representations of type Maybe c.

Instances

Store (Map c)

Associated Types

type Stores (Map c) :: *

type SafeRW (Map c) :: *

Methods

explGet :: Map c -> Int -> IO (SafeRW (Map c))

explSet :: Map c -> Int -> Stores (Map c) -> IO ()

explDestroy :: Map c -> Int -> IO ()

explExists :: Map c -> Int -> IO Bool

explMembers :: Map c -> IO (Vector Int)

explGetUnsafe :: Map c -> Int -> IO (Stores (Map c))

explSetMaybe :: Map c -> Int -> SafeRW (Map c) -> IO ()

initStore :: IO (Map c)

explReset :: Map c -> IO ()

explImapM_ :: MonadIO m => Map c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Map c -> (Int -> m a) -> m [a]

explModify :: Map c -> Int -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmap :: Map c -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmapM_ :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m ()

explCmapM :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m [a]

explCimapM :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m [a]

Cachable (Map s)

type Stores (Map c)

type Stores (Map c) = c

type SafeRW (Map c)

type SafeRW (Map c) = Maybe c

data Set c

A store that keeps membership, but holds no values. Produces flag runtime values.

Instances

Flag c => Store (Set c)

Associated Types

type Stores (Set c) :: *

type SafeRW (Set c) :: *

Methods

explGet :: Set c -> Int -> IO (SafeRW (Set c))

explSet :: Set c -> Int -> Stores (Set c) -> IO ()

explDestroy :: Set c -> Int -> IO ()

explExists :: Set c -> Int -> IO Bool

explMembers :: Set c -> IO (Vector Int)

explGetUnsafe :: Set c -> Int -> IO (Stores (Set c))

explSetMaybe :: Set c -> Int -> SafeRW (Set c) -> IO ()

initStore :: IO (Set c)

explReset :: Set c -> IO ()

explImapM_ :: MonadIO m => Set c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Set c -> (Int -> m a) -> m [a]

explModify :: Set c -> Int -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmap :: Set c -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmapM_ :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m ()

explCmapM :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m [a]

explCimapM :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m [a]

type Stores (Set c)

type Stores (Set c) = c

type SafeRW (Set c)

type SafeRW (Set c) = Bool

class Flag c where

Class for flags, used by Set to yield runtime representations.

Minimal complete definition

flag

Methods

flag :: c

data Cache n s

A cache around another store. The wrapped store must produce safe representations using Maybe. Note that iterating over a cache is linear in its size, so large, sparsely populated caches will actually decrease performance.

Instances

(KnownNat n, Cachable s) => Store (Cache n s)

Associated Types

type Stores (Cache n s) :: *

type SafeRW (Cache n s) :: *

Methods

explGet :: Cache n s -> Int -> IO (SafeRW (Cache n s))

explSet :: Cache n s -> Int -> Stores (Cache n s) -> IO ()

explDestroy :: Cache n s -> Int -> IO ()

explExists :: Cache n s -> Int -> IO Bool

explMembers :: Cache n s -> IO (Vector Int)

explGetUnsafe :: Cache n s -> Int -> IO (Stores (Cache n s))

explSetMaybe :: Cache n s -> Int -> SafeRW (Cache n s) -> IO ()

initStore :: IO (Cache n s)

explReset :: Cache n s -> IO ()

explImapM_ :: MonadIO m => Cache n s -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Cache n s -> (Int -> m a) -> m [a]

explModify :: Cache n s -> Int -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmap :: Cache n s -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmapM_ :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m ()

explCimapM_ :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m ()

explCmapM :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m [a]

explCimapM :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m [a]

(KnownNat n, Cachable s) => Cachable (Cache n s)

type Stores (Cache n s)

type Stores (Cache n s) = Stores s

type SafeRW (Cache n s)

type SafeRW (Cache n s) = SafeRW s

data Unique c

A Unique contains exactly one component belonging to some entity. Writing to it overwrites both the previous component and its owner.

Instances

Store (Unique c)

Associated Types

type Stores (Unique c) :: *

type SafeRW (Unique c) :: *

Methods

explGet :: Unique c -> Int -> IO (SafeRW (Unique c))

explSet :: Unique c -> Int -> Stores (Unique c) -> IO ()

explDestroy :: Unique c -> Int -> IO ()

explExists :: Unique c -> Int -> IO Bool

explMembers :: Unique c -> IO (Vector Int)

explGetUnsafe :: Unique c -> Int -> IO (Stores (Unique c))

explSetMaybe :: Unique c -> Int -> SafeRW (Unique c) -> IO ()

initStore :: IO (Unique c)

explReset :: Unique c -> IO ()

explImapM_ :: MonadIO m => Unique c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Unique c -> (Int -> m a) -> m [a]

explModify :: Unique c -> Int -> (Stores (Unique c) -> Stores (Unique c)) -> IO ()

explCmap :: Unique c -> (Stores (Unique c) -> Stores (Unique c)) -> IO ()

explCmapM_ :: MonadIO m => Unique c -> (Stores (Unique c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Unique c -> ((Int, Stores (Unique c)) -> m a) -> m ()

explCmapM :: MonadIO m => Unique c -> (Stores (Unique c) -> m a) -> m [a]

explCimapM :: MonadIO m => Unique c -> ((Int, Stores (Unique c)) -> m a) -> m [a]

type Stores (Unique c)

type Stores (Unique c) = c

type SafeRW (Unique c)

type SafeRW (Unique c) = Maybe c

data Global c

Global value. Initialized with mempty

Instances

Monoid c => GlobalStore (Global c)

Monoid c => Store (Global c)

Associated Types

type Stores (Global c) :: *

type SafeRW (Global c) :: *

Methods

explGet :: Global c -> Int -> IO (SafeRW (Global c))

explSet :: Global c -> Int -> Stores (Global c) -> IO ()

explDestroy :: Global c -> Int -> IO ()

explExists :: Global c -> Int -> IO Bool

explMembers :: Global c -> IO (Vector Int)

explGetUnsafe :: Global c -> Int -> IO (Stores (Global c))

explSetMaybe :: Global c -> Int -> SafeRW (Global c) -> IO ()

initStore :: IO (Global c)

explReset :: Global c -> IO ()

explImapM_ :: MonadIO m => Global c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Global c -> (Int -> m a) -> m [a]

explModify :: Global c -> Int -> (Stores (Global c) -> Stores (Global c)) -> IO ()

explCmap :: Global c -> (Stores (Global c) -> Stores (Global c)) -> IO ()

explCmapM_ :: MonadIO m => Global c -> (Stores (Global c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Global c -> ((Int, Stores (Global c)) -> m a) -> m ()

explCmapM :: MonadIO m => Global c -> (Stores (Global c) -> m a) -> m [a]

explCimapM :: MonadIO m => Global c -> ((Int, Stores (Global c)) -> m a) -> m [a]

type Stores (Global c)

type Stores (Global c) = c

type SafeRW (Global c)

type SafeRW (Global c) = c

class (Store s, SafeRW s ~ Maybe (Stores s)) => Cachable s

Instances

Cachable (Map s)

(KnownNat n, Cachable s) => Cachable (Cache n s)