module Data.SpirV.Reflect.Yaml.Parsers where

import Prelude hiding (id)

import Data.Functor ((<&>))
import Data.Text (Text)
import Data.Vector (Vector)
import Data.Vector qualified as Vector
import Data.Vector.Storable qualified as Storable
import Data.YAML ((.:))
import Data.YAML qualified as YAML

import Data.SpirV.Reflect.BlockVariable (BlockVariable)
import Data.SpirV.Reflect.BlockVariable qualified as BlockVariable
import Data.SpirV.Reflect.DescriptorBinding (DescriptorBinding)
import Data.SpirV.Reflect.DescriptorBinding qualified as DescriptorBinding
import Data.SpirV.Reflect.DescriptorSet (DescriptorSet)
import Data.SpirV.Reflect.DescriptorSet qualified as DescriptorSet
import Data.SpirV.Reflect.Enums qualified as Enums
import Data.SpirV.Reflect.InterfaceVariable (InterfaceVariable)
import Data.SpirV.Reflect.InterfaceVariable qualified as InterfaceVariable
import Data.SpirV.Reflect.Module (Module)
import Data.SpirV.Reflect.Module qualified as Module
import Data.SpirV.Reflect.Traits qualified as Traits
import Data.SpirV.Reflect.TypeDescription (TypeDescription)
import Data.SpirV.Reflect.TypeDescription qualified as TypeDescription

rootP :: NodeParser Module
rootP :: NodeParser Module
rootP = String -> (Mapping Pos -> Parser Module) -> NodeParser Module
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Root" \Mapping Pos
m ->
  -- XXX: Discarding all_XXX fields, assuming they got unrolled by YAML decoder.
  Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"module" Parser (Node Pos) -> NodeParser Module -> Parser Module
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser Module
moduleP

moduleP :: NodeParser Module
moduleP :: NodeParser Module
moduleP = String -> (Mapping Pos -> Parser Module) -> NodeParser Module
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Module" \Mapping Pos
m -> do
  Generator
generator               <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"generator" Parser Int -> (Int -> Generator) -> Parser Generator
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> Generator
Enums.Generator
  Text
entry_point_name        <- Mapping Pos
m Mapping Pos -> Text -> Parser Text
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"entry_point_name"
  Int
entry_point_id          <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"entry_point_id"
  Int
source_language         <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"source_language"
  Int
source_language_version <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"source_language_version"
  Int
spirv_execution_model   <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"spirv_execution_model"
  Int
shader_stage            <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"shader_stage"
  Vector DescriptorBinding
descriptor_bindings     <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"descriptor_bindings" Parser (Maybe (Node Pos))
-> NodeParser DescriptorBinding
-> Parser (Vector DescriptorBinding)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorBinding
descriptorBindingP
  Vector DescriptorSet
descriptor_sets         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"descriptor_sets" Parser (Maybe (Node Pos))
-> NodeParser DescriptorSet -> Parser (Vector DescriptorSet)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorSet
descriptorSetP
  Vector InterfaceVariable
input_variables         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"input_variables" Parser (Maybe (Node Pos))
-> NodeParser InterfaceVariable
-> Parser (Vector InterfaceVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser InterfaceVariable
interfaceVariableP
  Vector InterfaceVariable
output_variables        <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"output_variables" Parser (Maybe (Node Pos))
-> NodeParser InterfaceVariable
-> Parser (Vector InterfaceVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser InterfaceVariable
interfaceVariableP
  Vector BlockVariable
push_constants          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"push_constants" Parser (Maybe (Node Pos))
-> NodeParser BlockVariable -> Parser (Vector BlockVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser BlockVariable
blockVariableP
  pure Module :: Generator
-> Text
-> Int
-> Int
-> Int
-> Int
-> Int
-> Vector DescriptorBinding
-> Vector DescriptorSet
-> Vector InterfaceVariable
-> Vector InterfaceVariable
-> Vector BlockVariable
-> Module
Module.Module{Int
Text
Generator
Vector DescriptorSet
Vector DescriptorBinding
Vector BlockVariable
Vector InterfaceVariable
$sel:generator:Module :: Generator
$sel:entry_point_name:Module :: Text
$sel:entry_point_id:Module :: Int
$sel:source_language:Module :: Int
$sel:source_language_version:Module :: Int
$sel:spirv_execution_model:Module :: Int
$sel:shader_stage:Module :: Int
$sel:descriptor_bindings:Module :: Vector DescriptorBinding
$sel:descriptor_sets:Module :: Vector DescriptorSet
$sel:input_variables:Module :: Vector InterfaceVariable
$sel:output_variables:Module :: Vector InterfaceVariable
$sel:push_constants:Module :: Vector BlockVariable
push_constants :: Vector BlockVariable
output_variables :: Vector InterfaceVariable
input_variables :: Vector InterfaceVariable
descriptor_sets :: Vector DescriptorSet
descriptor_bindings :: Vector DescriptorBinding
shader_stage :: Int
spirv_execution_model :: Int
source_language_version :: Int
source_language :: Int
entry_point_id :: Int
entry_point_name :: Text
generator :: Generator
..}

descriptorBindingP :: NodeParser DescriptorBinding
descriptorBindingP :: NodeParser DescriptorBinding
descriptorBindingP = String
-> (Mapping Pos -> Parser DescriptorBinding)
-> NodeParser DescriptorBinding
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorBinding" \Mapping Pos
m -> do
  Maybe Word32
spirv_id               <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Text
name                   <- Mapping Pos
m Mapping Pos -> Text -> Parser Text
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"name"
  Word32
binding                <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"binding"
  Word32
input_attachment_index <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"input_attachment_index"
  Word32
set                    <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  DescriptorType
descriptor_type        <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"descriptor_type" Parser Int -> (Int -> DescriptorType) -> Parser DescriptorType
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> DescriptorType
Enums.DescriptorType
  ResourceFlagBits
resource_type          <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"resource_type" Parser Word32
-> (Word32 -> ResourceFlagBits) -> Parser ResourceFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> ResourceFlagBits
Enums.ResourceFlagBits
  Image
image                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image" Parser (Node Pos) -> (Node Pos -> Parser Image) -> Parser Image
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Image
traitsImageP
  BlockVariable
block                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"block" Parser (Node Pos)
-> NodeParser BlockVariable -> Parser BlockVariable
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser BlockVariable
blockVariableP
  Array
array                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Maybe Word32
count                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"count"
  Word32
accessed               <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"accessed"
  Word32
uav_counter_id         <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"uav_counter_id"
  Maybe DescriptorBinding
uav_counter_binding    <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"uav_counter_binding" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe DescriptorBinding))
-> Parser (Maybe DescriptorBinding)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser DescriptorBinding
-> Maybe (Node Pos) -> Parser (Maybe DescriptorBinding)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse NodeParser DescriptorBinding
descriptorBindingP
  Maybe TypeDescription
type_description       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  WordOffset
word_offset            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"word_offset" Parser (Node Pos)
-> (Node Pos -> Parser WordOffset) -> Parser WordOffset
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser WordOffset
descriptorBindingWordOffsetP
  DecorationFlagBits
decoration_flags       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"decoration_flags" Parser (Maybe Word32)
-> (Maybe Word32 -> DecorationFlagBits)
-> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> DecorationFlagBits
-> (Word32 -> DecorationFlagBits)
-> Maybe Word32
-> DecorationFlagBits
forall b a. b -> (a -> b) -> Maybe a -> b
maybe DecorationFlagBits
Enums.DECORATION_NONE Word32 -> DecorationFlagBits
Enums.DecorationFlagBits
  pure DescriptorBinding :: Maybe Word32
-> Text
-> Word32
-> Word32
-> Word32
-> DescriptorType
-> ResourceFlagBits
-> Image
-> BlockVariable
-> Array
-> Maybe Word32
-> Word32
-> Word32
-> Maybe DescriptorBinding
-> Maybe TypeDescription
-> WordOffset
-> DecorationFlagBits
-> DescriptorBinding
DescriptorBinding.DescriptorBinding{Maybe Word32
Maybe DescriptorBinding
Maybe TypeDescription
Word32
Text
WordOffset
BlockVariable
Array
Image
ResourceFlagBits
DescriptorType
DecorationFlagBits
$sel:spirv_id:DescriptorBinding :: Maybe Word32
$sel:name:DescriptorBinding :: Text
$sel:binding:DescriptorBinding :: Word32
$sel:input_attachment_index:DescriptorBinding :: Word32
$sel:set:DescriptorBinding :: Word32
$sel:descriptor_type:DescriptorBinding :: DescriptorType
$sel:resource_type:DescriptorBinding :: ResourceFlagBits
$sel:image:DescriptorBinding :: Image
$sel:block:DescriptorBinding :: BlockVariable
$sel:array:DescriptorBinding :: Array
$sel:count:DescriptorBinding :: Maybe Word32
$sel:accessed:DescriptorBinding :: Word32
$sel:uav_counter_id:DescriptorBinding :: Word32
$sel:uav_counter_binding:DescriptorBinding :: Maybe DescriptorBinding
$sel:type_description:DescriptorBinding :: Maybe TypeDescription
$sel:word_offset:DescriptorBinding :: WordOffset
$sel:decoration_flags:DescriptorBinding :: DecorationFlagBits
decoration_flags :: DecorationFlagBits
word_offset :: WordOffset
type_description :: Maybe TypeDescription
uav_counter_binding :: Maybe DescriptorBinding
uav_counter_id :: Word32
accessed :: Word32
count :: Maybe Word32
array :: Array
block :: BlockVariable
image :: Image
resource_type :: ResourceFlagBits
descriptor_type :: DescriptorType
set :: Word32
input_attachment_index :: Word32
binding :: Word32
name :: Text
spirv_id :: Maybe Word32
..}

descriptorBindingWordOffsetP :: NodeParser DescriptorBinding.WordOffset
descriptorBindingWordOffsetP :: Node Pos -> Parser WordOffset
descriptorBindingWordOffsetP = String
-> (Mapping Pos -> Parser WordOffset)
-> Node Pos
-> Parser WordOffset
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorBinding.WordOffset" \Mapping Pos
m -> do
  Word32
binding <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"binding"
  Word32
set     <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  pure WordOffset :: Word32 -> Word32 -> WordOffset
DescriptorBinding.WordOffset{Word32
$sel:binding:WordOffset :: Word32
$sel:set:WordOffset :: Word32
set :: Word32
binding :: Word32
..}

typeDescriptionP :: NodeParser TypeDescription
typeDescriptionP :: Node Pos -> Parser TypeDescription
typeDescriptionP = String
-> (Mapping Pos -> Parser TypeDescription)
-> Node Pos
-> Parser TypeDescription
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"TypeDescription" \Mapping Pos
m -> do
  Maybe Word32
id                 <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"id"
  Maybe Op
op                 <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Int32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"op" Parser (Maybe Int32)
-> (Maybe Int32 -> Maybe Op) -> Parser (Maybe Op)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Int32 -> Op) -> Maybe Int32 -> Maybe Op
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> Op
Enums.Op
  Maybe Text
type_name          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_name"
  Maybe Text
struct_member_name <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"struct_member_name"
  StorageClass
storage_class      <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"storage_class" Parser Int32 -> (Int32 -> StorageClass) -> Parser StorageClass
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> StorageClass
Enums.StorageClass
  TypeFlagBits
type_flags         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_flags" Parser (Maybe Word32)
-> (Maybe Word32 -> TypeFlagBits) -> Parser TypeFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> TypeFlagBits
-> (Word32 -> TypeFlagBits) -> Maybe Word32 -> TypeFlagBits
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TypeFlagBits
Enums.TYPE_FLAG_UNDEFINED Word32 -> TypeFlagBits
Enums.TypeFlagBits
  Maybe Traits
traits             <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"traits" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe Traits))
-> Parser (Maybe Traits)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser Traits)
-> Maybe (Node Pos) -> Parser (Maybe Traits)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Node Pos -> Parser Traits
typeDescriptionTraitsP
  Vector TypeDescription
members            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> (Node Pos -> Parser TypeDescription)
-> Parser (Vector TypeDescription)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` Node Pos -> Parser TypeDescription
typeDescriptionP
  pure TypeDescription :: Maybe Word32
-> Maybe Op
-> Maybe Text
-> Maybe Text
-> StorageClass
-> TypeFlagBits
-> Maybe Traits
-> Vector TypeDescription
-> TypeDescription
TypeDescription.TypeDescription{Maybe Word32
Maybe Text
Maybe Traits
Maybe Op
TypeFlagBits
StorageClass
Vector TypeDescription
$sel:id:TypeDescription :: Maybe Word32
$sel:op:TypeDescription :: Maybe Op
$sel:type_name:TypeDescription :: Maybe Text
$sel:struct_member_name:TypeDescription :: Maybe Text
$sel:storage_class:TypeDescription :: StorageClass
$sel:type_flags:TypeDescription :: TypeFlagBits
$sel:traits:TypeDescription :: Maybe Traits
$sel:members:TypeDescription :: Vector TypeDescription
members :: Vector TypeDescription
traits :: Maybe Traits
type_flags :: TypeFlagBits
storage_class :: StorageClass
struct_member_name :: Maybe Text
type_name :: Maybe Text
op :: Maybe Op
id :: Maybe Word32
..}

typeDescriptionTraitsP :: NodeParser TypeDescription.Traits
typeDescriptionTraitsP :: Node Pos -> Parser Traits
typeDescriptionTraitsP = String
-> (Mapping Pos -> Parser Traits) -> Node Pos -> Parser Traits
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"TypeDescription.Traits" \Mapping Pos
m -> do
  Numeric
numeric <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Image
image   <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image" Parser (Node Pos) -> (Node Pos -> Parser Image) -> Parser Image
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Image
traitsImageP
  Array
array   <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  pure Traits :: Numeric -> Image -> Array -> Traits
TypeDescription.Traits{Numeric
Array
Image
$sel:numeric:Traits :: Numeric
$sel:image:Traits :: Image
$sel:array:Traits :: Array
array :: Array
image :: Image
numeric :: Numeric
..}

descriptorSetP :: NodeParser DescriptorSet
descriptorSetP :: NodeParser DescriptorSet
descriptorSetP = String
-> (Mapping Pos -> Parser DescriptorSet)
-> NodeParser DescriptorSet
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorSet" \Mapping Pos
m -> do
  Word32
set <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  Vector DescriptorBinding
bindings <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"bindings" Parser (Maybe (Node Pos))
-> NodeParser DescriptorBinding
-> Parser (Vector DescriptorBinding)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorBinding
descriptorBindingP
  pure DescriptorSet :: Word32 -> Vector DescriptorBinding -> DescriptorSet
DescriptorSet.DescriptorSet{Word32
Vector DescriptorBinding
$sel:set:DescriptorSet :: Word32
$sel:bindings:DescriptorSet :: Vector DescriptorBinding
bindings :: Vector DescriptorBinding
set :: Word32
..}

interfaceVariableP :: NodeParser InterfaceVariable
interfaceVariableP :: NodeParser InterfaceVariable
interfaceVariableP = String
-> (Mapping Pos -> Parser InterfaceVariable)
-> NodeParser InterfaceVariable
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"InterfaceVariable" \Mapping Pos
m -> do
  Maybe Word32
spirv_id         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Maybe Text
name             <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"name"
  Word32
location         <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"location"
  StorageClass
storage_class    <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"storage_class" Parser Int32 -> (Int32 -> StorageClass) -> Parser StorageClass
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> StorageClass
Enums.StorageClass
  Maybe Text
semantic         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"semantic"
  DecorationFlagBits
decoration_flags <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"decoration_flags" Parser Word32
-> (Word32 -> DecorationFlagBits) -> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> DecorationFlagBits
Enums.DecorationFlagBits
  BuiltIn
built_in         <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"built_in" Parser Int32 -> (Int32 -> BuiltIn) -> Parser BuiltIn
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> BuiltIn
Enums.BuiltIn
  Numeric
numeric          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Array
array            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Vector TypeDescription
members          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> (Node Pos -> Parser TypeDescription)
-> Parser (Vector TypeDescription)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` Node Pos -> Parser TypeDescription
typeDescriptionP
  Format
format           <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"format" Parser Int -> (Int -> Format) -> Parser Format
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> Format
Enums.Format
  Maybe TypeDescription
type_description <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  WordOffset
word_offset      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"word_offset" Parser (Node Pos)
-> (Node Pos -> Parser WordOffset) -> Parser WordOffset
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser WordOffset
interfaceVariableWordOffsetP
  pure InterfaceVariable :: Maybe Word32
-> Maybe Text
-> Word32
-> StorageClass
-> Maybe Text
-> DecorationFlagBits
-> BuiltIn
-> Numeric
-> Array
-> Vector TypeDescription
-> Format
-> Maybe TypeDescription
-> WordOffset
-> InterfaceVariable
InterfaceVariable.InterfaceVariable{Maybe Word32
Maybe Text
Maybe TypeDescription
Word32
WordOffset
Numeric
Array
StorageClass
BuiltIn
Format
DecorationFlagBits
Vector TypeDescription
$sel:spirv_id:InterfaceVariable :: Maybe Word32
$sel:name:InterfaceVariable :: Maybe Text
$sel:location:InterfaceVariable :: Word32
$sel:storage_class:InterfaceVariable :: StorageClass
$sel:semantic:InterfaceVariable :: Maybe Text
$sel:decoration_flags:InterfaceVariable :: DecorationFlagBits
$sel:built_in:InterfaceVariable :: BuiltIn
$sel:numeric:InterfaceVariable :: Numeric
$sel:array:InterfaceVariable :: Array
$sel:members:InterfaceVariable :: Vector TypeDescription
$sel:format:InterfaceVariable :: Format
$sel:type_description:InterfaceVariable :: Maybe TypeDescription
$sel:word_offset:InterfaceVariable :: WordOffset
word_offset :: WordOffset
type_description :: Maybe TypeDescription
format :: Format
members :: Vector TypeDescription
array :: Array
numeric :: Numeric
built_in :: BuiltIn
decoration_flags :: DecorationFlagBits
semantic :: Maybe Text
storage_class :: StorageClass
location :: Word32
name :: Maybe Text
spirv_id :: Maybe Word32
..}

interfaceVariableWordOffsetP :: NodeParser InterfaceVariable.WordOffset
interfaceVariableWordOffsetP :: Node Pos -> Parser WordOffset
interfaceVariableWordOffsetP = String
-> (Mapping Pos -> Parser WordOffset)
-> Node Pos
-> Parser WordOffset
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"InterfaceVariable.WordOffset" \Mapping Pos
m -> do
  Word32
location <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"location"
  pure WordOffset :: Word32 -> WordOffset
InterfaceVariable.WordOffset{Word32
$sel:location:WordOffset :: Word32
location :: Word32
..}

blockVariableP :: NodeParser BlockVariable
blockVariableP :: NodeParser BlockVariable
blockVariableP = String
-> (Mapping Pos -> Parser BlockVariable)
-> NodeParser BlockVariable
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"BlockVariable" \Mapping Pos
m -> do
  Maybe Word32
spirv_id         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Maybe Text
name             <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"name"
  Word32
offset           <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"offset"
  Word32
absolute_offset  <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"absolute_offset"
  Word32
size             <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"size"
  Word32
padded_size      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"padded_size"
  DecorationFlagBits
decorations      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"decorations" Parser Word32
-> (Word32 -> DecorationFlagBits) -> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> DecorationFlagBits
Enums.DecorationFlagBits
  Numeric
numeric          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Array
array            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Vector BlockVariable
members          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> NodeParser BlockVariable -> Parser (Vector BlockVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser BlockVariable
blockVariableP
  Maybe TypeDescription
type_description <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  pure BlockVariable :: Maybe Word32
-> Maybe Text
-> Word32
-> Word32
-> Word32
-> Word32
-> DecorationFlagBits
-> Numeric
-> Array
-> Vector BlockVariable
-> Maybe TypeDescription
-> BlockVariable
BlockVariable.BlockVariable{Maybe Word32
Maybe Text
Maybe TypeDescription
Word32
Numeric
Array
DecorationFlagBits
Vector BlockVariable
$sel:spirv_id:BlockVariable :: Maybe Word32
$sel:name:BlockVariable :: Maybe Text
$sel:offset:BlockVariable :: Word32
$sel:absolute_offset:BlockVariable :: Word32
$sel:size:BlockVariable :: Word32
$sel:padded_size:BlockVariable :: Word32
$sel:decorations:BlockVariable :: DecorationFlagBits
$sel:numeric:BlockVariable :: Numeric
$sel:array:BlockVariable :: Array
$sel:members:BlockVariable :: Vector BlockVariable
$sel:type_description:BlockVariable :: Maybe TypeDescription
type_description :: Maybe TypeDescription
members :: Vector BlockVariable
array :: Array
numeric :: Numeric
decorations :: DecorationFlagBits
padded_size :: Word32
size :: Word32
absolute_offset :: Word32
offset :: Word32
name :: Maybe Text
spirv_id :: Maybe Word32
..}

--------------

traitsNumericP :: NodeParser Traits.Numeric
traitsNumericP :: Node Pos -> Parser Numeric
traitsNumericP = String
-> (Mapping Pos -> Parser Numeric) -> Node Pos -> Parser Numeric
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Numeric" \Mapping Pos
m -> do
  Scalar
scalar <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"scalar" Parser (Node Pos) -> (Node Pos -> Parser Scalar) -> Parser Scalar
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Scalar
traitsScalarP
  Vector
vector <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"vector" Parser (Node Pos) -> (Node Pos -> Parser Vector) -> Parser Vector
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Vector
traitsVectorP
  Matrix
matrix <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"matrix" Parser (Node Pos) -> (Node Pos -> Parser Matrix) -> Parser Matrix
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Matrix
traitsMatrixP
  pure Numeric :: Scalar -> Vector -> Matrix -> Numeric
Traits.Numeric{Scalar
Vector
Matrix
$sel:scalar:Numeric :: Scalar
$sel:vector:Numeric :: Vector
$sel:matrix:Numeric :: Matrix
matrix :: Matrix
vector :: Vector
scalar :: Scalar
..}

traitsScalarP :: NodeParser Traits.Scalar
traitsScalarP :: Node Pos -> Parser Scalar
traitsScalarP = String
-> (Mapping Pos -> Parser Scalar) -> Node Pos -> Parser Scalar
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Scalar" \Mapping Pos
m -> do
  Word32
width      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"width"
  Word32
signedness <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"signedness"
  pure Scalar :: Word32 -> Word32 -> Scalar
Traits.Scalar{Word32
$sel:width:Scalar :: Word32
$sel:signedness:Scalar :: Word32
signedness :: Word32
width :: Word32
..}

traitsVectorP :: NodeParser Traits.Vector
traitsVectorP :: Node Pos -> Parser Vector
traitsVectorP = String
-> (Mapping Pos -> Parser Vector) -> Node Pos -> Parser Vector
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Vector" \Mapping Pos
m -> do
  Word32
component_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"component_count"
  pure Vector :: Word32 -> Vector
Traits.Vector{Word32
$sel:component_count:Vector :: Word32
component_count :: Word32
..}

traitsMatrixP :: NodeParser Traits.Matrix
traitsMatrixP :: Node Pos -> Parser Matrix
traitsMatrixP = String
-> (Mapping Pos -> Parser Matrix) -> Node Pos -> Parser Matrix
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Matrix" \Mapping Pos
m -> do
  Word32
column_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"column_count"
  Word32
row_count    <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"row_count"
  Word32
stride       <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"stride"
  pure Matrix :: Word32 -> Word32 -> Word32 -> Matrix
Traits.Matrix{Word32
$sel:column_count:Matrix :: Word32
$sel:row_count:Matrix :: Word32
$sel:stride:Matrix :: Word32
stride :: Word32
row_count :: Word32
column_count :: Word32
..}

traitsArrayP :: NodeParser Traits.Array
traitsArrayP :: Node Pos -> Parser Array
traitsArrayP = String -> (Mapping Pos -> Parser Array) -> Node Pos -> Parser Array
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Array" \Mapping Pos
m -> do
  Word32
dims_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dims_count"
  Vector Word32
dims       <- Mapping Pos
m Mapping Pos -> Text -> Parser [Word32]
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dims" Parser [Word32]
-> ([Word32] -> Vector Word32) -> Parser (Vector Word32)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> [Word32] -> Vector Word32
forall a. Storable a => [a] -> Vector a
Storable.fromList
  Maybe Word32
stride     <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"stride"
  pure Array :: Word32 -> Vector Word32 -> Maybe Word32 -> Array
Traits.Array{Maybe Word32
Word32
Vector Word32
$sel:dims_count:Array :: Word32
$sel:dims:Array :: Vector Word32
$sel:stride:Array :: Maybe Word32
stride :: Maybe Word32
dims :: Vector Word32
dims_count :: Word32
..}

traitsImageP :: NodeParser Traits.Image
traitsImageP :: Node Pos -> Parser Image
traitsImageP = String -> (Mapping Pos -> Parser Image) -> Node Pos -> Parser Image
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Image" \Mapping Pos
m -> do
  Dim
dim          <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dim" Parser Int32 -> (Int32 -> Dim) -> Parser Dim
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> Dim
Enums.Dim
  Word32
depth        <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"depth"
  Word32
arrayed      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"arrayed"
  Word32
ms           <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"ms"
  Word32
sampled      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"sampled"
  ImageFormat
image_format <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image_format" Parser Int32 -> (Int32 -> ImageFormat) -> Parser ImageFormat
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> ImageFormat
Enums.ImageFormat
  pure Image :: Dim -> Word32 -> Word32 -> Word32 -> Word32 -> ImageFormat -> Image
Traits.Image{Word32
ImageFormat
Dim
$sel:dim:Image :: Dim
$sel:depth:Image :: Word32
$sel:arrayed:Image :: Word32
$sel:ms:Image :: Word32
$sel:sampled:Image :: Word32
$sel:image_format:Image :: ImageFormat
image_format :: ImageFormat
sampled :: Word32
ms :: Word32
arrayed :: Word32
depth :: Word32
dim :: Dim
..}

type NodeParser a =
  YAML.Node YAML.Pos ->
  YAML.Parser a

(.?)
  :: YAML.FromYAML a
  => YAML.Mapping YAML.Pos
  -> Text
  -> YAML.Parser (Maybe a)
Mapping Pos
o .? :: Mapping Pos -> Text -> Parser (Maybe a)
.? Text
v = Mapping Pos
o Mapping Pos -> Text -> Parser (Maybe a)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
YAML..:? Text
v

seqOf
  :: YAML.Parser (Maybe (YAML.Node YAML.Pos))
  -> NodeParser a
  -> YAML.Parser (Vector a)
seqOf :: Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
seqOf Parser (Maybe (Node Pos))
mappingP NodeParser a
nodeP =
  Parser (Maybe (Node Pos))
mappingP Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Vector a)) -> Parser (Vector a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe (Node Pos)
Nothing ->
      Vector a -> Parser (Vector a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
forall a. Monoid a => a
mempty
    Just Node Pos
items ->
      String
-> ([Node Pos] -> Parser (Vector a))
-> Node Pos
-> Parser (Vector a)
forall a.
String -> ([Node Pos] -> Parser a) -> Node Pos -> Parser a
YAML.withSeq String
"seqOf" (NodeParser a -> Vector (Node Pos) -> Parser (Vector a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse NodeParser a
nodeP (Vector (Node Pos) -> Parser (Vector a))
-> ([Node Pos] -> Vector (Node Pos))
-> [Node Pos]
-> Parser (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Node Pos] -> Vector (Node Pos)
forall a. [a] -> Vector a
Vector.fromList) Node Pos
items