module Engine.Vulkan.Types
  ( MonadVulkan
  , HasVulkan(..)
  , getPipelineCache

  , HasSwapchain(..)
  , HasRenderPass(..)
  , RenderPass(..)

  , PhysicalDeviceInfo(..)
  , Queues(..)

  , DsLayouts
  , DsLayoutBindings

  , Bound(..)
  ) where

import RIO

import Data.Kind (Type)
import RIO.App (App(..))
import RIO.State (MonadState(..))
import UnliftIO.Resource (MonadResource)
import Vulkan.Core10 qualified as Vk
import Vulkan.Core12.Promoted_From_VK_EXT_descriptor_indexing qualified as Vk12
import Vulkan.NamedType ((:::))
import Vulkan.Utils.QueueAssignment (QueueFamilyIndex(..))
import VulkanMemoryAllocator qualified as VMA

type MonadVulkan env m =
  ( MonadUnliftIO m
  , MonadReader env m
  , HasVulkan env
  )

-- | A class for Monads which can provide some Vulkan handles
class HasVulkan a where
  getInstance           :: a -> Vk.Instance
  getQueues             :: a -> Queues (QueueFamilyIndex, Vk.Queue)
  getPhysicalDevice     :: a -> Vk.PhysicalDevice
  getPhysicalDeviceInfo :: a -> PhysicalDeviceInfo
  getDevice             :: a -> Vk.Device
  getAllocator          :: a -> VMA.Allocator

instance HasVulkan env => HasVulkan (App env st) where
  getInstance :: App env st -> Instance
getInstance           = env -> Instance
forall a. HasVulkan a => a -> Instance
getInstance (env -> Instance) -> (App env st -> env) -> App env st -> Instance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv
  getQueues :: App env st -> Queues (QueueFamilyIndex, Queue)
getQueues             = env -> Queues (QueueFamilyIndex, Queue)
forall a. HasVulkan a => a -> Queues (QueueFamilyIndex, Queue)
getQueues (env -> Queues (QueueFamilyIndex, Queue))
-> (App env st -> env)
-> App env st
-> Queues (QueueFamilyIndex, Queue)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv
  getPhysicalDevice :: App env st -> PhysicalDevice
getPhysicalDevice     = env -> PhysicalDevice
forall a. HasVulkan a => a -> PhysicalDevice
getPhysicalDevice (env -> PhysicalDevice)
-> (App env st -> env) -> App env st -> PhysicalDevice
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv
  getPhysicalDeviceInfo :: App env st -> PhysicalDeviceInfo
getPhysicalDeviceInfo = env -> PhysicalDeviceInfo
forall a. HasVulkan a => a -> PhysicalDeviceInfo
getPhysicalDeviceInfo (env -> PhysicalDeviceInfo)
-> (App env st -> env) -> App env st -> PhysicalDeviceInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv
  getDevice :: App env st -> Device
getDevice             = env -> Device
forall a. HasVulkan a => a -> Device
getDevice (env -> Device) -> (App env st -> env) -> App env st -> Device
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv
  getAllocator :: App env st -> Allocator
getAllocator          = env -> Allocator
forall a. HasVulkan a => a -> Allocator
getAllocator (env -> Allocator)
-> (App env st -> env) -> App env st -> Allocator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. App env st -> env
forall env st. App env st -> env
appEnv

instance (HasVulkan env) => HasVulkan (env, a) where
  getInstance :: (env, a) -> Instance
getInstance           = env -> Instance
forall a. HasVulkan a => a -> Instance
getInstance (env -> Instance) -> ((env, a) -> env) -> (env, a) -> Instance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst
  getQueues :: (env, a) -> Queues (QueueFamilyIndex, Queue)
getQueues             = env -> Queues (QueueFamilyIndex, Queue)
forall a. HasVulkan a => a -> Queues (QueueFamilyIndex, Queue)
getQueues (env -> Queues (QueueFamilyIndex, Queue))
-> ((env, a) -> env)
-> (env, a)
-> Queues (QueueFamilyIndex, Queue)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst
  getPhysicalDevice :: (env, a) -> PhysicalDevice
getPhysicalDevice     = env -> PhysicalDevice
forall a. HasVulkan a => a -> PhysicalDevice
getPhysicalDevice (env -> PhysicalDevice)
-> ((env, a) -> env) -> (env, a) -> PhysicalDevice
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst
  getPhysicalDeviceInfo :: (env, a) -> PhysicalDeviceInfo
getPhysicalDeviceInfo = env -> PhysicalDeviceInfo
forall a. HasVulkan a => a -> PhysicalDeviceInfo
getPhysicalDeviceInfo (env -> PhysicalDeviceInfo)
-> ((env, a) -> env) -> (env, a) -> PhysicalDeviceInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst
  getDevice :: (env, a) -> Device
getDevice             = env -> Device
forall a. HasVulkan a => a -> Device
getDevice (env -> Device) -> ((env, a) -> env) -> (env, a) -> Device
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst
  getAllocator :: (env, a) -> Allocator
getAllocator          = env -> Allocator
forall a. HasVulkan a => a -> Allocator
getAllocator (env -> Allocator) -> ((env, a) -> env) -> (env, a) -> Allocator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (env, a) -> env
forall a b. (a, b) -> a
fst

-- TODO
getPipelineCache :: {- HasVulkan ctx => -} ctx -> Vk.PipelineCache
getPipelineCache :: forall ctx. ctx -> PipelineCache
getPipelineCache ctx
_ctx = PipelineCache
forall a. IsHandle a => a
Vk.NULL_HANDLE

{- |
  The shape of all the queues we use for our program, parameterized over the
  queue type so we can use it with 'Vulkan.Utils.QueueAssignment.assignQueues'.
-}
data Queues q = Queues
  { forall q. Queues q -> q
qGraphics :: q
  , forall q. Queues q -> q
qTransfer :: q
  , forall q. Queues q -> q
qCompute  :: q
  }
  deriving (Int -> Queues q -> ShowS
[Queues q] -> ShowS
Queues q -> String
(Int -> Queues q -> ShowS)
-> (Queues q -> String) -> ([Queues q] -> ShowS) -> Show (Queues q)
forall q. Show q => Int -> Queues q -> ShowS
forall q. Show q => [Queues q] -> ShowS
forall q. Show q => Queues q -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall q. Show q => Int -> Queues q -> ShowS
showsPrec :: Int -> Queues q -> ShowS
$cshow :: forall q. Show q => Queues q -> String
show :: Queues q -> String
$cshowList :: forall q. Show q => [Queues q] -> ShowS
showList :: [Queues q] -> ShowS
Show, (forall a b. (a -> b) -> Queues a -> Queues b)
-> (forall a b. a -> Queues b -> Queues a) -> Functor Queues
forall a b. a -> Queues b -> Queues a
forall a b. (a -> b) -> Queues a -> Queues b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Queues a -> Queues b
fmap :: forall a b. (a -> b) -> Queues a -> Queues b
$c<$ :: forall a b. a -> Queues b -> Queues a
<$ :: forall a b. a -> Queues b -> Queues a
Functor, (forall m. Monoid m => Queues m -> m)
-> (forall m a. Monoid m => (a -> m) -> Queues a -> m)
-> (forall m a. Monoid m => (a -> m) -> Queues a -> m)
-> (forall a b. (a -> b -> b) -> b -> Queues a -> b)
-> (forall a b. (a -> b -> b) -> b -> Queues a -> b)
-> (forall b a. (b -> a -> b) -> b -> Queues a -> b)
-> (forall b a. (b -> a -> b) -> b -> Queues a -> b)
-> (forall a. (a -> a -> a) -> Queues a -> a)
-> (forall a. (a -> a -> a) -> Queues a -> a)
-> (forall a. Queues a -> [a])
-> (forall a. Queues a -> Bool)
-> (forall a. Queues a -> Int)
-> (forall a. Eq a => a -> Queues a -> Bool)
-> (forall a. Ord a => Queues a -> a)
-> (forall a. Ord a => Queues a -> a)
-> (forall a. Num a => Queues a -> a)
-> (forall a. Num a => Queues a -> a)
-> Foldable Queues
forall a. Eq a => a -> Queues a -> Bool
forall a. Num a => Queues a -> a
forall a. Ord a => Queues a -> a
forall m. Monoid m => Queues m -> m
forall a. Queues a -> Bool
forall a. Queues a -> Int
forall a. Queues a -> [a]
forall a. (a -> a -> a) -> Queues a -> a
forall m a. Monoid m => (a -> m) -> Queues a -> m
forall b a. (b -> a -> b) -> b -> Queues a -> b
forall a b. (a -> b -> b) -> b -> Queues a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Queues m -> m
fold :: forall m. Monoid m => Queues m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Queues a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Queues a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Queues a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Queues a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Queues a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Queues a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Queues a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Queues a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Queues a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Queues a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Queues a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Queues a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Queues a -> a
foldr1 :: forall a. (a -> a -> a) -> Queues a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Queues a -> a
foldl1 :: forall a. (a -> a -> a) -> Queues a -> a
$ctoList :: forall a. Queues a -> [a]
toList :: forall a. Queues a -> [a]
$cnull :: forall a. Queues a -> Bool
null :: forall a. Queues a -> Bool
$clength :: forall a. Queues a -> Int
length :: forall a. Queues a -> Int
$celem :: forall a. Eq a => a -> Queues a -> Bool
elem :: forall a. Eq a => a -> Queues a -> Bool
$cmaximum :: forall a. Ord a => Queues a -> a
maximum :: forall a. Ord a => Queues a -> a
$cminimum :: forall a. Ord a => Queues a -> a
minimum :: forall a. Ord a => Queues a -> a
$csum :: forall a. Num a => Queues a -> a
sum :: forall a. Num a => Queues a -> a
$cproduct :: forall a. Num a => Queues a -> a
product :: forall a. Num a => Queues a -> a
Foldable, Functor Queues
Foldable Queues
Functor Queues
-> Foldable Queues
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Queues a -> f (Queues b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Queues (f a) -> f (Queues a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Queues a -> m (Queues b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Queues (m a) -> m (Queues a))
-> Traversable Queues
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Queues (m a) -> m (Queues a)
forall (f :: * -> *) a.
Applicative f =>
Queues (f a) -> f (Queues a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Queues a -> m (Queues b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Queues a -> f (Queues b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Queues a -> f (Queues b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Queues a -> f (Queues b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Queues (f a) -> f (Queues a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Queues (f a) -> f (Queues a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Queues a -> m (Queues b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Queues a -> m (Queues b)
$csequence :: forall (m :: * -> *) a. Monad m => Queues (m a) -> m (Queues a)
sequence :: forall (m :: * -> *) a. Monad m => Queues (m a) -> m (Queues a)
Traversable)

data PhysicalDeviceInfo = PhysicalDeviceInfo
  { PhysicalDeviceInfo -> Word64
pdiTotalMemory      :: Word64
  , PhysicalDeviceInfo -> Vector (DeviceQueueCreateInfo '[])
pdiQueueCreateInfos :: Vector (Vk.DeviceQueueCreateInfo '[])
  , PhysicalDeviceInfo -> Text
pdiName             :: Text
  , PhysicalDeviceInfo -> PhysicalDeviceProperties
pdiProperties       :: Vk.PhysicalDeviceProperties
  , PhysicalDeviceInfo
-> Device -> IO (Queues (QueueFamilyIndex, Queue))
pdiGetQueues        :: Vk.Device -> IO (Queues (QueueFamilyIndex, Vk.Queue))
  }

class HasSwapchain a where
  getSurfaceExtent  :: a -> Vk.Extent2D
  getSurfaceFormat  :: a -> Vk.Format
  getDepthFormat    :: a -> Vk.Format
  getMultisample    :: a -> Vk.SampleCountFlagBits
  getAnisotropy     :: a -> "max sampler anisotropy" ::: Float
  getSwapchainViews :: a -> Vector Vk.ImageView
  getMinImageCount  :: a -> Word32
  getImageCount     :: a -> Word32

-- TODO: extract to a module
class HasRenderPass a where
  getFramebuffers        :: a -> Vector Vk.Framebuffer
  getRenderPass          :: a -> Vk.RenderPass
  getClearValues         :: a -> Vector Vk.ClearValue
  getRenderArea          :: a -> Vk.Rect2D

class RenderPass a where
  updateRenderpass
    :: ( HasLogFunc env
       , HasSwapchain swapchain
       , HasVulkan env
       , MonadResource (RIO env)
       )
    => swapchain
    -> a
    -> RIO env a
  updateRenderpass = (a -> RIO env a) -> swapchain -> a -> RIO env a
forall a b. a -> b -> a
const a -> RIO env a
forall a. a -> RIO env a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

  refcountRenderpass
    :: MonadResource (RIO env)
    => a
    -> RIO env ()

type DsLayoutBindings = [(Vk.DescriptorSetLayoutBinding, Vk12.DescriptorBindingFlags)]
type DsLayouts = Vector Vk.DescriptorSetLayout

newtype Bound (dsl :: [Type]) vertices instances m a = Bound (m a)
  deriving stock ((forall m. Monoid m => Bound dsl vertices instances m m -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> Bound dsl vertices instances m a -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> Bound dsl vertices instances m a -> m)
-> (forall a b.
    (a -> b -> b) -> b -> Bound dsl vertices instances m a -> b)
-> (forall a b.
    (a -> b -> b) -> b -> Bound dsl vertices instances m a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> Bound dsl vertices instances m a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> Bound dsl vertices instances m a -> b)
-> (forall a.
    (a -> a -> a) -> Bound dsl vertices instances m a -> a)
-> (forall a.
    (a -> a -> a) -> Bound dsl vertices instances m a -> a)
-> (forall a. Bound dsl vertices instances m a -> [a])
-> (forall a. Bound dsl vertices instances m a -> Bool)
-> (forall a. Bound dsl vertices instances m a -> Int)
-> (forall a.
    Eq a =>
    a -> Bound dsl vertices instances m a -> Bool)
-> (forall a. Ord a => Bound dsl vertices instances m a -> a)
-> (forall a. Ord a => Bound dsl vertices instances m a -> a)
-> (forall a. Num a => Bound dsl vertices instances m a -> a)
-> (forall a. Num a => Bound dsl vertices instances m a -> a)
-> Foldable (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Eq a) =>
a -> Bound dsl vertices instances m a -> Bool
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Num a) =>
Bound dsl vertices instances m a -> a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Ord a) =>
Bound dsl vertices instances m a -> a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) m.
(Foldable m, Monoid m) =>
Bound dsl vertices instances m m -> m
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> Bool
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> Int
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> [a]
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> Bound dsl vertices instances m a -> a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> Bound dsl vertices instances m a -> m
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
forall a. Eq a => a -> Bound dsl vertices instances m a -> Bool
forall a. Num a => Bound dsl vertices instances m a -> a
forall a. Ord a => Bound dsl vertices instances m a -> a
forall m. Monoid m => Bound dsl vertices instances m m -> m
forall a. Bound dsl vertices instances m a -> Bool
forall a. Bound dsl vertices instances m a -> Int
forall a. Bound dsl vertices instances m a -> [a]
forall a. (a -> a -> a) -> Bound dsl vertices instances m a -> a
forall m a.
Monoid m =>
(a -> m) -> Bound dsl vertices instances m a -> m
forall b a.
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
forall a b.
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) m.
(Foldable m, Monoid m) =>
Bound dsl vertices instances m m -> m
fold :: forall m. Monoid m => Bound dsl vertices instances m m -> m
$cfoldMap :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> Bound dsl vertices instances m a -> m
foldMap :: forall m a.
Monoid m =>
(a -> m) -> Bound dsl vertices instances m a -> m
$cfoldMap' :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> Bound dsl vertices instances m a -> m
foldMap' :: forall m a.
Monoid m =>
(a -> m) -> Bound dsl vertices instances m a -> m
$cfoldr :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
foldr :: forall a b.
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
$cfoldr' :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
foldr' :: forall a b.
(a -> b -> b) -> b -> Bound dsl vertices instances m a -> b
$cfoldl :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
foldl :: forall b a.
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
$cfoldl' :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
foldl' :: forall b a.
(b -> a -> b) -> b -> Bound dsl vertices instances m a -> b
$cfoldr1 :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> Bound dsl vertices instances m a -> a
foldr1 :: forall a. (a -> a -> a) -> Bound dsl vertices instances m a -> a
$cfoldl1 :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> Bound dsl vertices instances m a -> a
foldl1 :: forall a. (a -> a -> a) -> Bound dsl vertices instances m a -> a
$ctoList :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> [a]
toList :: forall a. Bound dsl vertices instances m a -> [a]
$cnull :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> Bool
null :: forall a. Bound dsl vertices instances m a -> Bool
$clength :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Foldable m =>
Bound dsl vertices instances m a -> Int
length :: forall a. Bound dsl vertices instances m a -> Int
$celem :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Eq a) =>
a -> Bound dsl vertices instances m a -> Bool
elem :: forall a. Eq a => a -> Bound dsl vertices instances m a -> Bool
$cmaximum :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Ord a) =>
Bound dsl vertices instances m a -> a
maximum :: forall a. Ord a => Bound dsl vertices instances m a -> a
$cminimum :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Ord a) =>
Bound dsl vertices instances m a -> a
minimum :: forall a. Ord a => Bound dsl vertices instances m a -> a
$csum :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Num a) =>
Bound dsl vertices instances m a -> a
sum :: forall a. Num a => Bound dsl vertices instances m a -> a
$cproduct :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
(Foldable m, Num a) =>
Bound dsl vertices instances m a -> a
product :: forall a. Num a => Bound dsl vertices instances m a -> a
Foldable, Functor (Bound dsl vertices instances m)
Foldable (Bound dsl vertices instances m)
Functor (Bound dsl vertices instances m)
-> Foldable (Bound dsl vertices instances m)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b)
    -> Bound dsl vertices instances m a
    -> f (Bound dsl vertices instances m b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Bound dsl vertices instances m (f a)
    -> f (Bound dsl vertices instances m a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b)
    -> Bound dsl vertices instances m a
    -> m (Bound dsl vertices instances m b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Bound dsl vertices instances m (m a)
    -> m (Bound dsl vertices instances m a))
-> Traversable (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
Traversable m =>
Functor (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
Traversable m =>
Foldable (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (m :: * -> *) a.
(Traversable m, Monad m) =>
Bound dsl vertices instances m (m a)
-> m (Bound dsl vertices instances m a)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (f :: * -> *) a.
(Traversable m, Applicative f) =>
Bound dsl vertices instances m (f a)
-> f (Bound dsl vertices instances m a)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (m :: * -> *) a b.
(Traversable m, Monad m) =>
(a -> m b)
-> Bound dsl vertices instances m a
-> m (Bound dsl vertices instances m b)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (f :: * -> *) a b.
(Traversable m, Applicative f) =>
(a -> f b)
-> Bound dsl vertices instances m a
-> f (Bound dsl vertices instances m b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Bound dsl vertices instances m (m a)
-> m (Bound dsl vertices instances m a)
forall (f :: * -> *) a.
Applicative f =>
Bound dsl vertices instances m (f a)
-> f (Bound dsl vertices instances m a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b)
-> Bound dsl vertices instances m a
-> m (Bound dsl vertices instances m b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Bound dsl vertices instances m a
-> f (Bound dsl vertices instances m b)
$ctraverse :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (f :: * -> *) a b.
(Traversable m, Applicative f) =>
(a -> f b)
-> Bound dsl vertices instances m a
-> f (Bound dsl vertices instances m b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Bound dsl vertices instances m a
-> f (Bound dsl vertices instances m b)
$csequenceA :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (f :: * -> *) a.
(Traversable m, Applicative f) =>
Bound dsl vertices instances m (f a)
-> f (Bound dsl vertices instances m a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Bound dsl vertices instances m (f a)
-> f (Bound dsl vertices instances m a)
$cmapM :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (m :: * -> *) a b.
(Traversable m, Monad m) =>
(a -> m b)
-> Bound dsl vertices instances m a
-> m (Bound dsl vertices instances m b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b)
-> Bound dsl vertices instances m a
-> m (Bound dsl vertices instances m b)
$csequence :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) (m :: * -> *) a.
(Traversable m, Monad m) =>
Bound dsl vertices instances m (m a)
-> m (Bound dsl vertices instances m a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Bound dsl vertices instances m (m a)
-> m (Bound dsl vertices instances m a)
Traversable, (forall a b.
 (a -> b)
 -> Bound dsl vertices instances m a
 -> Bound dsl vertices instances m b)
-> (forall a b.
    a
    -> Bound dsl vertices instances m b
    -> Bound dsl vertices instances m a)
-> Functor (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Functor m =>
a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Functor m =>
(a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
forall a b.
a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
forall a b.
(a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances 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 (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Functor m =>
(a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
fmap :: forall a b.
(a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
$c<$ :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Functor m =>
a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
<$ :: forall a b.
a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
Functor)
  deriving newtype (Functor (Bound dsl vertices instances m)
Functor (Bound dsl vertices instances m)
-> (forall a. a -> Bound dsl vertices instances m a)
-> (forall a b.
    Bound dsl vertices instances m (a -> b)
    -> Bound dsl vertices instances m a
    -> Bound dsl vertices instances m b)
-> (forall a b c.
    (a -> b -> c)
    -> Bound dsl vertices instances m a
    -> Bound dsl vertices instances m b
    -> Bound dsl vertices instances m c)
-> (forall a b.
    Bound dsl vertices instances m a
    -> Bound dsl vertices instances m b
    -> Bound dsl vertices instances m b)
-> (forall a b.
    Bound dsl vertices instances m a
    -> Bound dsl vertices instances m b
    -> Bound dsl vertices instances m a)
-> Applicative (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
Applicative m =>
Functor (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Applicative m =>
a -> Bound dsl vertices instances m a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m (a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m c
forall a. a -> Bound dsl vertices instances m a
forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
forall a b.
Bound dsl vertices instances m (a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
forall a b c.
(a -> b -> c)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances 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 (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Applicative m =>
a -> Bound dsl vertices instances m a
pure :: forall a. a -> Bound dsl vertices instances m a
$c<*> :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m (a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
<*> :: forall a b.
Bound dsl vertices instances m (a -> b)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
$cliftA2 :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m c
liftA2 :: forall a b c.
(a -> b -> c)
-> Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m c
$c*> :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
*> :: forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
$c<* :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Applicative m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
<* :: forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m a
Applicative, Applicative (Bound dsl vertices instances m)
Applicative (Bound dsl vertices instances m)
-> (forall a b.
    Bound dsl vertices instances m a
    -> (a -> Bound dsl vertices instances m b)
    -> Bound dsl vertices instances m b)
-> (forall a b.
    Bound dsl vertices instances m a
    -> Bound dsl vertices instances m b
    -> Bound dsl vertices instances m b)
-> (forall a. a -> Bound dsl vertices instances m a)
-> Monad (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
Monad m =>
Applicative (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Monad m =>
a -> Bound dsl vertices instances m a
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Monad m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Monad m =>
Bound dsl vertices instances m a
-> (a -> Bound dsl vertices instances m b)
-> Bound dsl vertices instances m b
forall a. a -> Bound dsl vertices instances m a
forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
forall a b.
Bound dsl vertices instances m a
-> (a -> Bound dsl vertices instances m b)
-> Bound dsl vertices instances 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 (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Monad m =>
Bound dsl vertices instances m a
-> (a -> Bound dsl vertices instances m b)
-> Bound dsl vertices instances m b
>>= :: forall a b.
Bound dsl vertices instances m a
-> (a -> Bound dsl vertices instances m b)
-> Bound dsl vertices instances m b
$c>> :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a b.
Monad m =>
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
>> :: forall a b.
Bound dsl vertices instances m a
-> Bound dsl vertices instances m b
-> Bound dsl vertices instances m b
$creturn :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
Monad m =>
a -> Bound dsl vertices instances m a
return :: forall a. a -> Bound dsl vertices instances m a
Monad, Monad (Bound dsl vertices instances m)
Monad (Bound dsl vertices instances m)
-> (forall a. IO a -> Bound dsl vertices instances m a)
-> MonadIO (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
MonadIO m =>
Monad (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
MonadIO m =>
IO a -> Bound dsl vertices instances m a
forall a. IO a -> Bound dsl vertices instances m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) a.
MonadIO m =>
IO a -> Bound dsl vertices instances m a
liftIO :: forall a. IO a -> Bound dsl vertices instances m a
MonadIO, MonadIO (Bound dsl vertices instances m)
MonadIO (Bound dsl vertices instances m)
-> (forall b.
    ((forall a. Bound dsl vertices instances m a -> IO a) -> IO b)
    -> Bound dsl vertices instances m b)
-> MonadUnliftIO (Bound dsl vertices instances m)
forall {dsl :: [*]} {k} {vertices :: k} {k} {instances :: k}
       {m :: * -> *}.
MonadUnliftIO m =>
MonadIO (Bound dsl vertices instances m)
forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. Bound dsl vertices instances m a -> IO a) -> IO b)
-> Bound dsl vertices instances m b
forall b.
((forall a. Bound dsl vertices instances m a -> IO a) -> IO b)
-> Bound dsl vertices instances m b
forall (m :: * -> *).
MonadIO m
-> (forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
$cwithRunInIO :: forall (dsl :: [*]) k (vertices :: k) k (instances :: k)
       (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. Bound dsl vertices instances m a -> IO a) -> IO b)
-> Bound dsl vertices instances m b
withRunInIO :: forall b.
((forall a. Bound dsl vertices instances m a -> IO a) -> IO b)
-> Bound dsl vertices instances m b
MonadUnliftIO)
  deriving newtype (MonadReader r, MonadState s)