{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}

-- |
-- Module      : Aztecs.ECS.Query.Dynamic
-- Copyright   : (c) Matt Hunzinger, 2025
-- License     : BSD-style (see the LICENSE file in the distribution)
--
-- Maintainer  : matt@hunzinger.me
-- Stability   : provisional
-- Portability : non-portable (GHC extensions)
module Aztecs.ECS.Query.Dynamic
  ( -- * Dynamic queries
    DynamicQuery (..),
    DynamicQueryF (..),

    -- ** Running
    readQueryDyn,
    readQueryFilteredDyn,
    readQuerySingleDyn,
    readQuerySingleMaybeDyn,
    runQueryDyn,
    runQueryFilteredDyn,
    runQuerySingleDyn,
    runQuerySingleMaybeDyn,

    -- * Dynamic query filters
    DynamicQueryFilter (..),
  )
where

import Aztecs.ECS.Access.Internal (Access)
import Aztecs.ECS.Component
import Aztecs.ECS.Query.Dynamic.Class
import Aztecs.ECS.World.Archetype (Archetype)
import qualified Aztecs.ECS.World.Archetype as A
import Aztecs.ECS.World.Archetypes (Node (..))
import qualified Aztecs.ECS.World.Archetypes as AS
import Aztecs.ECS.World.Entities (Entities (..))
import Aztecs.ECS.World.Storage.Dynamic
import Data.Foldable
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Map as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Vector (Vector)
import qualified Data.Vector as V
import GHC.Stack

-- | Dynamic query for components by ID.
newtype DynamicQuery m a
  = DynamicQuery
  { -- | Run a dynamic query.
    --
    -- @since 0.10
    forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery :: Archetype m -> m (Vector a, Archetype m, Access m ())
  }
  deriving ((forall a b. (a -> b) -> DynamicQuery m a -> DynamicQuery m b)
-> (forall a b. a -> DynamicQuery m b -> DynamicQuery m a)
-> Functor (DynamicQuery m)
forall a b. a -> DynamicQuery m b -> DynamicQuery m a
forall a b. (a -> b) -> DynamicQuery m a -> DynamicQuery m b
forall (m :: * -> *) a b.
Functor m =>
a -> DynamicQuery m b -> DynamicQuery m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> DynamicQuery m a -> DynamicQuery 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 (m :: * -> *) a b.
Functor m =>
(a -> b) -> DynamicQuery m a -> DynamicQuery m b
fmap :: forall a b. (a -> b) -> DynamicQuery m a -> DynamicQuery m b
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> DynamicQuery m b -> DynamicQuery m a
<$ :: forall a b. a -> DynamicQuery m b -> DynamicQuery m a
Functor)

instance (Monad m) => Applicative (DynamicQuery m) where
  pure :: forall a. a -> DynamicQuery m a
pure a
a = (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector a, Archetype m, Access m ()))
 -> DynamicQuery m a)
-> (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> (Vector a, Archetype m, Access m ())
-> m (Vector a, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) a
a, Archetype m
arch, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  {-# INLINE pure #-}

  DynamicQuery m (a -> b)
f <*> :: forall a b.
DynamicQuery m (a -> b) -> DynamicQuery m a -> DynamicQuery m b
<*> DynamicQuery m a
g = (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector b, Archetype m, Access m ()))
 -> DynamicQuery m b)
-> (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a, Archetype m, Access m ())
x <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
g Archetype m
arch
    (Vector (a -> b), Archetype m, Access m ())
y <- DynamicQuery m (a -> b)
-> Archetype m -> m (Vector (a -> b), Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m (a -> b)
f Archetype m
arch
    return $
      let (Vector a
as, Archetype m
arch', Access m ()
hook1) = (Vector a, Archetype m, Access m ())
x
          (Vector (a -> b)
bs, Archetype m
arch'', Access m ()
hook2) = (Vector (a -> b), Archetype m, Access m ())
y
       in (((a -> b) -> a -> b) -> Vector (a -> b) -> Vector a -> Vector b
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
($) Vector (a -> b)
bs Vector a
as, Archetype m
arch' Archetype m -> Archetype m -> Archetype m
forall a. Semigroup a => a -> a -> a
<> Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE (<*>) #-}

instance (Monad m) => DynamicQueryF m (DynamicQuery m) where
  entity :: DynamicQuery m EntityID
entity = (Archetype m -> m (Vector EntityID, Archetype m, Access m ()))
-> DynamicQuery m EntityID
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector EntityID, Archetype m, Access m ()))
 -> DynamicQuery m EntityID)
-> (Archetype m -> m (Vector EntityID, Archetype m, Access m ()))
-> DynamicQuery m EntityID
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> (Vector EntityID, Archetype m, Access m ())
-> m (Vector EntityID, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([EntityID] -> Vector EntityID
forall a. [a] -> Vector a
V.fromList ([EntityID] -> Vector EntityID)
-> (Set EntityID -> [EntityID]) -> Set EntityID -> Vector EntityID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set EntityID -> [EntityID]
forall a. Set a -> [a]
Set.toList (Set EntityID -> Vector EntityID)
-> Set EntityID -> Vector EntityID
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch, Archetype m
arch, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  {-# INLINE entity #-}

  queryDyn :: forall a. Component m a => ComponentID -> DynamicQuery m a
queryDyn ComponentID
cId = (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector a, Archetype m, Access m ()))
 -> DynamicQuery m a)
-> (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> (Vector a, Archetype m, Access m ())
-> m (Vector a, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ComponentID -> Archetype m -> Vector a
forall (m :: * -> *) a.
Component m a =>
ComponentID -> Archetype m -> Vector a
A.lookupComponentsAsc ComponentID
cId Archetype m
arch, Archetype m
arch, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  {-# INLINE queryDyn #-}

  queryMaybeDyn :: forall a. Component m a => ComponentID -> DynamicQuery m (Maybe a)
queryMaybeDyn ComponentID
cId = (Archetype m -> m (Vector (Maybe a), Archetype m, Access m ()))
-> DynamicQuery m (Maybe a)
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector (Maybe a), Archetype m, Access m ()))
 -> DynamicQuery m (Maybe a))
-> (Archetype m -> m (Vector (Maybe a), Archetype m, Access m ()))
-> DynamicQuery m (Maybe a)
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> case ComponentID -> Archetype m -> Maybe (Vector a)
forall (m :: * -> *) a.
Component m a =>
ComponentID -> Archetype m -> Maybe (Vector a)
A.lookupComponentsAscMaybe ComponentID
cId Archetype m
arch of
    Just Vector a
as -> (Vector (Maybe a), Archetype m, Access m ())
-> m (Vector (Maybe a), Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a -> Maybe a) -> Vector a -> Vector (Maybe a)
forall a b. (a -> b) -> Vector a -> Vector b
V.map a -> Maybe a
forall a. a -> Maybe a
Just Vector a
as, Archetype m
arch, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    Maybe (Vector a)
Nothing -> (Vector (Maybe a), Archetype m, Access m ())
-> m (Vector (Maybe a), Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Maybe a -> Vector (Maybe a)
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) Maybe a
forall a. Maybe a
Nothing, Archetype m
arch, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  {-# INLINE queryMaybeDyn #-}

  queryMapDyn :: forall a.
Component m a =>
(a -> a) -> ComponentID -> DynamicQuery m a
queryMapDyn a -> a
f ComponentID
cId = (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector a, Archetype m, Access m ()))
 -> DynamicQuery m a)
-> (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    let (Vector a
cs, Archetype m
arch', Access m ()
hook) = Vector ()
-> (() -> a -> a)
-> ComponentID
-> Archetype m
-> (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> c)
-> ComponentID
-> Archetype m
-> (Vector c, Archetype m, Access m ())
A.zipWith (Int -> () -> Vector ()
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) ()) ((a -> a) -> () -> a -> a
forall a b. a -> b -> a
const a -> a
f) ComponentID
cId Archetype m
arch
    (Vector a, Archetype m, Access m ())
-> m (Vector a, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector a
cs, Archetype m
arch', Access m ()
hook)
  {-# INLINE queryMapDyn #-}

  queryMapDyn_ :: forall a.
Component m a =>
(a -> a) -> ComponentID -> DynamicQuery m ()
queryMapDyn_ a -> a
f ComponentID
cId = (Archetype m -> m (Vector (), Archetype m, Access m ()))
-> DynamicQuery m ()
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector (), Archetype m, Access m ()))
 -> DynamicQuery m ())
-> (Archetype m -> m (Vector (), Archetype m, Access m ()))
-> DynamicQuery m ()
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    let (Archetype m
arch', Access m ()
hook) = Vector ()
-> (() -> a -> a)
-> ComponentID
-> Archetype m
-> (Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> c)
-> ComponentID
-> Archetype m
-> (Archetype m, Access m ())
A.zipWith_ (Int -> () -> Vector ()
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) ()) ((a -> a) -> () -> a -> a
forall a b. a -> b -> a
const a -> a
f) ComponentID
cId Archetype m
arch
    (Vector (), Archetype m, Access m ())
-> m (Vector (), Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Int -> () -> Vector ()
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) (), Archetype m
arch', Access m ()
hook)
  {-# INLINE queryMapDyn_ #-}

  queryMapDynM :: forall a.
(Monad m, Component m a) =>
(a -> m a) -> ComponentID -> DynamicQuery m a
queryMapDynM a -> m a
f ComponentID
cId = (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector a, Archetype m, Access m ()))
 -> DynamicQuery m a)
-> (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
cs, Archetype m
arch', Access m ()
hook) <- Vector ()
-> (() -> a -> m a)
-> ComponentID
-> Archetype m
-> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> m c)
-> ComponentID
-> Archetype m
-> m (Vector c, Archetype m, Access m ())
A.zipWithM (Int -> () -> Vector ()
forall a. Int -> a -> Vector a
V.replicate (Set EntityID -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set EntityID -> Int) -> Set EntityID -> Int
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch) ()) ((a -> m a) -> () -> a -> m a
forall a b. a -> b -> a
const a -> m a
f) ComponentID
cId Archetype m
arch
    (Vector a, Archetype m, Access m ())
-> m (Vector a, Archetype m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector a
cs, Archetype m
arch', Access m ()
hook)
  {-# INLINE queryMapDynM #-}

  queryMapDynWith :: forall b a.
Component m b =>
(a -> b -> b)
-> ComponentID -> DynamicQuery m a -> DynamicQuery m b
queryMapDynWith a -> b -> b
f ComponentID
cId DynamicQuery m a
q = (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector b, Archetype m, Access m ()))
 -> DynamicQuery m b)
-> (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
as, Archetype m
arch', Access m ()
hook1) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype m
arch
    let (Vector b
cs, Archetype m
arch'', Access m ()
hook2) = Vector a
-> (a -> b -> b)
-> ComponentID
-> Archetype m
-> (Vector b, Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> c)
-> ComponentID
-> Archetype m
-> (Vector c, Archetype m, Access m ())
A.zipWith Vector a
as a -> b -> b
f ComponentID
cId Archetype m
arch'
    (Vector b, Archetype m, Access m ())
-> m (Vector b, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector b
cs, Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE queryMapDynWith #-}

  queryMapDynWith_ :: forall b a.
Component m b =>
(a -> b -> b)
-> ComponentID -> DynamicQuery m a -> DynamicQuery m ()
queryMapDynWith_ a -> b -> b
f ComponentID
cId DynamicQuery m a
q = (Archetype m -> m (Vector (), Archetype m, Access m ()))
-> DynamicQuery m ()
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector (), Archetype m, Access m ()))
 -> DynamicQuery m ())
-> (Archetype m -> m (Vector (), Archetype m, Access m ()))
-> DynamicQuery m ()
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
as, Archetype m
arch', Access m ()
hook1) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype m
arch
    let (Archetype m
arch'', Access m ()
hook2) = Vector a
-> (a -> b -> b)
-> ComponentID
-> Archetype m
-> (Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> c)
-> ComponentID
-> Archetype m
-> (Archetype m, Access m ())
A.zipWith_ Vector a
as a -> b -> b
f ComponentID
cId Archetype m
arch'
    (Vector (), Archetype m, Access m ())
-> m (Vector (), Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return ((a -> ()) -> Vector a -> Vector ()
forall a b. (a -> b) -> Vector a -> Vector b
V.map (() -> a -> ()
forall a b. a -> b -> a
const ()) Vector a
as, Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE queryMapDynWith_ #-}

  queryMapDynWithM :: forall b a.
(Monad m, Component m b) =>
(a -> b -> m b)
-> ComponentID -> DynamicQuery m a -> DynamicQuery m b
queryMapDynWithM a -> b -> m b
f ComponentID
cId DynamicQuery m a
q = (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector b, Archetype m, Access m ()))
 -> DynamicQuery m b)
-> (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
as, Archetype m
arch', Access m ()
hook1) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype m
arch
    (Vector b
cs, Archetype m
arch'', Access m ()
hook2) <- Vector a
-> (a -> b -> m b)
-> ComponentID
-> Archetype m
-> m (Vector b, Archetype m, Access m ())
forall (m :: * -> *) a c.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> m c)
-> ComponentID
-> Archetype m
-> m (Vector c, Archetype m, Access m ())
A.zipWithM Vector a
as a -> b -> m b
f ComponentID
cId Archetype m
arch'
    (Vector b, Archetype m, Access m ())
-> m (Vector b, Archetype m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector b
cs, Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE queryMapDynWithM #-}

  queryMapDynWithAccum :: forall c b a.
Component m c =>
(b -> c -> (a, c))
-> ComponentID -> DynamicQuery m b -> DynamicQuery m (a, c)
queryMapDynWithAccum b -> c -> (a, c)
f ComponentID
cId DynamicQuery m b
q = (Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
-> DynamicQuery m (a, c)
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
 -> DynamicQuery m (a, c))
-> (Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
-> DynamicQuery m (a, c)
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector b
bs, Archetype m
arch', Access m ()
hook1) <- DynamicQuery m b
-> Archetype m -> m (Vector b, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m b
q Archetype m
arch
    let (Vector (a, c)
pairs, Archetype m
arch'', Access m ()
hook2) = Vector b
-> (b -> c -> (a, c))
-> ComponentID
-> Archetype m
-> (Vector (a, c), Archetype m, Access m ())
forall (m :: * -> *) a c o.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> (o, c))
-> ComponentID
-> Archetype m
-> (Vector (o, c), Archetype m, Access m ())
A.zipWithAccum Vector b
bs b -> c -> (a, c)
f ComponentID
cId Archetype m
arch'
    (Vector (a, c), Archetype m, Access m ())
-> m (Vector (a, c), Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector (a, c)
pairs, Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE queryMapDynWithAccum #-}

  queryMapDynWithAccumM :: forall c b a.
(Monad m, Component m c) =>
(b -> c -> m (a, c))
-> ComponentID -> DynamicQuery m b -> DynamicQuery m (a, c)
queryMapDynWithAccumM b -> c -> m (a, c)
f ComponentID
cId DynamicQuery m b
q = (Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
-> DynamicQuery m (a, c)
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
 -> DynamicQuery m (a, c))
-> (Archetype m -> m (Vector (a, c), Archetype m, Access m ()))
-> DynamicQuery m (a, c)
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector b
bs, Archetype m
arch', Access m ()
hook1) <- DynamicQuery m b
-> Archetype m -> m (Vector b, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m b
q Archetype m
arch
    (Vector (a, c)
pairs, Archetype m
arch'', Access m ()
hook2) <- Vector b
-> (b -> c -> m (a, c))
-> ComponentID
-> Archetype m
-> m (Vector (a, c), Archetype m, Access m ())
forall (m :: * -> *) a c o.
(Monad m, Component m c) =>
Vector a
-> (a -> c -> m (o, c))
-> ComponentID
-> Archetype m
-> m (Vector (o, c), Archetype m, Access m ())
A.zipWithAccumM Vector b
bs b -> c -> m (a, c)
f ComponentID
cId Archetype m
arch'
    (Vector (a, c), Archetype m, Access m ())
-> m (Vector (a, c), Archetype m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector (a, c)
pairs, Archetype m
arch'', Access m ()
hook1 Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook2)
  {-# INLINE queryMapDynWithAccumM #-}

  queryUntracked :: forall a. DynamicQuery m a -> DynamicQuery m a
queryUntracked DynamicQuery m a
q = (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector a, Archetype m, Access m ()))
 -> DynamicQuery m a)
-> (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
as, Archetype m
arch', Access m ()
_hooks) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype m
arch
    (Vector a, Archetype m, Access m ())
-> m (Vector a, Archetype m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector a
as, Archetype m
arch', () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  {-# INLINE queryUntracked #-}

  queryFilterMap :: forall a b. (a -> Maybe b) -> DynamicQuery m a -> DynamicQuery m b
queryFilterMap a -> Maybe b
p DynamicQuery m a
q = (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall (m :: * -> *) a.
(Archetype m -> m (Vector a, Archetype m, Access m ()))
-> DynamicQuery m a
DynamicQuery ((Archetype m -> m (Vector b, Archetype m, Access m ()))
 -> DynamicQuery m b)
-> (Archetype m -> m (Vector b, Archetype m, Access m ()))
-> DynamicQuery m b
forall a b. (a -> b) -> a -> b
$ \Archetype m
arch -> do
    (Vector a
as, Archetype m
_, Access m ()
_) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype m
arch
    let eIds :: Vector EntityID
eIds = [EntityID] -> Vector EntityID
forall a. [a] -> Vector a
V.fromList ([EntityID] -> Vector EntityID)
-> (Set EntityID -> [EntityID]) -> Set EntityID -> Vector EntityID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set EntityID -> [EntityID]
forall a. Set a -> [a]
Set.toList (Set EntityID -> Vector EntityID)
-> Set EntityID -> Vector EntityID
forall a b. (a -> b) -> a -> b
$ Archetype m -> Set EntityID
forall (m :: * -> *). Archetype m -> Set EntityID
A.entities Archetype m
arch
        mapped :: Vector (Maybe b)
mapped = (a -> Maybe b) -> Vector a -> Vector (Maybe b)
forall a b. (a -> b) -> Vector a -> Vector b
V.map a -> Maybe b
p Vector a
as
        (Vector EntityID
filteredEIds, Vector Int
indices, Vector b
filteredBs) = Vector (EntityID, Int, b)
-> (Vector EntityID, Vector Int, Vector b)
forall a b c. Vector (a, b, c) -> (Vector a, Vector b, Vector c)
V.unzip3 (Vector (EntityID, Int, b)
 -> (Vector EntityID, Vector Int, Vector b))
-> (Vector (EntityID, Maybe b) -> Vector (EntityID, Int, b))
-> Vector (EntityID, Maybe b)
-> (Vector EntityID, Vector Int, Vector b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (EntityID, Maybe b) -> Maybe (EntityID, Int, b))
-> Vector (EntityID, Maybe b) -> Vector (EntityID, Int, b)
forall a b. (Int -> a -> Maybe b) -> Vector a -> Vector b
V.imapMaybe (\Int
i (EntityID
e, Maybe b
mb) -> (\b
b -> (EntityID
e, Int
i, b
b)) (b -> (EntityID, Int, b)) -> Maybe b -> Maybe (EntityID, Int, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe b
mb) (Vector (EntityID, Maybe b)
 -> (Vector EntityID, Vector Int, Vector b))
-> Vector (EntityID, Maybe b)
-> (Vector EntityID, Vector Int, Vector b)
forall a b. (a -> b) -> a -> b
$ Vector EntityID -> Vector (Maybe b) -> Vector (EntityID, Maybe b)
forall a b. Vector a -> Vector b -> Vector (a, b)
V.zip Vector EntityID
eIds Vector (Maybe b)
mapped
        filteredArch :: Archetype Any
filteredArch = Vector Int -> Archetype m -> Archetype Any
forall {m :: * -> *} {m :: * -> *}.
Vector Int -> Archetype m -> Archetype m
filterArchetype Vector Int
indices Archetype m
arch
    (Vector a
_, Archetype m
filteredArch', Access m ()
hook) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype Any
filteredArch {A.entities = Set.fromList $ V.toList filteredEIds}
    let resultArch :: Archetype m
resultArch = Vector Int -> Archetype m -> Archetype m -> Archetype m
forall {m :: * -> *} {m :: * -> *} {m :: * -> *}.
Vector Int -> Archetype m -> Archetype m -> Archetype m
unfilterArchetype Vector Int
indices Archetype m
arch Archetype m
filteredArch'
    (Vector b, Archetype m, Access m ())
-> m (Vector b, Archetype m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector b
filteredBs, Archetype m
resultArch, Access m ()
hook)
    where
      filterArchetype :: Vector Int -> Archetype m -> Archetype m
filterArchetype Vector Int
indices Archetype m
arch =
        Archetype m
arch {A.storages = IntMap.map (filterStorage indices) $ A.storages arch}
      filterStorage :: Vector Int -> DynamicStorage -> DynamicStorage
filterStorage Vector Int
indices DynamicStorage
s =
        let allVec :: Vector Dynamic
allVec = DynamicStorage -> Vector Dynamic
toAscVectorDyn DynamicStorage
s
            filteredVec :: Vector Dynamic
filteredVec = (Int -> Dynamic) -> Vector Int -> Vector Dynamic
forall a b. (a -> b) -> Vector a -> Vector b
V.map (Vector Dynamic
allVec Vector Dynamic -> Int -> Dynamic
forall a. Vector a -> Int -> a
V.!) Vector Int
indices
         in Vector Dynamic -> DynamicStorage -> DynamicStorage
fromAscVectorDyn Vector Dynamic
filteredVec DynamicStorage
s
      unfilterArchetype :: Vector Int -> Archetype m -> Archetype m -> Archetype m
unfilterArchetype Vector Int
indices Archetype m
original Archetype m
filtered =
        Archetype m
original {A.storages = IntMap.mapWithKey go $ A.storages original}
        where
          go :: Int -> DynamicStorage -> DynamicStorage
go Int
cId DynamicStorage
s = case Int -> IntMap DynamicStorage -> Maybe DynamicStorage
forall a. Int -> IntMap a -> Maybe a
IntMap.lookup Int
cId (Archetype m -> IntMap DynamicStorage
forall (m :: * -> *). Archetype m -> IntMap DynamicStorage
A.storages Archetype m
filtered) of
            Just DynamicStorage
filteredStorage ->
              let origVec :: Vector Dynamic
origVec = DynamicStorage -> Vector Dynamic
toAscVectorDyn DynamicStorage
s
                  filteredVec :: Vector Dynamic
filteredVec = DynamicStorage -> Vector Dynamic
toAscVectorDyn DynamicStorage
filteredStorage
                  mergedVec :: Vector Dynamic
mergedVec = (Dynamic -> Dynamic -> Dynamic)
-> Vector Dynamic -> [(Int, Dynamic)] -> Vector Dynamic
forall a b. (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
V.accum (\Dynamic
_ Dynamic
new -> Dynamic
new) Vector Dynamic
origVec (Vector (Int, Dynamic) -> [(Int, Dynamic)]
forall a. Vector a -> [a]
V.toList (Vector (Int, Dynamic) -> [(Int, Dynamic)])
-> Vector (Int, Dynamic) -> [(Int, Dynamic)]
forall a b. (a -> b) -> a -> b
$ Vector Int -> Vector Dynamic -> Vector (Int, Dynamic)
forall a b. Vector a -> Vector b -> Vector (a, b)
V.zip Vector Int
indices Vector Dynamic
filteredVec)
               in Vector Dynamic -> DynamicStorage -> DynamicStorage
fromAscVectorDyn Vector Dynamic
mergedVec DynamicStorage
s
            Maybe DynamicStorage
Nothing -> DynamicStorage
s
  {-# INLINE queryFilterMap #-}

-- | Match all entities.
readQueryDyn :: (Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m (Vector a)
readQueryDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID -> DynamicQuery m a -> Entities m -> m (Vector a)
readQueryDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es =
  if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
    then (\(Vector a
a, Archetype m
_, Access m ()
_) -> Vector a
a) ((Vector a, Archetype m, Access m ()) -> Vector a)
-> m (Vector a, Archetype m, Access m ()) -> m (Vector a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype Any
forall (m :: * -> *). Archetype m
A.empty {A.entities = Map.keysSet $ entities es}
    else do
      let go :: Node m -> m (Vector a)
go Node m
n = (\(Vector a
a, Archetype m
_, Access m ()
_) -> Vector a
a) ((Vector a, Archetype m, Access m ()) -> Vector a)
-> m (Vector a, Archetype m, Access m ()) -> m (Vector a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
AS.nodeArchetype Node m
n)
      [Vector a]
results <- (Node m -> m (Vector a)) -> [Node m] -> m [Vector a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Node m -> m (Vector a)
go ([Node m] -> m [Vector a])
-> (Map ArchetypeID (Node m) -> [Node m])
-> Map ArchetypeID (Node m)
-> m [Vector a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map ArchetypeID (Node m) -> [Node m]
forall k a. Map k a -> [a]
Map.elems (Map ArchetypeID (Node m) -> m [Vector a])
-> Map ArchetypeID (Node m) -> m [Vector a]
forall a b. (a -> b) -> a -> b
$ Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es
      return $ [Vector a] -> Vector a
forall a. [Vector a] -> Vector a
V.concat [Vector a]
results

-- | Match all entities with a filter.
readQueryFilteredDyn :: (Monad m) => Set ComponentID -> (Node m -> Bool) -> DynamicQuery m a -> Entities m -> m (Vector a)
readQueryFilteredDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID
-> (Node m -> Bool)
-> DynamicQuery m a
-> Entities m
-> m (Vector a)
readQueryFilteredDyn Set ComponentID
cIds Node m -> Bool
f DynamicQuery m a
q Entities m
es =
  if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
    then (\(Vector a
a, Archetype m
_, Access m ()
_) -> Vector a
a) ((Vector a, Archetype m, Access m ()) -> Vector a)
-> m (Vector a, Archetype m, Access m ()) -> m (Vector a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q Archetype Any
forall (m :: * -> *). Archetype m
A.empty {A.entities = Map.keysSet $ entities es}
    else do
      let go :: Node m -> m (Vector a)
go Node m
n = (\(Vector a
a, Archetype m
_, Access m ()
_) -> Vector a
a) ((Vector a, Archetype m, Access m ()) -> Vector a)
-> m (Vector a, Archetype m, Access m ()) -> m (Vector a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
AS.nodeArchetype Node m
n)
      [Vector a]
results <- (Node m -> m (Vector a)) -> [Node m] -> m [Vector a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Node m -> m (Vector a)
go ([Node m] -> m [Vector a])
-> (Map ArchetypeID (Node m) -> [Node m])
-> Map ArchetypeID (Node m)
-> m [Vector a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map ArchetypeID (Node m) -> [Node m]
forall k a. Map k a -> [a]
Map.elems (Map ArchetypeID (Node m) -> [Node m])
-> (Map ArchetypeID (Node m) -> Map ArchetypeID (Node m))
-> Map ArchetypeID (Node m)
-> [Node m]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Node m -> Bool)
-> Map ArchetypeID (Node m) -> Map ArchetypeID (Node m)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Node m -> Bool
f (Map ArchetypeID (Node m) -> m [Vector a])
-> Map ArchetypeID (Node m) -> m [Vector a]
forall a b. (a -> b) -> a -> b
$ Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es
      return $ [Vector a] -> Vector a
forall a. [Vector a] -> Vector a
V.concat [Vector a]
results

-- | Match a single entity.
readQuerySingleDyn :: (HasCallStack, Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m a
readQuerySingleDyn :: forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Set ComponentID -> DynamicQuery m a -> Entities m -> m a
readQuerySingleDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es = do
  Maybe a
res <- Set ComponentID -> DynamicQuery m a -> Entities m -> m (Maybe a)
forall (m :: * -> *) a.
Monad m =>
Set ComponentID -> DynamicQuery m a -> Entities m -> m (Maybe a)
readQuerySingleMaybeDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es
  case Maybe a
res of
    Just a
a -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a
    Maybe a
_ -> [Char] -> m a
forall a. HasCallStack => [Char] -> a
error [Char]
"readQuerySingleDyn: expected a single entity"

-- | Match a single entity, or `Nothing`.
readQuerySingleMaybeDyn :: (Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m (Maybe a)
readQuerySingleMaybeDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID -> DynamicQuery m a -> Entities m -> m (Maybe a)
readQuerySingleMaybeDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es =
  if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
    then case Map EntityID ArchetypeID -> [EntityID]
forall k a. Map k a -> [k]
Map.keys (Map EntityID ArchetypeID -> [EntityID])
-> Map EntityID ArchetypeID -> [EntityID]
forall a b. (a -> b) -> a -> b
$ Entities m -> Map EntityID ArchetypeID
forall (m :: * -> *). Entities m -> Map EntityID ArchetypeID
entities Entities m
es of
      [EntityID
eId] -> do
        (Vector a
v, Archetype m
_, Access m ()
_) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ EntityID -> Archetype m
forall (m :: * -> *). EntityID -> Archetype m
A.singleton EntityID
eId
        Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a)) -> Maybe a -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ if Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then a -> Maybe a
forall a. a -> Maybe a
Just (Vector a -> a
forall a. Vector a -> a
V.head Vector a
v) else Maybe a
forall a. Maybe a
Nothing
      [EntityID]
_ -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
    else case Map ArchetypeID (Node m) -> [Node m]
forall k a. Map k a -> [a]
Map.elems (Map ArchetypeID (Node m) -> [Node m])
-> Map ArchetypeID (Node m) -> [Node m]
forall a b. (a -> b) -> a -> b
$ Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es of
      [Node m
n] -> do
        (Vector a
v, Archetype m
_, Access m ()
_) <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
AS.nodeArchetype Node m
n
        Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a)) -> Maybe a -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ if Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then a -> Maybe a
forall a. a -> Maybe a
Just (Vector a -> a
forall a. Vector a -> a
V.head Vector a
v) else Maybe a
forall a. Maybe a
Nothing
      [Node m]
_ -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing

-- | Map all matched entities.
runQueryDyn :: (Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m (Vector a, Entities m, Access m ())
runQueryDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID
-> DynamicQuery m a
-> Entities m
-> m (Vector a, Entities m, Access m ())
runQueryDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es =
  let go :: Archetype m -> m (Vector a, Archetype m, Access m ())
go = DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q
   in if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
        then do
          (Vector a
as, Archetype m
_, Access m ()
hook) <- Archetype m -> m (Vector a, Archetype m, Access m ())
go Archetype Any
forall (m :: * -> *). Archetype m
A.empty {A.entities = Map.keysSet $ entities es}
          (Vector a, Entities m, Access m ())
-> m (Vector a, Entities m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector a
as, Entities m
es, Access m ()
hook)
        else
          let go' :: (Vector a, Entities m, Access m ())
-> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ())
go' (Vector a
acc, Entities m
esAcc, Access m ()
hooks) (ArchetypeID
aId, Node m
n) = do
                (Vector a
as', Archetype m
arch', Access m ()
hook) <- Archetype m -> m (Vector a, Archetype m, Access m ())
go (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
nodeArchetype Node m
n
                let !nodes :: Map ArchetypeID (Node m)
nodes = ArchetypeID
-> Node m -> Map ArchetypeID (Node m) -> Map ArchetypeID (Node m)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ArchetypeID
aId Node m
n {nodeArchetype = arch' <> nodeArchetype n} (Map ArchetypeID (Node m) -> Map ArchetypeID (Node m))
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> Map ArchetypeID (Node m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *). Archetypes m -> Map ArchetypeID (Node m)
AS.nodes (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
esAcc
                (Vector a, Entities m, Access m ())
-> m (Vector a, Entities m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector a
as' Vector a -> Vector a -> Vector a
forall a. Vector a -> Vector a -> Vector a
V.++ Vector a
acc, Entities m
esAcc {archetypes = (archetypes esAcc) {AS.nodes = nodes}}, Access m ()
hooks Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook)
           in ((Vector a, Entities m, Access m ())
 -> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ()))
-> (Vector a, Entities m, Access m ())
-> [(ArchetypeID, Node m)]
-> m (Vector a, Entities m, Access m ())
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM (Vector a, Entities m, Access m ())
-> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ())
go' (Vector a
forall a. Vector a
V.empty, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()) ([(ArchetypeID, Node m)] -> m (Vector a, Entities m, Access m ()))
-> [(ArchetypeID, Node m)] -> m (Vector a, Entities m, Access m ())
forall a b. (a -> b) -> a -> b
$ Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)])
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> [(ArchetypeID, Node m)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> [(ArchetypeID, Node m)])
-> Archetypes m -> [(ArchetypeID, Node m)]
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es
{-# INLINE runQueryDyn #-}

-- | Map all matched entities.
runQueryFilteredDyn :: (Monad m) => Set ComponentID -> (Node m -> Bool) -> DynamicQuery m a -> Entities m -> m (Vector a, Entities m, Access m ())
runQueryFilteredDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID
-> (Node m -> Bool)
-> DynamicQuery m a
-> Entities m
-> m (Vector a, Entities m, Access m ())
runQueryFilteredDyn Set ComponentID
cIds Node m -> Bool
f DynamicQuery m a
q Entities m
es =
  let go :: Archetype m -> m (Vector a, Archetype m, Access m ())
go = DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q
   in if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
        then do
          (Vector a
as, Archetype m
_, Access m ()
hook) <- Archetype m -> m (Vector a, Archetype m, Access m ())
go Archetype Any
forall (m :: * -> *). Archetype m
A.empty {A.entities = Map.keysSet $ entities es}
          (Vector a, Entities m, Access m ())
-> m (Vector a, Entities m, Access m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector a
as, Entities m
es, Access m ()
hook)
        else
          let go' :: (Vector a, Entities m, Access m ())
-> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ())
go' (Vector a
acc, Entities m
esAcc, Access m ()
hooks) (ArchetypeID
aId, Node m
n) = do
                (Vector a
as', Archetype m
arch', Access m ()
hook) <- Archetype m -> m (Vector a, Archetype m, Access m ())
go (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
nodeArchetype Node m
n
                let !nodes :: Map ArchetypeID (Node m)
nodes = ArchetypeID
-> Node m -> Map ArchetypeID (Node m) -> Map ArchetypeID (Node m)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ArchetypeID
aId Node m
n {nodeArchetype = arch' <> nodeArchetype n} (Map ArchetypeID (Node m) -> Map ArchetypeID (Node m))
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> Map ArchetypeID (Node m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *). Archetypes m -> Map ArchetypeID (Node m)
AS.nodes (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
esAcc
                (Vector a, Entities m, Access m ())
-> m (Vector a, Entities m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
return (Vector a
as' Vector a -> Vector a -> Vector a
forall a. Vector a -> Vector a -> Vector a
V.++ Vector a
acc, Entities m
esAcc {archetypes = (archetypes esAcc) {AS.nodes = nodes}}, Access m ()
hooks Access m () -> Access m () -> Access m ()
forall a b. Access m a -> Access m b -> Access m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Access m ()
hook)
           in ((Vector a, Entities m, Access m ())
 -> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ()))
-> (Vector a, Entities m, Access m ())
-> [(ArchetypeID, Node m)]
-> m (Vector a, Entities m, Access m ())
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM (Vector a, Entities m, Access m ())
-> (ArchetypeID, Node m) -> m (Vector a, Entities m, Access m ())
go' (Vector a
forall a. Vector a
V.empty, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()) ([(ArchetypeID, Node m)] -> m (Vector a, Entities m, Access m ()))
-> [(ArchetypeID, Node m)] -> m (Vector a, Entities m, Access m ())
forall a b. (a -> b) -> a -> b
$ Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)])
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> [(ArchetypeID, Node m)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Node m -> Bool)
-> Map ArchetypeID (Node m) -> Map ArchetypeID (Node m)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Node m -> Bool
f (Map ArchetypeID (Node m) -> Map ArchetypeID (Node m))
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> Map ArchetypeID (Node m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> [(ArchetypeID, Node m)])
-> Archetypes m -> [(ArchetypeID, Node m)]
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es
{-# INLINE runQueryFilteredDyn #-}

-- | Map a single matched entity.
runQuerySingleDyn :: (HasCallStack, Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m (a, Entities m, Access m ())
runQuerySingleDyn :: forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Set ComponentID
-> DynamicQuery m a -> Entities m -> m (a, Entities m, Access m ())
runQuerySingleDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es = do
  (Maybe a, Entities m, Access m ())
res <- Set ComponentID
-> DynamicQuery m a
-> Entities m
-> m (Maybe a, Entities m, Access m ())
forall (m :: * -> *) a.
Monad m =>
Set ComponentID
-> DynamicQuery m a
-> Entities m
-> m (Maybe a, Entities m, Access m ())
runQuerySingleMaybeDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es
  return $ case (Maybe a, Entities m, Access m ())
res of
    (Just a
a, Entities m
es', Access m ()
hook) -> (a
a, Entities m
es', Access m ()
hook)
    (Maybe a, Entities m, Access m ())
_ -> [Char] -> (a, Entities m, Access m ())
forall a. HasCallStack => [Char] -> a
error [Char]
"querySingleDyn: expected single matching entity"

-- | Map a single matched entity, or @Nothing@.
runQuerySingleMaybeDyn :: (Monad m) => Set ComponentID -> DynamicQuery m a -> Entities m -> m (Maybe a, Entities m, Access m ())
runQuerySingleMaybeDyn :: forall (m :: * -> *) a.
Monad m =>
Set ComponentID
-> DynamicQuery m a
-> Entities m
-> m (Maybe a, Entities m, Access m ())
runQuerySingleMaybeDyn Set ComponentID
cIds DynamicQuery m a
q Entities m
es =
  if Set ComponentID -> Bool
forall a. Set a -> Bool
Set.null Set ComponentID
cIds
    then case Map EntityID ArchetypeID -> [EntityID]
forall k a. Map k a -> [k]
Map.keys (Map EntityID ArchetypeID -> [EntityID])
-> Map EntityID ArchetypeID -> [EntityID]
forall a b. (a -> b) -> a -> b
$ Entities m -> Map EntityID ArchetypeID
forall (m :: * -> *). Entities m -> Map EntityID ArchetypeID
entities Entities m
es of
      [EntityID
eId] -> do
        (Vector a, Archetype m, Access m ())
res <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ EntityID -> Archetype m
forall (m :: * -> *). EntityID -> Archetype m
A.singleton EntityID
eId
        return $ case (Vector a, Archetype m, Access m ())
res of
          (Vector a
v, Archetype m
_, Access m ()
hook) | Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 -> (a -> Maybe a
forall a. a -> Maybe a
Just (Vector a -> a
forall a. Vector a -> a
V.head Vector a
v), Entities m
es, Access m ()
hook)
          (Vector a, Archetype m, Access m ())
_ -> (Maybe a
forall a. Maybe a
Nothing, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
      [EntityID]
_ -> (Maybe a, Entities m, Access m ())
-> m (Maybe a, Entities m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe a
forall a. Maybe a
Nothing, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    else case Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)])
-> Map ArchetypeID (Node m) -> [(ArchetypeID, Node m)]
forall a b. (a -> b) -> a -> b
$ Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *).
Set ComponentID -> Archetypes m -> Map ArchetypeID (Node m)
AS.find Set ComponentID
cIds (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es of
      [(ArchetypeID
aId, Node m
n)] -> do
        (Vector a, Archetype m, Access m ())
res <- DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall (m :: * -> *) a.
DynamicQuery m a
-> Archetype m -> m (Vector a, Archetype m, Access m ())
runDynQuery DynamicQuery m a
q (Archetype m -> m (Vector a, Archetype m, Access m ()))
-> Archetype m -> m (Vector a, Archetype m, Access m ())
forall a b. (a -> b) -> a -> b
$ Node m -> Archetype m
forall (m :: * -> *). Node m -> Archetype m
AS.nodeArchetype Node m
n
        return $ case (Vector a, Archetype m, Access m ())
res of
          (Vector a
v, Archetype m
arch', Access m ()
hook)
            | Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 ->
                let nodes :: Map ArchetypeID (Node m)
nodes = ArchetypeID
-> Node m -> Map ArchetypeID (Node m) -> Map ArchetypeID (Node m)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ArchetypeID
aId Node m
n {nodeArchetype = arch' <> nodeArchetype n} (Map ArchetypeID (Node m) -> Map ArchetypeID (Node m))
-> (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m
-> Map ArchetypeID (Node m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Archetypes m -> Map ArchetypeID (Node m)
forall (m :: * -> *). Archetypes m -> Map ArchetypeID (Node m)
AS.nodes (Archetypes m -> Map ArchetypeID (Node m))
-> Archetypes m -> Map ArchetypeID (Node m)
forall a b. (a -> b) -> a -> b
$ Entities m -> Archetypes m
forall (m :: * -> *). Entities m -> Archetypes m
archetypes Entities m
es
                 in (a -> Maybe a
forall a. a -> Maybe a
Just (Vector a -> a
forall a. Vector a -> a
V.head Vector a
v), Entities m
es {archetypes = (archetypes es) {AS.nodes = nodes}}, Access m ()
hook)
          (Vector a, Archetype m, Access m ())
_ -> (Maybe a
forall a. Maybe a
Nothing, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
      [(ArchetypeID, Node m)]
_ -> (Maybe a, Entities m, Access m ())
-> m (Maybe a, Entities m, Access m ())
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe a
forall a. Maybe a
Nothing, Entities m
es, () -> Access m ()
forall a. a -> Access m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
{-# INLINE runQuerySingleMaybeDyn #-}

-- | Dynamic query filter.
data DynamicQueryFilter = DynamicQueryFilter
  { -- | `ComponentID`s to include.
    DynamicQueryFilter -> Set ComponentID
filterWith :: !(Set ComponentID),
    -- | `ComponentID`s to exclude.
    DynamicQueryFilter -> Set ComponentID
filterWithout :: !(Set ComponentID)
  }

instance Semigroup DynamicQueryFilter where
  DynamicQueryFilter Set ComponentID
withA Set ComponentID
withoutA <> :: DynamicQueryFilter -> DynamicQueryFilter -> DynamicQueryFilter
<> DynamicQueryFilter Set ComponentID
withB Set ComponentID
withoutB =
    Set ComponentID -> Set ComponentID -> DynamicQueryFilter
DynamicQueryFilter (Set ComponentID
withA Set ComponentID -> Set ComponentID -> Set ComponentID
forall a. Semigroup a => a -> a -> a
<> Set ComponentID
withB) (Set ComponentID
withoutA Set ComponentID -> Set ComponentID -> Set ComponentID
forall a. Semigroup a => a -> a -> a
<> Set ComponentID
withoutB)
  {-# INLINE (<>) #-}

instance Monoid DynamicQueryFilter where
  mempty :: DynamicQueryFilter
mempty = Set ComponentID -> Set ComponentID -> DynamicQueryFilter
DynamicQueryFilter Set ComponentID
forall a. Monoid a => a
mempty Set ComponentID
forall a. Monoid a => a
mempty
  {-# INLINE mempty #-}