{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}

module Aztecs.Internal
  ( AztecsT (..),
    runAztecsT,
    runAztecsT_,
  )
where

import Aztecs.ECS.Bundle
import Aztecs.ECS.Bundle.Class
import Aztecs.ECS.Class
import Aztecs.ECS.Commands
import Aztecs.ECS.Component (Component (ComponentStorage, componentHooks), Hooks (..))
import Aztecs.ECS.HSet (AdjustM, HSet (..), Lookup (..))
import qualified Aztecs.ECS.HSet as HS
import Aztecs.ECS.Query
import Aztecs.ECS.Query.Internal
import Aztecs.ECS.R
import qualified Aztecs.ECS.Scheduler as Scheduler
import Aztecs.ECS.W
import qualified Aztecs.Entity as E
import Aztecs.Storage
import qualified Aztecs.Storage as S
import Aztecs.World (SparseStorage, WorldComponents)
import qualified Aztecs.World as W
import qualified Aztecs.World.Entities as E
import Control.Monad.Primitive
import Control.Monad.State.Strict
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Map.Strict as Map
import Data.Maybe
import Data.Proxy
import qualified Data.Set as Set
import Data.Typeable
import Prelude hiding (Read, lookup)

newtype AztecsT cs m a = AztecsT {forall (cs :: [*]) (m :: * -> *) a.
AztecsT cs m a -> StateT (World m cs) m a
unAztecsT :: StateT (W.World m cs) m a}
  deriving ((forall a b. (a -> b) -> AztecsT cs m a -> AztecsT cs m b)
-> (forall a b. a -> AztecsT cs m b -> AztecsT cs m a)
-> Functor (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *) a b.
Functor m =>
a -> AztecsT cs m b -> AztecsT cs m a
forall (cs :: [*]) (m :: * -> *) a b.
Functor m =>
(a -> b) -> AztecsT cs m a -> AztecsT cs m b
forall a b. a -> AztecsT cs m b -> AztecsT cs m a
forall a b. (a -> b) -> AztecsT cs m a -> AztecsT cs m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (cs :: [*]) (m :: * -> *) a b.
Functor m =>
(a -> b) -> AztecsT cs m a -> AztecsT cs m b
fmap :: forall a b. (a -> b) -> AztecsT cs m a -> AztecsT cs m b
$c<$ :: forall (cs :: [*]) (m :: * -> *) a b.
Functor m =>
a -> AztecsT cs m b -> AztecsT cs m a
<$ :: forall a b. a -> AztecsT cs m b -> AztecsT cs m a
Functor, Functor (AztecsT cs m)
Functor (AztecsT cs m) =>
(forall a. a -> AztecsT cs m a)
-> (forall a b.
    AztecsT cs m (a -> b) -> AztecsT cs m a -> AztecsT cs m b)
-> (forall a b c.
    (a -> b -> c)
    -> AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m c)
-> (forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b)
-> (forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m a)
-> Applicative (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *). Monad m => Functor (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *) a. Monad m => a -> AztecsT cs m a
forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m a
forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m (a -> b) -> AztecsT cs m a -> AztecsT cs m b
forall (cs :: [*]) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m c
forall a. a -> AztecsT cs m a
forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m a
forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
forall a b.
AztecsT cs m (a -> b) -> AztecsT cs m a -> AztecsT cs m b
forall a b c.
(a -> b -> c) -> AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall (cs :: [*]) (m :: * -> *) a. Monad m => a -> AztecsT cs m a
pure :: forall a. a -> AztecsT cs m a
$c<*> :: forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m (a -> b) -> AztecsT cs m a -> AztecsT cs m b
<*> :: forall a b.
AztecsT cs m (a -> b) -> AztecsT cs m a -> AztecsT cs m b
$cliftA2 :: forall (cs :: [*]) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m c
liftA2 :: forall a b c.
(a -> b -> c) -> AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m c
$c*> :: forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
*> :: forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
$c<* :: forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m a
<* :: forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m a
Applicative, Applicative (AztecsT cs m)
Applicative (AztecsT cs m) =>
(forall a b.
 AztecsT cs m a -> (a -> AztecsT cs m b) -> AztecsT cs m b)
-> (forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b)
-> (forall a. a -> AztecsT cs m a)
-> Monad (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *).
Monad m =>
Applicative (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *) a. Monad m => a -> AztecsT cs m a
forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> (a -> AztecsT cs m b) -> AztecsT cs m b
forall a. a -> AztecsT cs m a
forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
forall a b.
AztecsT cs m a -> (a -> AztecsT cs m b) -> AztecsT cs m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> (a -> AztecsT cs m b) -> AztecsT cs m b
>>= :: forall a b.
AztecsT cs m a -> (a -> AztecsT cs m b) -> AztecsT cs m b
$c>> :: forall (cs :: [*]) (m :: * -> *) a b.
Monad m =>
AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
>> :: forall a b. AztecsT cs m a -> AztecsT cs m b -> AztecsT cs m b
$creturn :: forall (cs :: [*]) (m :: * -> *) a. Monad m => a -> AztecsT cs m a
return :: forall a. a -> AztecsT cs m a
Monad, Monad (AztecsT cs m)
Monad (AztecsT cs m) =>
(forall a. IO a -> AztecsT cs m a) -> MonadIO (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *). MonadIO m => Monad (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *) a.
MonadIO m =>
IO a -> AztecsT cs m a
forall a. IO a -> AztecsT cs m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall (cs :: [*]) (m :: * -> *) a.
MonadIO m =>
IO a -> AztecsT cs m a
liftIO :: forall a. IO a -> AztecsT cs m a
MonadIO, Monad (AztecsT cs m)
Monad (AztecsT cs m) =>
(forall a.
 (State# (PrimState (AztecsT cs m))
  -> (# State# (PrimState (AztecsT cs m)), a #))
 -> AztecsT cs m a)
-> PrimMonad (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *).
PrimMonad m =>
Monad (AztecsT cs m)
forall (cs :: [*]) (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState (AztecsT cs m))
 -> (# State# (PrimState (AztecsT cs m)), a #))
-> AztecsT cs m a
forall a.
(State# (PrimState (AztecsT cs m))
 -> (# State# (PrimState (AztecsT cs m)), a #))
-> AztecsT cs m a
forall (m :: * -> *).
Monad m =>
(forall a.
 (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
-> PrimMonad m
$cprimitive :: forall (cs :: [*]) (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState (AztecsT cs m))
 -> (# State# (PrimState (AztecsT cs m)), a #))
-> AztecsT cs m a
primitive :: forall a.
(State# (PrimState (AztecsT cs m))
 -> (# State# (PrimState (AztecsT cs m)), a #))
-> AztecsT cs m a
PrimMonad)

instance MonadTrans (AztecsT cs) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> AztecsT cs m a
lift = StateT (World m cs) m a -> AztecsT cs m a
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m a -> AztecsT cs m a)
-> (m a -> StateT (World m cs) m a) -> m a -> AztecsT cs m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
  {-# INLINE lift #-}

instance (PrimMonad m) => ECS (AztecsT cs m) where
  type Entity (AztecsT cs m) = E.Entity
  type Task (AztecsT cs m) = (Commands (AztecsT cs) m)

  spawn :: Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
-> AztecsT cs m (Entity (AztecsT cs m))
spawn Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
b = do
    World m cs
w <- StateT (World m cs) m (World m cs) -> AztecsT cs m (World m cs)
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    let (Entity
e, Entities
counter) = Entities -> (Entity, Entities)
E.mkEntityWithCounter (World m cs -> Entities
forall (m :: * -> *) (cs :: [*]). World m cs -> Entities
W.worldEntities World m cs
w)
    StateT (World m cs) m () -> AztecsT cs m ()
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m () -> AztecsT cs m ())
-> StateT (World m cs) m () -> AztecsT cs m ()
forall a b. (a -> b) -> a -> b
$ World m cs -> StateT (World m cs) m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put World m cs
w {W.worldEntities = counter}
    Bundle Entity (AztecsT cs m) -> Entity -> AztecsT cs m ()
forall e (m :: * -> *). Bundle e m -> e -> m ()
runBundle Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
Bundle Entity (AztecsT cs m)
b Entity
e
    Entity -> AztecsT cs m Entity
forall a. a -> AztecsT cs m a
forall (m :: * -> *) a. Monad m => a -> m a
return Entity
e
  {-# INLINE spawn #-}
  insert :: Entity (AztecsT cs m)
-> Bundle (Entity (AztecsT cs m)) (AztecsT cs m) -> AztecsT cs m ()
insert Entity (AztecsT cs m)
e Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
b = Bundle Entity (AztecsT cs m) -> Entity -> AztecsT cs m ()
forall e (m :: * -> *). Bundle e m -> e -> m ()
runBundle Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
Bundle Entity (AztecsT cs m)
b Entity (AztecsT cs m)
Entity
e
  {-# INLINE insert #-}
  remove :: Entity (AztecsT cs m) -> AztecsT cs m ()
remove Entity (AztecsT cs m)
e = StateT (World m cs) m () -> AztecsT cs m ()
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m () -> AztecsT cs m ())
-> StateT (World m cs) m () -> AztecsT cs m ()
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    World m cs
w' <- m (World m cs) -> StateT (World m cs) m (World m cs)
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (World m cs) -> StateT (World m cs) m (World m cs))
-> m (World m cs) -> StateT (World m cs) m (World m cs)
forall a b. (a -> b) -> a -> b
$ Entity -> World m cs -> m (World m cs)
forall (m :: * -> *) (cs :: [*]).
Monad m =>
Entity -> World m cs -> m (World m cs)
W.remove Entity (AztecsT cs m)
Entity
e World m cs
w
    World m cs -> StateT (World m cs) m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put World m cs
w'
  {-# INLINE remove #-}
  task :: forall a. Task (AztecsT cs m) a -> AztecsT cs m a
task = Task (AztecsT cs m) a -> AztecsT cs m a
Commands (AztecsT cs) m a -> AztecsT cs m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad (t m), Monad m) =>
Commands t m a -> t m a
runCommands
  {-# INLINE task #-}

instance
  ( PrimMonad m,
    Typeable c,
    Component (AztecsT cs m) c,
    AdjustM m (SparseStorage m c) (WorldComponents m cs)
  ) =>
  Bundleable c (AztecsT cs m)
  where
  bundle :: c -> Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
bundle c
c = (Entity (AztecsT cs m) -> AztecsT cs m ())
-> Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
forall e (m :: * -> *). (e -> m ()) -> Bundle e m
Bundle ((Entity (AztecsT cs m) -> AztecsT cs m ())
 -> Bundle (Entity (AztecsT cs m)) (AztecsT cs m))
-> (Entity (AztecsT cs m) -> AztecsT cs m ())
-> Bundle (Entity (AztecsT cs m)) (AztecsT cs m)
forall a b. (a -> b) -> a -> b
$ \Entity (AztecsT cs m)
entity -> do
    World m cs
w <- StateT (World m cs) m (World m cs) -> AztecsT cs m (World m cs)
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    let entityIdx :: Key
entityIdx = Word32 -> Key
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Key) -> Word32 -> Key
forall a b. (a -> b) -> a -> b
$ Entity -> Word32
E.entityIndex Entity (AztecsT cs m)
Entity
entity
        componentType :: TypeRep
componentType = c -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf c
c
        go :: SparseStorage m c -> m (SparseStorage m c)
go = Entity -> c -> SparseStorage m c -> m (SparseStorage m c)
forall a.
Entity
-> a
-> MSparseSet (PrimState m) Word32 a
-> m (MSparseSet (PrimState m) Word32 a)
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
Entity -> a -> s a -> m (s a)
S.insertStorage Entity (AztecsT cs m)
Entity
entity c
c
        hooks :: Hooks (AztecsT cs m)
hooks = Proxy c -> Hooks (AztecsT cs m)
forall (proxy :: * -> *). proxy c -> Hooks (AztecsT cs m)
forall (m :: * -> *) a (proxy :: * -> *).
Component m a =>
proxy a -> Hooks m
componentHooks (Proxy c
forall {k} (t :: k). Proxy t
Proxy :: Proxy c)
    HSet (WorldComponents m cs)
cs <- m (HSet (WorldComponents m cs))
-> AztecsT cs m (HSet (WorldComponents m cs))
forall (m :: * -> *) a. Monad m => m a -> AztecsT cs m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (HSet (WorldComponents m cs))
 -> AztecsT cs m (HSet (WorldComponents m cs)))
-> (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
-> HSet (WorldComponents m cs)
-> AztecsT cs m (HSet (WorldComponents m cs))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) t (ts :: [*]).
AdjustM m t ts =>
(t -> m t) -> HSet ts -> m (HSet ts)
HS.adjustM @_ @(SparseStorage m c) SparseStorage m c -> m (SparseStorage m c)
go (HSet (WorldComponents m cs)
 -> AztecsT cs m (HSet (WorldComponents m cs)))
-> HSet (WorldComponents m cs)
-> AztecsT cs m (HSet (WorldComponents m cs))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
    let entityComponents' :: IntMap
  (Map
     TypeRep
     (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs))))
entityComponents' =
          (Map
   TypeRep
   (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
 -> Map
      TypeRep
      (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
 -> Map
      TypeRep
      (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs))))
-> Key
-> Map
     TypeRep
     (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
-> IntMap
     (Map
        TypeRep
        (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs))))
-> IntMap
     (Map
        TypeRep
        (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs))))
forall a. (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
IntMap.insertWith
            Map
  TypeRep
  (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
-> Map
     TypeRep
     (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
-> Map
     TypeRep
     (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union
            Key
entityIdx
            (TypeRep
-> (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
-> Map
     TypeRep
     (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs)))
forall k a. k -> a -> Map k a
Map.singleton TypeRep
componentType (forall (m :: * -> *) c (cs :: [*]).
(AdjustM m (SparseStorage m c) cs, PrimMonad m) =>
Entity -> HSet cs -> m (HSet cs)
W.removeComponent' @m @c Entity (AztecsT cs m)
Entity
entity))
            (World m cs
-> IntMap
     (Map
        TypeRep
        (HSet (WorldComponents m cs) -> m (HSet (WorldComponents m cs))))
forall (m :: * -> *) (cs :: [*]).
World m cs -> WorldEntityComponents m cs
W.worldEntityComponents World m cs
w)
    StateT (World m cs) m () -> AztecsT cs m ()
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m () -> AztecsT cs m ())
-> StateT (World m cs) m () -> AztecsT cs m ()
forall a b. (a -> b) -> a -> b
$ World m cs -> StateT (World m cs) m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put World m cs
w {W.worldComponents = cs, W.worldEntityComponents = entityComponents'}
    Hooks (AztecsT cs m) -> Entity (AztecsT cs m) -> AztecsT cs m ()
forall (m :: * -> *). Hooks m -> Entity m -> m ()
onInsert Hooks (AztecsT cs m)
hooks Entity (AztecsT cs m)
entity
  {-# INLINE bundle #-}

runAztecsT :: (Monad m) => AztecsT cs m a -> W.World m cs -> m (a, W.World m cs)
runAztecsT :: forall (m :: * -> *) (cs :: [*]) a.
Monad m =>
AztecsT cs m a -> World m cs -> m (a, World m cs)
runAztecsT (AztecsT StateT (World m cs) m a
m) = StateT (World m cs) m a -> World m cs -> m (a, World m cs)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT (World m cs) m a
m
{-# INLINE runAztecsT #-}

runAztecsT_ :: (Monad m) => AztecsT cs m a -> W.World m cs -> m a
runAztecsT_ :: forall (m :: * -> *) (cs :: [*]) a.
Monad m =>
AztecsT cs m a -> World m cs -> m a
runAztecsT_ (AztecsT StateT (World m cs) m a
m) = StateT (World m cs) m a -> World m cs -> m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT (World m cs) m a
m
{-# INLINE runAztecsT_ #-}

instance (PrimMonad m) => Queryable (AztecsT cs m) E.Entity where
  type QueryableAccess E.Entity = '[]
  queryable :: AztecsT cs m (Query Entity)
queryable = StateT (World m cs) m (Query Entity) -> AztecsT cs m (Query Entity)
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m (Query Entity)
 -> AztecsT cs m (Query Entity))
-> StateT (World m cs) m (Query Entity)
-> AztecsT cs m (Query Entity)
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    Query Entity -> StateT (World m cs) m (Query Entity)
forall a. a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query Entity -> StateT (World m cs) m (Query Entity))
-> (Entities -> Query Entity)
-> Entities
-> StateT (World m cs) m (Query Entity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe Entity] -> Query Entity
forall a. [Maybe a] -> Query a
Query ([Maybe Entity] -> Query Entity)
-> (Entities -> [Maybe Entity]) -> Entities -> Query Entity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Entity -> Maybe Entity) -> [Entity] -> [Maybe Entity]
forall a b. (a -> b) -> [a] -> [b]
map Entity -> Maybe Entity
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Entity] -> [Maybe Entity])
-> (Entities -> [Entity]) -> Entities -> [Maybe Entity]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Entities -> [Entity]
E.entities (Entities -> StateT (World m cs) m (Query Entity))
-> Entities -> StateT (World m cs) m (Query Entity)
forall a b. (a -> b) -> a -> b
$ World m cs -> Entities
forall (m :: * -> *) (cs :: [*]). World m cs -> Entities
W.worldEntities World m cs
w
  {-# INLINE queryable #-}

instance
  ( PrimMonad m,
    Lookup (ComponentStorage m a a) (WorldComponents m cs),
    Storage m (ComponentStorage m a)
  ) =>
  Queryable (AztecsT cs m) (With a)
  where
  type QueryableAccess (With a) = '[With a]
  queryable :: AztecsT cs m (Query (With a))
queryable = StateT (World m cs) m (Query (With a))
-> AztecsT cs m (Query (With a))
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m (Query (With a))
 -> AztecsT cs m (Query (With a)))
-> StateT (World m cs) m (Query (With a))
-> AztecsT cs m (Query (With a))
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    Query (R a)
withComponent <-
      m (Query (R a)) -> StateT (World m cs) m (Query (R a))
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
        (m (Query (R a)) -> StateT (World m cs) m (Query (R a)))
-> (HSet (WorldComponents m cs) -> m (Query (R a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (R a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentStorage m a a -> m (Query (R a))
forall a. ComponentStorage m a a -> m (Query (R a))
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
s a -> m (Query (R a))
S.queryStorageR
        (ComponentStorage m a a -> m (Query (R a)))
-> (HSet (WorldComponents m cs) -> ComponentStorage m a a)
-> HSet (WorldComponents m cs)
-> m (Query (R a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (ts :: [*]). Lookup t ts => HSet ts -> t
HS.lookup @(ComponentStorage m a a)
        (HSet (WorldComponents m cs)
 -> StateT (World m cs) m (Query (R a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (R a))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
    Query (With a) -> StateT (World m cs) m (Query (With a))
forall a. a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query (With a) -> StateT (World m cs) m (Query (With a)))
-> (Query (R a) -> Query (With a))
-> Query (R a)
-> StateT (World m cs) m (Query (With a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (R a -> With a) -> Query (R a) -> Query (With a)
forall a b. (a -> b) -> Query a -> Query b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (With a -> R a -> With a
forall a b. a -> b -> a
const With a
forall a. With a
With) (Query (R a) -> StateT (World m cs) m (Query (With a)))
-> Query (R a) -> StateT (World m cs) m (Query (With a))
forall a b. (a -> b) -> a -> b
$ Query (R a)
withComponent
  {-# INLINE queryable #-}

instance
  ( PrimMonad m,
    Lookup (ComponentStorage m a a) (WorldComponents m cs),
    Storage m (ComponentStorage m a)
  ) =>
  Queryable (AztecsT cs m) (Without a)
  where
  type QueryableAccess (Without a) = '[Without a]
  queryable :: AztecsT cs m (Query (Without a))
queryable = StateT (World m cs) m (Query (Without a))
-> AztecsT cs m (Query (Without a))
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m (Query (Without a))
 -> AztecsT cs m (Query (Without a)))
-> StateT (World m cs) m (Query (Without a))
-> AztecsT cs m (Query (Without a))
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    (Query [Maybe (R a)]
cs) <-
      m (Query (R a)) -> StateT (World m cs) m (Query (R a))
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
        (m (Query (R a)) -> StateT (World m cs) m (Query (R a)))
-> (HSet (WorldComponents m cs) -> m (Query (R a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (R a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentStorage m a a -> m (Query (R a))
forall a. ComponentStorage m a a -> m (Query (R a))
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
s a -> m (Query (R a))
S.queryStorageR
        (ComponentStorage m a a -> m (Query (R a)))
-> (HSet (WorldComponents m cs) -> ComponentStorage m a a)
-> HSet (WorldComponents m cs)
-> m (Query (R a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (ts :: [*]). Lookup t ts => HSet ts -> t
HS.lookup @(ComponentStorage m a a)
        (HSet (WorldComponents m cs)
 -> StateT (World m cs) m (Query (R a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (R a))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
    let go :: Maybe a -> Maybe (Without a)
go Maybe a
m = case Maybe a
m of
          Just a
v -> Maybe (Without a)
forall a. Maybe a
Nothing
          Maybe a
Nothing -> Without a -> Maybe (Without a)
forall a. a -> Maybe a
Just Without a
forall a. Without a
Without
    Query (Without a) -> StateT (World m cs) m (Query (Without a))
forall a. a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query (Without a) -> StateT (World m cs) m (Query (Without a)))
-> ([Maybe (Without a)] -> Query (Without a))
-> [Maybe (Without a)]
-> StateT (World m cs) m (Query (Without a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe (Without a)] -> Query (Without a)
forall a. [Maybe a] -> Query a
Query ([Maybe (Without a)] -> StateT (World m cs) m (Query (Without a)))
-> [Maybe (Without a)] -> StateT (World m cs) m (Query (Without a))
forall a b. (a -> b) -> a -> b
$ (Maybe (R a) -> Maybe (Without a))
-> [Maybe (R a)] -> [Maybe (Without a)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (R a) -> Maybe (Without a)
forall {a} {a}. Maybe a -> Maybe (Without a)
go [Maybe (R a)]
cs
  {-# INLINE queryable #-}

instance
  ( PrimMonad m,
    Lookup (ComponentStorage m a a) (WorldComponents m cs),
    Storage (AztecsT cs m) (ComponentStorage m a)
  ) =>
  Queryable (AztecsT cs m) (R a)
  where
  type QueryableAccess (R a) = '[Read a]
  queryable :: AztecsT cs m (Query (R a))
queryable = do
    World m cs
w <- StateT (World m cs) m (World m cs) -> AztecsT cs m (World m cs)
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    ComponentStorage m a a -> AztecsT cs m (Query (R a))
forall a. ComponentStorage m a a -> AztecsT cs m (Query (R a))
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
s a -> m (Query (R a))
S.queryStorageR (ComponentStorage m a a -> AztecsT cs m (Query (R a)))
-> (HSet (WorldComponents m cs) -> ComponentStorage m a a)
-> HSet (WorldComponents m cs)
-> AztecsT cs m (Query (R a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (ts :: [*]). Lookup t ts => HSet ts -> t
HS.lookup @(ComponentStorage m a a) (HSet (WorldComponents m cs) -> AztecsT cs m (Query (R a)))
-> HSet (WorldComponents m cs) -> AztecsT cs m (Query (R a))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
  {-# INLINE queryable #-}

instance
  ( PrimMonad m,
    PrimState m ~ s,
    Lookup (ComponentStorage m a a) (WorldComponents m cs),
    Storage m (ComponentStorage m a)
  ) =>
  Queryable (AztecsT cs m) (W (Commands (AztecsT cs) m) a)
  where
  type QueryableAccess (W (Commands (AztecsT cs) m) a) = '[Write a]
  queryable :: AztecsT cs m (Query (W (Commands (AztecsT cs) m) a))
queryable = StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
-> AztecsT cs m (Query (W (Commands (AztecsT cs) m) a))
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
 -> AztecsT cs m (Query (W (Commands (AztecsT cs) m) a)))
-> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
-> AztecsT cs m (Query (W (Commands (AztecsT cs) m) a))
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    Query [Maybe (W m a)]
results <-
      m (Query (W m a)) -> StateT (World m cs) m (Query (W m a))
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
        (m (Query (W m a)) -> StateT (World m cs) m (Query (W m a)))
-> (HSet (WorldComponents m cs) -> m (Query (W m a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (W m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentStorage m a a -> m (Query (W m a))
forall a. ComponentStorage m a a -> m (Query (W m a))
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
s a -> m (Query (W m a))
S.queryStorageW
        (ComponentStorage m a a -> m (Query (W m a)))
-> (HSet (WorldComponents m cs) -> ComponentStorage m a a)
-> HSet (WorldComponents m cs)
-> m (Query (W m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (ts :: [*]). Lookup t ts => HSet ts -> t
HS.lookup @(ComponentStorage m a a)
        (HSet (WorldComponents m cs)
 -> StateT (World m cs) m (Query (W m a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (W m a))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
    let liftToCommands :: m a -> Commands t m a
liftToCommands m a
m = m (a, t m ()) -> Commands t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
m (a, t m ()) -> Commands t m a
Commands (m (a, t m ()) -> Commands t m a)
-> m (a, t m ()) -> Commands t m a
forall a b. (a -> b) -> a -> b
$ (,() -> t m ()
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) (a -> (a, t m ())) -> m a -> m (a, t m ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
m
        go :: W m c -> W (Commands t m) c
go (W m c
r c -> m ()
wf (c -> c) -> m ()
mf) =
          Commands t m c
-> (c -> Commands t m ())
-> ((c -> c) -> Commands t m ())
-> W (Commands t m) c
forall (m :: * -> *) c.
m c -> (c -> m ()) -> ((c -> c) -> m ()) -> W m c
W
            (m c -> Commands t m c
forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(Applicative (t m), Functor m) =>
m a -> Commands t m a
liftToCommands m c
r)
            (m () -> Commands t m ()
forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(Applicative (t m), Functor m) =>
m a -> Commands t m a
liftToCommands (m () -> Commands t m ()) -> (c -> m ()) -> c -> Commands t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> m ()
wf)
            (m () -> Commands t m ()
forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(Applicative (t m), Functor m) =>
m a -> Commands t m a
liftToCommands (m () -> Commands t m ())
-> ((c -> c) -> m ()) -> (c -> c) -> Commands t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
mf)
    Query (W (Commands (AztecsT cs) m) a)
-> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
forall a. a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query (W (Commands (AztecsT cs) m) a)
 -> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a)))
-> ([Maybe (W (Commands (AztecsT cs) m) a)]
    -> Query (W (Commands (AztecsT cs) m) a))
-> [Maybe (W (Commands (AztecsT cs) m) a)]
-> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe (W (Commands (AztecsT cs) m) a)]
-> Query (W (Commands (AztecsT cs) m) a)
forall a. [Maybe a] -> Query a
Query ([Maybe (W (Commands (AztecsT cs) m) a)]
 -> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a)))
-> [Maybe (W (Commands (AztecsT cs) m) a)]
-> StateT (World m cs) m (Query (W (Commands (AztecsT cs) m) a))
forall a b. (a -> b) -> a -> b
$ (Maybe (W m a) -> Maybe (W (Commands (AztecsT cs) m) a))
-> [Maybe (W m a)] -> [Maybe (W (Commands (AztecsT cs) m) a)]
forall a b. (a -> b) -> [a] -> [b]
map ((W m a -> W (Commands (AztecsT cs) m) a)
-> Maybe (W m a) -> Maybe (W (Commands (AztecsT cs) m) a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap W m a -> W (Commands (AztecsT cs) m) a
forall {t :: (* -> *) -> * -> *} {m :: * -> *} {c}.
(Applicative (t m), Functor m) =>
W m c -> W (Commands t m) c
go) [Maybe (W m a)]
results
  {-# INLINE queryable #-}

-- Additional instance for direct AztecsT usage in scheduler

instance
  ( PrimMonad m,
    PrimState m ~ s,
    Lookup (ComponentStorage m a a) (WorldComponents m cs),
    Storage m (ComponentStorage m a)
  ) =>
  Queryable (AztecsT cs m) (W (AztecsT cs m) a)
  where
  type QueryableAccess (W (AztecsT cs m) a) = '[Write a]
  queryable :: AztecsT cs m (Query (W (AztecsT cs m) a))
queryable = StateT (World m cs) m (Query (W (AztecsT cs m) a))
-> AztecsT cs m (Query (W (AztecsT cs m) a))
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m (Query (W (AztecsT cs m) a))
 -> AztecsT cs m (Query (W (AztecsT cs m) a)))
-> StateT (World m cs) m (Query (W (AztecsT cs m) a))
-> AztecsT cs m (Query (W (AztecsT cs m) a))
forall a b. (a -> b) -> a -> b
$ do
    World m cs
w <- StateT (World m cs) m (World m cs)
forall s (m :: * -> *). MonadState s m => m s
get
    Query [Maybe (W m a)]
results <-
      m (Query (W m a)) -> StateT (World m cs) m (Query (W m a))
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
        (m (Query (W m a)) -> StateT (World m cs) m (Query (W m a)))
-> (HSet (WorldComponents m cs) -> m (Query (W m a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (W m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentStorage m a a -> m (Query (W m a))
forall a. ComponentStorage m a a -> m (Query (W m a))
forall (m :: * -> *) (s :: * -> *) a.
Storage m s =>
s a -> m (Query (W m a))
S.queryStorageW
        (ComponentStorage m a a -> m (Query (W m a)))
-> (HSet (WorldComponents m cs) -> ComponentStorage m a a)
-> HSet (WorldComponents m cs)
-> m (Query (W m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (ts :: [*]). Lookup t ts => HSet ts -> t
HS.lookup @(ComponentStorage m a a)
        (HSet (WorldComponents m cs)
 -> StateT (World m cs) m (Query (W m a)))
-> HSet (WorldComponents m cs)
-> StateT (World m cs) m (Query (W m a))
forall a b. (a -> b) -> a -> b
$ World m cs -> HSet (WorldComponents m cs)
forall (m :: * -> *) (cs :: [*]).
World m cs -> HSet (WorldComponents m cs)
W.worldComponents World m cs
w
    let liftToAztecs :: W m c -> W (AztecsT cs m) c
liftToAztecs (W m c
r c -> m ()
wf (c -> c) -> m ()
mf) =
          AztecsT cs m c
-> (c -> AztecsT cs m ())
-> ((c -> c) -> AztecsT cs m ())
-> W (AztecsT cs m) c
forall (m :: * -> *) c.
m c -> (c -> m ()) -> ((c -> c) -> m ()) -> W m c
W
            (StateT (World m cs) m c -> AztecsT cs m c
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m c -> AztecsT cs m c)
-> StateT (World m cs) m c -> AztecsT cs m c
forall a b. (a -> b) -> a -> b
$ m c -> StateT (World m cs) m c
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
r)
            (StateT (World m cs) m () -> AztecsT cs m ()
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m () -> AztecsT cs m ())
-> (c -> StateT (World m cs) m ()) -> c -> AztecsT cs m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> StateT (World m cs) m ()
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT (World m cs) m ())
-> (c -> m ()) -> c -> StateT (World m cs) m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> m ()
wf)
            (StateT (World m cs) m () -> AztecsT cs m ()
forall (cs :: [*]) (m :: * -> *) a.
StateT (World m cs) m a -> AztecsT cs m a
AztecsT (StateT (World m cs) m () -> AztecsT cs m ())
-> ((c -> c) -> StateT (World m cs) m ())
-> (c -> c)
-> AztecsT cs m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> StateT (World m cs) m ()
forall (m :: * -> *) a. Monad m => m a -> StateT (World m cs) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT (World m cs) m ())
-> ((c -> c) -> m ()) -> (c -> c) -> StateT (World m cs) m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
mf)
    Query (W (AztecsT cs m) a)
-> StateT (World m cs) m (Query (W (AztecsT cs m) a))
forall a. a -> StateT (World m cs) m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query (W (AztecsT cs m) a)
 -> StateT (World m cs) m (Query (W (AztecsT cs m) a)))
-> ([Maybe (W (AztecsT cs m) a)] -> Query (W (AztecsT cs m) a))
-> [Maybe (W (AztecsT cs m) a)]
-> StateT (World m cs) m (Query (W (AztecsT cs m) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe (W (AztecsT cs m) a)] -> Query (W (AztecsT cs m) a)
forall a. [Maybe a] -> Query a
Query ([Maybe (W (AztecsT cs m) a)]
 -> StateT (World m cs) m (Query (W (AztecsT cs m) a)))
-> [Maybe (W (AztecsT cs m) a)]
-> StateT (World m cs) m (Query (W (AztecsT cs m) a))
forall a b. (a -> b) -> a -> b
$ (Maybe (W m a) -> Maybe (W (AztecsT cs m) a))
-> [Maybe (W m a)] -> [Maybe (W (AztecsT cs m) a)]
forall a b. (a -> b) -> [a] -> [b]
map ((W m a -> W (AztecsT cs m) a)
-> Maybe (W m a) -> Maybe (W (AztecsT cs m) a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap W m a -> W (AztecsT cs m) a
forall {m :: * -> *} {c} {cs :: [*]}.
Monad m =>
W m c -> W (AztecsT cs m) c
liftToAztecs) [Maybe (W m a)]
results
  {-# INLINE queryable #-}