add lambdacube-ir haskell lib

34 files changed, 19919 insertions, 0 deletions

diff --git a/ddl/Definitions.hs b/ddl/Definitions.hs
new file mode 100644
index 0000000..9618407
--- /dev/null
+++ b/ddl/Definitions.hs
@@ -0,0 +1,479 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Definitions (modules) where
+
+import Control.Monad.Writer
+import Language
+
+ir = do
+  -- type aliases
+  "StreamName" #= Int
+  "ProgramName" #= Int
+  "TextureName" #= Int
+  "SamplerName" #= Int
+  "UniformName" #= String
+  "SlotName" #= Int
+  "FrameBufferComponent" #= Int
+  "TextureUnit" #= Int
+  "RenderTargetName" #= Int
+  "TextureUnitMapping" #= Map "UniformName" "TextureUnit"
+
+  -- definitions
+  data_ "ArrayValue" $ do
+    const_ "VBoolArray"   [Array Bool]
+    const_ "VIntArray"    [Array Int32]
+    const_ "VWordArray"   [Array Word32]
+    const_ "VFloatArray"  [Array Float]
+
+  -- GPU type value reification, needed for shader codegen
+  data_ "Value" $ do
+    const_ "VBool"  [Bool]
+    const_ "VV2B"   [v2b]
+    const_ "VV3B"   [v3b]
+    const_ "VV4B"   [v4b]
+    const_ "VWord"  [Word32]
+    const_ "VV2U"   [v2u]
+    const_ "VV3U"   [v3u]
+    const_ "VV4U"   [v4u]
+    const_ "VInt"   [Int32]
+    const_ "VV2I"   [v2i]
+    const_ "VV3I"   [v3i]
+    const_ "VV4I"   [v4i]
+    const_ "VFloat" [Float]
+    const_ "VV2F"   [v2f]
+    const_ "VV3F"   [v3f]
+    const_ "VV4F"   [v4f]
+    const_ "VM22F"  [m22]
+    const_ "VM23F"  [m23]
+    const_ "VM24F"  [m24]
+    const_ "VM32F"  [m32]
+    const_ "VM33F"  [m33]
+    const_ "VM34F"  [m34]
+    const_ "VM42F"  [m42]
+    const_ "VM43F"  [m43]
+    const_ "VM44F"  [m44]
+
+  data_ "InputType" $ do
+    enum_ "Bool"
+    enum_ "V2B"
+    enum_ "V3B"
+    enum_ "V4B"
+    enum_ "Word"
+    enum_ "V2U"
+    enum_ "V3U"
+    enum_ "V4U"
+    enum_ "Int"
+    enum_ "V2I"
+    enum_ "V3I"
+    enum_ "V4I"
+    enum_ "Float"
+    enum_ "V2F"
+    enum_ "V3F"
+    enum_ "V4F"
+    enum_ "M22F"
+    enum_ "M23F"
+    enum_ "M24F"
+    enum_ "M32F"
+    enum_ "M33F"
+    enum_ "M34F"
+    enum_ "M42F"
+    enum_ "M43F"
+    enum_ "M44F"
+    -- shadow textures
+    enum_ "STexture1D"
+    enum_ "STexture2D"
+    enum_ "STextureCube"
+    enum_ "STexture1DArray"
+    enum_ "STexture2DArray"
+    enum_ "STexture2DRect"
+    -- float textures
+    enum_ "FTexture1D"
+    enum_ "FTexture2D"
+    enum_ "FTexture3D"
+    enum_ "FTextureCube"
+    enum_ "FTexture1DArray"
+    enum_ "FTexture2DArray"
+    enum_ "FTexture2DMS"
+    enum_ "FTexture2DMSArray"
+    enum_ "FTextureBuffer"
+    enum_ "FTexture2DRect"
+    -- int textures
+    enum_ "ITexture1D"
+    enum_ "ITexture2D"
+    enum_ "ITexture3D"
+    enum_ "ITextureCube"
+    enum_ "ITexture1DArray"
+    enum_ "ITexture2DArray"
+    enum_ "ITexture2DMS"
+    enum_ "ITexture2DMSArray"
+    enum_ "ITextureBuffer"
+    enum_ "ITexture2DRect"
+    -- uint textures
+    enum_ "UTexture1D"
+    enum_ "UTexture2D"
+    enum_ "UTexture3D"
+    enum_ "UTextureCube"
+    enum_ "UTexture1DArray"
+    enum_ "UTexture2DArray"
+    enum_ "UTexture2DMS"
+    enum_ "UTexture2DMSArray"
+    enum_ "UTextureBuffer"
+    enum_ "UTexture2DRect"
+    deriving_ [Haskell] [Eq,Ord]
+
+  data_ "PointSpriteCoordOrigin" $ do
+    enum_ "LowerLeft"
+    enum_ "UpperLeft"
+
+  data_ "PointSize" $ do
+    const_  "PointSize" [Float]
+    enum_   "ProgramPointSize"
+
+  data_ "PolygonOffset" $ do
+    enum_   "NoOffset"
+    const_  "Offset" [Float,Float]
+
+  data_ "FrontFace" $ do
+    enum_ "CCW"
+    enum_ "CW"
+
+  data_ "PolygonMode" $ do
+    const_  "PolygonPoint" ["PointSize"]
+    const_  "PolygonLine"  [Float]
+    enum_   "PolygonFill"
+
+  data_ "ProvokingVertex" $ do
+    enum_ "FirstVertex"
+    enum_ "LastVertex"
+
+  data_ "CullMode" $ do
+    enum_ "CullNone"
+    const_  "CullFront" ["FrontFace"]
+    const_  "CullBack"  ["FrontFace"]
+
+  data_ "ComparisonFunction" $ do
+    enum_ "Never"
+    enum_ "Less"
+    enum_ "Equal"
+    enum_ "Lequal"
+    enum_ "Greater"
+    enum_ "Notequal"
+    enum_ "Gequal"
+    enum_ "Always"
+
+  "DepthFunction" #= "ComparisonFunction"
+
+  data_ "StencilOperation" $ do
+    enum_ "OpZero"
+    enum_ "OpKeep"
+    enum_ "OpReplace"
+    enum_ "OpIncr"
+    enum_ "OpIncrWrap"
+    enum_ "OpDecr"
+    enum_ "OpDecrWrap"
+    enum_ "OpInvert"
+
+  data_ "BlendEquation" $ do
+    enum_ "FuncAdd"
+    enum_ "FuncSubtract"
+    enum_ "FuncReverseSubtract"
+    enum_ "Min"
+    enum_ "Max"
+
+  data_ "BlendingFactor" $ do
+    enum_ "Zero"
+    enum_ "One"
+    enum_ "SrcColor"
+    enum_ "OneMinusSrcColor"
+    enum_ "DstColor"
+    enum_ "OneMinusDstColor"
+    enum_ "SrcAlpha"
+    enum_ "OneMinusSrcAlpha"
+    enum_ "DstAlpha"
+    enum_ "OneMinusDstAlpha"
+    enum_ "ConstantColor"
+    enum_ "OneMinusConstantColor"
+    enum_ "ConstantAlpha"
+    enum_ "OneMinusConstantAlpha"
+    enum_ "SrcAlphaSaturate"
+
+  data_ "LogicOperation" $ do
+    enum_ "Clear"
+    enum_ "And"
+    enum_ "AndReverse"
+    enum_ "Copy"
+    enum_ "AndInverted"
+    enum_ "Noop"
+    enum_ "Xor"
+    enum_ "Or"
+    enum_ "Nor"
+    enum_ "Equiv"
+    enum_ "Invert"
+    enum_ "OrReverse"
+    enum_ "CopyInverted"
+    enum_ "OrInverted"
+    enum_ "Nand"
+    enum_ "Set"
+
+  data_ "StencilOps" $ do
+    constR_ "StencilOps"
+      [ "frontStencilOp"  #:: "StencilOperation" -- Used for front faced triangles and other primitives.
+      , "backStencilOp"   #:: "StencilOperation" -- Used for back faced triangles.
+      ]
+
+  data_ "StencilTest" $ do
+    constR_ "StencilTest"
+      [ "stencilComparision"  #:: "ComparisonFunction" -- The function used to compare the @stencilReference@ and the stencil buffers value with.
+      , "stencilReference"    #:: Int32                -- The value to compare with the stencil buffer's value.
+      , "stencilMask"         #:: Word32               -- A bit mask with ones in each position that should be compared and written to the stencil buffer.
+      ]
+
+  data_ "StencilTests" $ do
+    const_ "StencilTests" ["StencilTest", "StencilTest"]
+
+  -- primitive types
+  data_ "FetchPrimitive" $ do
+    enum_ "Points"
+    enum_ "Lines"
+    enum_ "Triangles"
+    enum_ "LinesAdjacency"
+    enum_ "TrianglesAdjacency"
+    deriving_ [PureScript] [Show,Eq]
+
+  data_ "OutputPrimitive" $ do
+    enum_ "TrianglesOutput"
+    enum_ "LinesOutput"
+    enum_ "PointsOutput"
+
+  data_ "ColorArity" $ do
+    enum_ "Red"
+    enum_ "RG"
+    enum_ "RGB"
+    enum_ "RGBA"
+    deriving_ [PureScript] [Show]
+
+  data_ "Blending" $ do
+    enum_ "NoBlending"
+    const_ "BlendLogicOp"  ["LogicOperation"]
+    constR_ "Blend"
+      [ "colorEqSrc"  #:: "BlendEquation"
+      , "alphaEqSrc"  #:: "BlendEquation"
+      , "colorFSrc"   #:: "BlendingFactor"
+      , "colorFDst"   #:: "BlendingFactor"
+      , "alphaFSrc"   #:: "BlendingFactor"
+      , "alphaFDst"   #:: "BlendingFactor"
+      , "color"       #:: v4f
+      ]
+
+  data_ "RasterContext" $ do
+    const_ "PointCtx"      ["PointSize", Float, "PointSpriteCoordOrigin"]
+    const_ "LineCtx"       [Float, "ProvokingVertex"]
+    const_ "TriangleCtx"   ["CullMode", "PolygonMode", "PolygonOffset", "ProvokingVertex"]
+
+  data_ "FragmentOperation" $ do
+    const_ "DepthOp"       ["DepthFunction", Bool]
+    const_ "StencilOp"     ["StencilTests", "StencilOps", "StencilOps"]
+    const_ "ColorOp"       ["Blending", "Value"]
+
+  data_ "AccumulationContext" $ do
+    constR_ "AccumulationContext"
+      [ "accViewportName" #:: Maybe String
+      , "accOperations"   #:: List "FragmentOperation"
+      ]
+
+  data_ "TextureDataType" $ do
+    const_  "FloatT"        ["ColorArity"]
+    const_  "IntT"          ["ColorArity"]
+    const_  "WordT"         ["ColorArity"]
+    enum_   "ShadowT"
+    deriving_ [PureScript] [Show]
+
+  data_ "TextureType" $ do
+    const_ "Texture1D"      ["TextureDataType", Int]
+    const_ "Texture2D"      ["TextureDataType", Int]
+    const_ "Texture3D"      ["TextureDataType"]
+    const_ "TextureCube"    ["TextureDataType"]
+    const_ "TextureRect"    ["TextureDataType"]
+    const_ "Texture2DMS"    ["TextureDataType", Int, Int, Bool]
+    const_ "TextureBuffer"  ["TextureDataType"]
+
+  data_ "MipMap" $ do
+    const_  "Mip"           [Int,Int] -- Base level, Max level
+    enum_   "NoMip"
+    const_  "AutoMip"       [Int,Int] -- Base level, Max level
+
+  data_ "Filter" $ do
+    enum_ "Nearest"
+    enum_ "Linear"
+    enum_ "NearestMipmapNearest"
+    enum_ "NearestMipmapLinear"
+    enum_ "LinearMipmapNearest"
+    enum_ "LinearMipmapLinear"
+
+  data_ "EdgeMode" $ do
+    enum_ "Repeat"
+    enum_ "MirroredRepeat"
+    enum_ "ClampToEdge"
+    enum_ "ClampToBorder"
+
+  data_ "ImageSemantic" $ do
+    enum_ "Depth"
+    enum_ "Stencil"
+    enum_ "Color"
+    deriving_ [Haskell] [Eq]
+
+  data_ "ImageRef" $ do
+    const_ "TextureImage"  ["TextureName", Int, Maybe Int]  -- Texture name, mip index, array index
+    const_ "Framebuffer"   ["ImageSemantic"]
+
+  data_ "ClearImage" $ do
+    constR_ "ClearImage"
+      [ "imageSemantic" #:: "ImageSemantic"
+      , "clearValue"    #:: "Value"
+      ]
+
+  data_ "Command" $ do
+    const_ "SetRasterContext"          ["RasterContext"]
+    const_ "SetAccumulationContext"    ["AccumulationContext"]
+    const_ "SetRenderTarget"           ["RenderTargetName"]
+    const_ "SetProgram"                ["ProgramName"] --TextureUnitMapping    -- adding texture unit map to set program command seems to be better solution than the current one
+    const_ "SetSamplerUniform"         ["UniformName", "TextureUnit"]             -- hint: currently the texture unit mapping is encoded with this command
+    const_ "SetTexture"                ["TextureUnit", "TextureName"]             -- binds texture to the specified texture unit
+    const_ "SetSampler"                ["TextureUnit", Maybe "SamplerName"]     -- binds sampler to the specified texture unit
+    const_ "RenderSlot"                ["SlotName"]
+    const_ "RenderStream"              ["StreamName"]
+    const_ "ClearRenderTarget"         [Array "ClearImage"]
+    const_ "GenerateMipMap"            ["TextureUnit"]
+    const_ "SaveImage"                 ["FrameBufferComponent", "ImageRef"]                            -- from framebuffer component to texture (image)
+    const_ "LoadImage"                 ["ImageRef", "FrameBufferComponent"]                            -- from texture (image) to framebuffer component
+
+  data_ "SamplerDescriptor" $ do
+    constR_ "SamplerDescriptor"
+      [ "samplerWrapS"          #:: "EdgeMode"
+      , "samplerWrapT"          #:: Maybe "EdgeMode"
+      , "samplerWrapR"          #:: Maybe "EdgeMode"
+      , "samplerMinFilter"      #:: "Filter"
+      , "samplerMagFilter"      #:: "Filter"
+      , "samplerBorderColor"    #:: "Value"
+      , "samplerMinLod"         #:: Maybe Float
+      , "samplerMaxLod"         #:: Maybe Float
+      , "samplerLodBias"        #:: Float
+      , "samplerCompareFunc"    #:: Maybe "ComparisonFunction"
+      ]
+
+  data_ "TextureDescriptor" $ do    -- texture size, type, array, mipmap
+    constR_ "TextureDescriptor"
+      [ "textureType"       #:: "TextureType"
+      , "textureSize"       #:: "Value"
+      , "textureSemantic"   #:: "ImageSemantic"
+      , "textureSampler"    #:: "SamplerDescriptor"
+      , "textureBaseLevel"  #:: Int
+      , "textureMaxLevel"   #:: Int
+      ]
+
+  data_ "Parameter" $ do 
+    constR_ "Parameter"
+      [ "name"  #:: String
+      , "ty"    #:: "InputType"
+      ]
+
+  data_ "Program" $ do   -- AST, input
+    constR_ "Program"
+      [ "programUniforms"   #:: Map "UniformName" "InputType"   -- uniform input (value based uniforms only / no textures)
+      , "programStreams"    #:: Map "UniformName" "Parameter"   -- vertex shader input attribute name -> (slot attribute name, attribute type)
+      , "programInTextures" #:: Map "UniformName" "InputType"   -- all textures (uniform textures and render textures) referenced by the program
+      , "programOutput"     #:: Array "Parameter"
+      , "vertexShader"      #:: String
+      , "geometryShader"    #:: Maybe String
+      , "fragmentShader"    #:: String
+      ]
+
+  data_ "Slot" $ do      -- input, primitive type
+    constR_ "Slot"
+      [ "slotName"      #:: String
+      , "slotStreams"   #:: Map String "InputType"
+      , "slotUniforms"  #:: Map "UniformName" "InputType"
+      , "slotPrimitive" #:: "FetchPrimitive"
+      , "slotPrograms"  #:: Array "ProgramName"
+      ]
+
+  data_ "StreamData" $ do
+    constR_ "StreamData"
+      [ "streamData"      #:: Map String "ArrayValue"
+      , "streamType"      #:: Map String "InputType"
+      , "streamPrimitive" #:: "FetchPrimitive"
+      , "streamPrograms"  #:: Array "ProgramName"
+      ]
+
+  data_ "TargetItem" $ do
+    constR_ "TargetItem"
+      [ "targetSemantic"  #:: "ImageSemantic"
+      , "targetRef"       #:: Maybe "ImageRef"
+      ]
+
+  data_ "RenderTarget" $ do
+    constR_ "RenderTarget"
+      [ "renderTargets" #:: Array "TargetItem" -- render texture or default framebuffer (semantic, render texture for the program output)
+      ]
+
+  data_ "Backend" $ do
+    enum_ "WebGL1"
+    enum_ "OpenGL33"
+
+  data_ "Pipeline" $ do
+    constR_ "Pipeline"
+      [ "backend"       #:: "Backend"
+      , "textures"      #:: Array "TextureDescriptor"
+      , "samplers"      #:: Array "SamplerDescriptor"
+      , "targets"       #:: Array "RenderTarget"
+      , "programs"      #:: Array "Program"
+      , "slots"         #:: Array "Slot"
+      , "streams"       #:: Array "StreamData"
+      , "commands"      #:: Array "Command"
+      ]
+    deriving_ [Haskell] [Show]
+
+mesh = do
+  data_ "MeshAttribute" $ do
+    const_ "A_Float"  [Array Float]
+    const_ "A_V2F"    [Array v2f]
+    const_ "A_V3F"    [Array v3f]
+    const_ "A_V4F"    [Array v4f]
+    const_ "A_M22F"   [Array m22]
+    const_ "A_M33F"   [Array m33]
+    const_ "A_M44F"   [Array m44]
+    const_ "A_Int"    [Array Int32]
+    const_ "A_Word"   [Array Word32]
+
+  data_ "MeshPrimitive" $ do
+    enum_  "P_Points"
+    enum_  "P_TriangleStrip"
+    enum_  "P_Triangles"
+    const_ "P_TriangleStripI" [Array Int32]
+    const_ "P_TrianglesI"     [Array Int32]
+
+  data_ "Mesh" $ do
+    constR_ "Mesh"
+      [ "mAttributes" #:: Map String "MeshAttribute"
+      , "mPrimitive"  #:: "MeshPrimitive"
+      ]
+
+typeInfo = do
+  data_ "TypeInfo" $ do
+    constR_ "TypeInfo"
+      [ "startLine"   #:: Int
+      , "startColumn" #:: Int
+      , "endLine"     #:: Int
+      , "endColumn"   #:: Int
+      , "text"        #:: String
+      ]
+
+  data_ "MyEither" $ do
+    const_ "MyLeft"   ["TypeInfo", Array "TypeInfo"]
+    const_ "MyRight"  ["Pipeline", Array "TypeInfo"]
+
+modules = do
+  module_ "IR" ir
+  module_ "Mesh" mesh
+  module_ "TypeInfo" $ do
+    import_ ["IR"]
+    typeInfo
diff --git a/ddl/Generate.hs b/ddl/Generate.hs
new file mode 100644
index 0000000..5f5c0d0
--- /dev/null
+++ b/ddl/Generate.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE OverloadedStrings, FlexibleInstances #-}
+import qualified Data.Text.Lazy as LText
+import           Text.EDE
+import           Text.EDE.Filters
+
+import           Data.HashMap.Strict          (HashMap)
+import qualified Data.HashMap.Strict          as HashMap
+import           Data.Text                    (Text)
+import qualified Data.Map as Map
+
+import Data.Time.Clock
+import Control.Monad.Writer
+
+import Definitions
+import Language
+
+instance Unquote [Field]
+instance Unquote [Char]
+instance Quote [Char]
+instance Unquote DataDef
+instance Unquote Type
+
+main :: IO ()
+main = do
+  dataSwift <- eitherParseFile "templates/data.swift.ede"
+  dataJava <- eitherParseFile "templates/data.java.ede"
+  dataHpp <- eitherParseFile "templates/data.hpp.ede"
+  dataHpp2 <- eitherParseFile "templates/data.hpp2.ede"
+  dataCpp <- eitherParseFile "templates/data.cpp.ede"
+  dataCs <- eitherParseFile "templates/data.cs.ede"
+  dataHs <- eitherParseFile "templates/data.hs.ede"
+  dataPs <- eitherParseFile "templates/data.purs.ede"
+  let generate (ModuleDef name imports def) = do
+        dt <- getCurrentTime
+        let env = fromPairs
+              [ "dataAndType" .= def
+              , "definitions" .= [a | a@DataDef{} <- def ]
+              , "moduleName"  .= name
+              , "dateTime"    .= dt
+              , "imports"     .= imports
+              ]
+            aliasMap = Map.fromList [(n,t) | TypeAlias n t <- def]
+            mylib :: HashMap Text Term
+            mylib = HashMap.fromList
+                [ "hasFieldNames"   @: hasFieldNames
+                , "parens"          @: parens
+                , "constType"       @: constType
+                , "hsType"          @: hsType aliasMap
+                , "psType"          @: psType aliasMap
+                , "cppType"         @: cppType aliasMap
+                , "csType"          @: csType aliasMap
+                , "javaType"        @: javaType aliasMap
+                , "swiftType"       @: swiftType aliasMap
+                ]
+
+        -- Haskell
+        either error (\x -> writeFile ("out/" ++ name ++ ".hs") $ LText.unpack x) $ dataHs >>= (\t -> eitherRenderWith mylib t env)
+        -- Purescript
+        either error (\x -> writeFile ("out/" ++ name ++ ".purs") $ LText.unpack x) $ dataPs >>= (\t -> eitherRenderWith mylib t env)
+        -- C++
+        either error (\x -> writeFile ("out/" ++ name ++ "2.hpp") $ LText.unpack x) $ dataHpp2 >>= (\t -> eitherRenderWith mylib t env)
+        either error (\x -> writeFile ("out/" ++ name ++ ".hpp") $ LText.unpack x) $ dataHpp >>= (\t -> eitherRenderWith mylib t env)
+        either error (\x -> writeFile ("out/" ++ name ++ ".cpp") $ LText.unpack x) $ dataCpp >>= (\t -> eitherRenderWith mylib t env)
+        {-
+        -- Java
+        either error (\x -> writeFile ("out/" ++ name ++ ".java") $ LText.unpack x) $ dataJava >>= (\t -> eitherRenderWith mylib t env)
+        -- C#
+        either error (\x -> writeFile ("out/" ++ name ++ ".cs") $ LText.unpack x) $ dataCs >>= (\t -> eitherRenderWith mylib t env)
+        -}
+        -- Swift
+        either error (\x -> writeFile ("out/" ++ name ++ ".swift") $ LText.unpack x) $ dataSwift >>= (\t -> eitherRenderWith mylib t env)
+  mapM_ generate $ execWriter modules
diff --git a/ddl/Language.hs b/ddl/Language.hs
new file mode 100644
index 0000000..79c3056
--- /dev/null
+++ b/ddl/Language.hs
@@ -0,0 +1,393 @@
+{-# LANGUAGE RankNTypes, OverloadedStrings, DeriveGeneric, LambdaCase #-}
+module Language where
+
+import GHC.Generics
+import Data.Aeson (ToJSON(..),FromJSON(..))
+import Control.Monad.Writer
+import Data.String
+import Data.List
+import Data.Map (Map)
+import qualified Data.Map as Map
+
+instance IsString Type where
+  fromString a = Data a
+
+data ModuleDef
+  = ModuleDef
+  { moduleName  :: String
+  , imports     :: [String]
+  , definitions :: [DataDef]
+  }
+  deriving (Show,Generic)
+
+data DataDef
+  = DataDef
+  { dataName      :: String
+  , constructors  :: [ConstructorDef]
+  , instances     :: [Instance]
+  }
+  | TypeAlias
+  { aliasName     :: String
+  , aliasType     :: Type
+  }
+  deriving (Show,Generic)
+
+data ConstructorDef
+  = ConstructorDef
+  { name          :: String
+  , fields        :: [Field]
+  }
+  deriving (Show,Generic)
+
+data Field
+  = Field
+  { fieldName :: String
+  , fieldType :: Type
+  }
+  deriving (Show,Generic)
+
+data Instance
+  = Show
+  | Eq
+  | Ord
+  deriving (Show,Generic)
+
+data Target
+  = Haskell
+  | PureScript
+  | Cpp
+  | CSharp
+  deriving (Show,Generic)
+
+data Type
+  = Int
+  | Int32
+  | Word
+  | Word32
+  | Float
+  | Bool
+  | String
+  | V2 Type
+  | V3 Type
+  | V4 Type
+  -- higher order types
+  | Array Type
+  | List Type
+  | Maybe Type
+  | Map Type Type
+  -- user defined
+  | Data String
+  deriving (Show,Generic)
+
+parens :: String -> String
+parens a
+  | 1 == length (words a) = a
+  | otherwise = "(" ++ a ++ ")"
+
+type AliasMap = Map String Type
+
+normalize :: AliasMap -> Type -> Type
+normalize aliasMap t@(Data n) = Map.findWithDefault t n aliasMap
+normalize _ t = t
+
+psType :: AliasMap -> Type -> String
+psType aliasMap = \case
+  Int     -> "Int"
+  Int32   -> "Int32"
+  Word    -> "Word"
+  Word32  -> "Word32"
+  Float   -> "Float"
+  Bool    -> "Bool"
+  String  -> "String"
+
+  V2 Int        -> "V2I"
+  V2 Word       -> "V2U"
+  V2 Float      -> "V2F"
+  V2 Bool       -> "V2B"
+  V2 (V2 Float) -> "M22F"
+  V2 (V3 Float) -> "M32F"
+  V2 (V4 Float) -> "M42F"
+
+  V3 Int        -> "V3I"
+  V3 Word       -> "V3U"
+  V3 Float      -> "V3F"
+  V3 Bool       -> "V3B"
+  V3 (V2 Float) -> "M23F"
+  V3 (V3 Float) -> "M33F"
+  V3 (V4 Float) -> "M43F"
+
+  V4 Int        -> "V4I"
+  V4 Word       -> "V4U"
+  V4 Float      -> "V4F"
+  V4 Bool       -> "V4B"
+  V4 (V2 Float) -> "M24F"
+  V4 (V3 Float) -> "M34F"
+  V4 (V4 Float) -> "M44F"
+
+  Array t       -> "Array " ++ parens (psType aliasMap t)
+  List t        -> "List " ++ parens (psType aliasMap t)
+  Maybe t       -> "Maybe " ++ parens (psType aliasMap t)
+  Map k v
+    | String <- normalize aliasMap k -> "StrMap " ++ parens (psType aliasMap v)
+    | otherwise -> "Map " ++ parens (psType aliasMap k) ++ " " ++ parens (psType aliasMap v)
+  -- user defined
+  Data t        -> t
+  x -> error $ "unknown type: " ++ show x
+
+hsType :: AliasMap -> Type -> String
+hsType aliasMap = \case
+  Int     -> "Int"
+  Int32   -> "Int32"
+  Word    -> "Word"
+  Word32  -> "Word32"
+  Float   -> "Float"
+  Bool    -> "Bool"
+  String  -> "String"
+
+  V2 Int        -> "V2I"
+  V2 Word       -> "V2U"
+  V2 Float      -> "V2F"
+  V2 Bool       -> "V2B"
+  V2 (V2 Float) -> "M22F"
+  V2 (V3 Float) -> "M32F"
+  V2 (V4 Float) -> "M42F"
+
+  V3 Int        -> "V3I"
+  V3 Word       -> "V3U"
+  V3 Float      -> "V3F"
+  V3 Bool       -> "V3B"
+  V3 (V2 Float) -> "M23F"
+  V3 (V3 Float) -> "M33F"
+  V3 (V4 Float) -> "M43F"
+
+  V4 Int        -> "V4I"
+  V4 Word       -> "V4U"
+  V4 Float      -> "V4F"
+  V4 Bool       -> "V4B"
+  V4 (V2 Float) -> "M24F"
+  V4 (V3 Float) -> "M34F"
+  V4 (V4 Float) -> "M44F"
+
+  Array t       -> "Vector " ++ parens (hsType aliasMap t)
+  List t        -> "[" ++ hsType aliasMap t ++ "]"
+  Maybe t       -> "Maybe " ++ parens (hsType aliasMap t)
+  Map k v       -> "Map " ++ parens (hsType aliasMap k) ++ " " ++ parens (hsType aliasMap v)
+  -- user defined
+  Data t        -> t
+  x -> error $ "unknown type: " ++ show x
+
+swiftType :: AliasMap -> Type -> String
+swiftType aliasMap = \case
+  Int     -> "Int"
+  Int32   -> "Int32"
+  Word    -> "UInt"
+  Word32  -> "UInt32"
+  Float   -> "Float"
+  Bool    -> "Bool"
+  String  -> "String"
+{-
+  V2 Int        -> "V2I"
+  V2 Word       -> "V2U"
+  V2 Float      -> "V2F"
+  V2 Bool       -> "V2B"
+  V2 (V2 Float) -> "M22F"
+  V2 (V3 Float) -> "M32F"
+  V2 (V4 Float) -> "M42F"
+
+  V3 Int        -> "V3I"
+  V3 Word       -> "V3U"
+  V3 Float      -> "V3F"
+  V3 Bool       -> "V3B"
+  V3 (V2 Float) -> "M23F"
+  V3 (V3 Float) -> "M33F"
+  V3 (V4 Float) -> "M43F"
+
+  V4 Int        -> "V4I"
+  V4 Word       -> "V4U"
+  V4 Float      -> "V4F"
+  V4 Bool       -> "V4B"
+  V4 (V2 Float) -> "M24F"
+  V4 (V3 Float) -> "M34F"
+  V4 (V4 Float) -> "M44F"
+-}
+  Array t       -> "Array<" ++ swiftType aliasMap t ++ ">"
+  List t        -> "Array<" ++ swiftType aliasMap t ++ ">"
+  Maybe t       -> "Maybe<" ++ swiftType aliasMap t ++ ">"
+  Map k v       -> "Dictionary<" ++ swiftType aliasMap k ++ ", " ++ swiftType aliasMap v ++ ">"
+  -- user defined
+  Data t        -> t
+  _ -> "Int"
+  x -> error $ "unknown type: " ++ show x
+
+javaType :: AliasMap -> Type -> String -- TODO
+javaType aliasMap a = case normalize aliasMap a of
+  Data t        -> t
+  Int           -> "int"
+  Int32         -> "int"
+  Word          -> "int"
+  Word32        -> "int"
+  Float         -> "float"
+  Bool          -> "boolean"
+  String        -> "String"
+  Array t       -> "ArrayList<" ++ javaType aliasMap t ++ ">"
+  List t        -> "ArrayList<" ++ javaType aliasMap t ++ ">"
+  Map k v       -> "HashMap<" ++ javaType aliasMap k ++ ", " ++ javaType aliasMap v ++ ">"
+  _ -> "int"
+
+csType :: AliasMap -> Type -> String -- TODO
+csType aliasMap a = case normalize aliasMap a of
+  Data t        -> t
+  Int           -> "int"
+  Int32         -> "int"
+  Word          -> "uint"
+  Word32        -> "uint"
+  Float         -> "float"
+  Bool          -> "bool"
+  String        -> "string"
+  Array t       -> "List<" ++ csType aliasMap t ++ ">"
+  List t        -> "List<" ++ csType aliasMap t ++ ">"
+  Map k v       -> "Dictionary<" ++ csType aliasMap k ++ ", " ++ csType aliasMap v ++ ">"
+  _ -> "int"
+
+cppType :: AliasMap -> Type -> String
+cppType aliasMap = \case
+  Int           -> "Int"
+  Int32         -> "Int32"
+  Word          -> "Word"
+  Word32        -> "Word32"
+  Float         -> "Float"
+  Bool          -> "Bool"
+  String        -> "String"
+
+  V2 Int        -> "V2I"
+  V2 Word       -> "V2U"
+  V2 Float      -> "V2F"
+  V2 Bool       -> "V2B"
+  V2 (V2 Float) -> "M22F"
+  V2 (V3 Float) -> "M32F"
+  V2 (V4 Float) -> "M42F"
+
+  V3 Int        -> "V3I"
+  V3 Word       -> "V3U"
+  V3 Float      -> "V3F"
+  V3 Bool       -> "V3B"
+  V3 (V2 Float) -> "M23F"
+  V3 (V3 Float) -> "M33F"
+  V3 (V4 Float) -> "M43F"
+
+  V4 Int        -> "V4I"
+  V4 Word       -> "V4U"
+  V4 Float      -> "V4F"
+  V4 Bool       -> "V4B"
+  V4 (V2 Float) -> "M24F"
+  V4 (V3 Float) -> "M34F"
+  V4 (V4 Float) -> "M44F"
+
+  Array t       -> "std::vector<" ++ cppType aliasMap t ++ ">"
+  List t        -> "std::vector<" ++ cppType aliasMap t ++ ">"
+  Maybe t       -> "Maybe<" ++ cppType aliasMap t ++ ">"
+  Map k v       -> "std::map<" ++ cppType aliasMap k ++ ", " ++ cppType aliasMap v ++ ">"
+  -- user defined
+  Data t        -> case normalize aliasMap (Data t) of
+    Data _  -> "std::shared_ptr<::" ++ t ++ ">"
+    _       -> "::" ++ t
+  x -> error $ "unknown type: " ++ show x
+
+hasFieldNames :: [Field] -> Bool
+hasFieldNames [] = False
+hasFieldNames l = all (not . null . fieldName) l
+
+constType :: DataDef -> String
+constType = head . words . show
+
+instance ToJSON ConstructorDef
+instance ToJSON DataDef
+instance ToJSON Instance
+instance ToJSON Field
+instance ToJSON Type
+
+instance FromJSON ConstructorDef
+instance FromJSON DataDef
+instance FromJSON Instance
+instance FromJSON Field
+instance FromJSON Type
+
+type MDef = Writer [ModuleDef]
+type DDef = Writer ([DataDef],[String])
+type CDef = Writer ([ConstructorDef],[Instance])
+
+module_ :: String -> DDef () -> MDef ()
+module_ n m = tell [let (d,i) = execWriter m in ModuleDef n i d]
+
+import_ :: [String] -> DDef ()
+import_ l = tell (mempty,l)
+
+data_ :: String -> CDef () -> DDef ()
+data_ n l = tell ([let (c,i) = execWriter l in DataDef n c i],mempty)
+
+alias_ :: String -> Type -> DDef ()
+alias_ n t = tell ([TypeAlias n t],mempty)
+
+a #= b = alias_ a b
+
+class IsField a where
+  toField :: a -> Field
+
+instance IsField Field where
+  toField a = a
+
+instance IsField Type where
+  toField a = Field "" a
+
+deriving_ :: [Target] -> [Instance] -> CDef ()
+deriving_ t l = tell (mempty,l)
+
+const_ :: String -> [Type] -> CDef ()
+const_ n t = tell ([ConstructorDef n [Field a b | Field a b <- map toField t]],mempty)
+
+constR_ :: String -> [Field] -> CDef ()
+constR_ n t = tell ([ConstructorDef n [Field a b | Field a b <- map toField t]],mempty)
+
+enum_ :: String -> CDef ()
+enum_ n = tell ([ConstructorDef n []],mempty)
+
+v2b = V2 Bool
+v3b = V3 Bool
+v4b = V4 Bool
+v2u = V2 Word
+v3u = V3 Word
+v4u = V4 Word
+v2i = V2 Int
+v3i = V3 Int
+v4i = V4 Int
+v2f = V2 Float
+v3f = V3 Float
+v4f = V4 Float
+m22 = V2 v2f
+m23 = V3 v2f
+m24 = V4 v2f
+m32 = V2 v3f
+m33 = V3 v3f
+m34 = V4 v3f
+m42 = V2 v4f
+m43 = V3 v4f
+m44 = V4 v4f
+
+(#::) :: String -> Type -> Field
+a #:: b = Field a b
+
+{-
+  definitions:
+    ADT
+    Record
+    Vector
+
+  instances:
+    Show
+    Eq
+    Ord
+
+  serialization:
+    json: encode/decode
+    other?
+-}
\ No newline at end of file
diff --git a/ddl/lib/RT.cpp b/ddl/lib/RT.cpp
new file mode 100644
index 0000000..97701b2
--- /dev/null
+++ b/ddl/lib/RT.cpp
@@ -0,0 +1,42 @@
+#include "RT.hpp"
+
+template<> json toJSON<String>(String &v) {
+  return json(v);
+}
+
+template<> json toJSON<Float>(Float &v) {
+  return json(v);
+}
+
+template<> json toJSON<bool>(bool &v) {
+  return json(v);
+}
+
+template<> json toJSON<int>(int &v) {
+  return json(v);
+}
+
+template<> json toJSON<unsigned int>(unsigned int &v) {
+  return json(v);
+}
+
+template<> String fromJSON<String>(W<String> v, json &obj) {
+  return obj.get<String>();
+}
+
+template<> Float fromJSON<Float>(W<Float> v, json &obj) {
+  return obj.get<Float>();
+}
+
+template<> bool fromJSON<bool>(W<bool> v, json &obj) {
+  return obj.get<bool>();
+}
+
+template<> int fromJSON<int>(W<int> v, json &obj) {
+  return obj.get<int>();
+}
+
+template<> unsigned int fromJSON<unsigned int>(W<unsigned int> v, json &obj) {
+  return obj.get<unsigned int>();
+}
+
diff --git a/ddl/lib/RT.hpp b/ddl/lib/RT.hpp
new file mode 100644
index 0000000..2e1e652
--- /dev/null
+++ b/ddl/lib/RT.hpp
@@ -0,0 +1,188 @@
+#ifndef HEADER_RT_H
+#define HEADER_RT_H
+
+#include <vector>
+#include <map>
+#include <string>
+
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+typedef int Int;
+typedef int Int32;
+typedef unsigned int Word;
+typedef unsigned int Word32;
+typedef float Float;
+typedef bool Bool;
+typedef std::string String;
+
+template<typename T1>
+struct Maybe
+{
+  T1 data;
+  bool valid;
+};
+
+template<typename T>
+struct V2 { T x,y; };
+
+template<typename T>
+struct V3 { T x,y,z; };
+
+template<typename T>
+struct V4 { T x,y,z,w; };
+
+typedef struct V2<Int>    V2I;
+typedef struct V2<Word>   V2U;
+typedef struct V2<Float>  V2F;
+typedef struct V2<Bool>   V2B;
+
+typedef struct V3<Int>    V3I;
+typedef struct V3<Word>   V3U;
+typedef struct V3<Float>  V3F;
+typedef struct V3<Bool>   V3B;
+
+typedef struct V4<Int>    V4I;
+typedef struct V4<Word>   V4U;
+typedef struct V4<Float>  V4F;
+typedef struct V4<Bool>   V4B;
+
+typedef struct V2<V2F>    M22F;
+typedef struct V2<V3F>    M32F;
+typedef struct V2<V4F>    M42F;
+typedef struct V3<V2F>    M23F;
+typedef struct V3<V3F>    M33F;
+typedef struct V3<V4F>    M43F;
+typedef struct V4<V2F>    M24F;
+typedef struct V4<V3F>    M34F;
+typedef struct V4<V4F>    M44F;
+
+
+template<typename T>
+json toJSON(T &v);
+
+template<typename any>
+json toJSON(Maybe<any> &v) {
+  if (v.valid) {
+    return toJSON(v.data);
+  }
+  return json();
+}
+
+template<typename any>
+json toJSON(V2<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  return obj;
+}
+
+template<typename any>
+json toJSON(V3<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  obj["z"] = toJSON(v.z);
+  return obj;
+}
+
+template<typename any>
+json toJSON(V4<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  obj["z"] = toJSON(v.z);
+  obj["w"] = toJSON(v.w);
+  return obj;
+}
+
+template<typename any>
+json toJSON(std::vector<any> &v) {
+  json obj = json::array();
+  for (any i : v) {
+    obj.push_back(toJSON(i));
+  }
+  return obj;
+}
+
+template<typename v>
+json toJSON(std::map<String,v> &value) {
+  json obj({});
+  for(auto i : value) {
+    obj[i.first] = toJSON(i.second);
+  }
+  return obj;
+}
+
+template<typename T>
+struct W {};
+
+template<typename T>
+T fromJSON(W<T> w, json &obj);
+
+template<typename any>
+Maybe<any> fromJSON(W<Maybe<any>> v, json &obj) {
+  Maybe<any> a;
+  if (obj.is_null()) {
+    a.valid = false;
+  } else {
+    a.valid = true;
+    a.data = fromJSON(W<any>(),obj);
+  }
+  return a;
+}
+
+template<typename any>
+V2<any> fromJSON(W<V2<any>> v, json &obj) {
+  V2<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
+  return a;
+}
+
+template<typename any>
+V3<any> fromJSON(W<V3<any>> v, json &obj) {
+  V3<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
+  a.z = fromJSON(W<any>(), obj["z"]);
+  return a;
+}
+
+template<typename any>
+V4<any> fromJSON(W<V4<any>> v, json &obj) {
+  V4<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
+  a.z = fromJSON(W<any>(), obj["z"]);
+  a.w = fromJSON(W<any>(), obj["w"]);
+  return a;
+}
+
+template<typename any>
+std::vector<any> fromJSON(W<std::vector<any>> v, json &obj) {
+  std::vector<any> a;
+  for (json::iterator it = obj.begin(); it != obj.end(); ++it) {
+    a.push_back(fromJSON(W<any>(),*it));
+  }
+  return a;
+}
+
+template<typename v>
+std::map<String,v> fromJSON(W<std::map<String,v>> value, json &obj) {
+  std::map<String,v> a;
+  for (json::iterator it = obj.begin(); it != obj.end(); ++it) {
+    a[it.key()] = fromJSON(W<v>(),it.value());
+  }
+  return a;
+}
+
+/*
+template<typename k, typename v>
+std::map<k,v> fromJSON(W<std::map<k,v>> value, json &obj) {
+  std::map<k,v> a;
+  return a;
+}
+*/
+#endif
\ No newline at end of file
diff --git a/ddl/lib/json.hpp b/ddl/lib/json.hpp
new file mode 100644
index 0000000..bdea958
--- /dev/null
+++ b/ddl/lib/json.hpp
@@ -0,0 +1,7307 @@
+/*!
+@mainpage
+
+These pages contain the API documentation of JSON for Modern C++, a C++11
+header-only JSON class.
+
+Class @ref nlohmann::basic_json is a good entry point for the documentation.
+
+@copyright The code is licensed under the [MIT
+           License](http://opensource.org/licenses/MIT):
+           <br>
+           Copyright &copy; 2013-2015 Niels Lohmann.
+           <br>
+           Permission is hereby granted, free of charge, to any person
+           obtaining a copy of this software and associated documentation files
+           (the "Software"), to deal in the Software without restriction,
+           including without limitation the rights to use, copy, modify, merge,
+           publish, distribute, sublicense, and/or sell copies of the Software,
+           and to permit persons to whom the Software is furnished to do so,
+           subject to the following conditions:
+           <br>
+           The above copyright notice and this permission notice shall be
+           included in all copies or substantial portions of the Software.
+           <br>
+           THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+           EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+           MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+           NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+           BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+           ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+           CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+           SOFTWARE.
+
+@author [Niels Lohmann](http://nlohmann.me)
+@see https://github.com/nlohmann/json to download the source code
+*/
+
+#ifndef NLOHMANN_JSON_HPP
+#define NLOHMANN_JSON_HPP
+
+#include <algorithm>
+#include <array>
+#include <ciso646>
+#include <cmath>
+#include <cstdio>
+#include <functional>
+#include <initializer_list>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// enable ssize_t on MinGW
+#ifdef __GNUC__
+    #ifdef __MINGW32__
+        #include <sys/types.h>
+    #endif
+#endif
+
+// enable ssize_t for MSVC
+#ifdef _MSC_VER
+    #include <basetsd.h>
+    using ssize_t = SSIZE_T;
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+*/
+namespace nlohmann
+{
+
+
+/*!
+@brief unnamed namespace with internal helper functions
+*/
+namespace
+{
+/*!
+@brief Helper to determine whether there's a key_type for T.
+@sa http://stackoverflow.com/a/7728728/266378
+*/
+template<typename T>
+struct has_mapped_type
+{
+  private:
+    template<typename C> static char test(typename C::mapped_type*);
+    template<typename C> static int  test(...);
+  public:
+    enum { value = sizeof(test<T>(0)) == sizeof(char) };
+};
+
+/// "equality" comparison for floating point numbers
+template<typename T>
+static bool approx(const T a, const T b)
+{
+    return not (a > b or a < b);
+}
+}
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (@c std::map by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (@c std::vector by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (@c std::string by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (@c `bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (@c `int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberFloatType type for JSON floating-point numbers (@c `double` by
+default; will be used in @ref number_float_t)
+@tparam AllocatorType type of the allocator to use (@c `std::allocator` by
+default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):
+   JSON values can be default constructed. The result will be a JSON null value.
+ - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):
+   A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):
+   A JSON value can be copy-constrcuted from an lvalue expression.
+ - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):
+   A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):
+   A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):
+   JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):
+   JSON values have
+   [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+   All non-static data members are private and standard layout types, the class
+   has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):
+   JSON values can be compared with `==`, see @ref
+   operator==(const_reference,const_reference).
+ - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):
+   JSON values can be compared with `<`, see @ref
+   operator<(const_reference,const_reference).
+ - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):
+   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+   other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):
+   JSON values can be compared against `std::nullptr_t` objects which are used
+   to model the `null` value.
+- Container
+ - [Container](http://en.cppreference.com/w/cpp/concept/Container):
+   JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);
+   JSON values can be used like STL containers and provide reverse iterator
+   access.
+
+@internal
+@note ObjectType trick from http://stackoverflow.com/a/9860911
+@endinternal
+
+@see RFC 7159 <http://rfc7159.net/rfc7159>
+*/
+template <
+    template<typename U, typename V, typename... Args> class ObjectType = std::map,
+    template<typename U, typename... Args> class ArrayType = std::vector,
+    class StringType = std::string,
+    class BooleanType = bool,
+    class NumberIntegerType = int64_t,
+    class NumberFloatType = double,
+    template<typename U> class AllocatorType = std::allocator
+    >
+class basic_json
+{
+  private:
+    /// workaround type for MSVC
+    using basic_json_t = basic_json<ObjectType,
+          ArrayType,
+          StringType,
+          BooleanType,
+          NumberIntegerType,
+          NumberFloatType,
+          AllocatorType>;
+
+  public:
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    // forward declaration
+    template<typename Base> class json_reverse_iterator;
+
+    /// an iterator for a basic_json container
+    class iterator;
+    /// a const iterator for a basic_json container
+    class const_iterator;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /*!
+    @brief returns the allocator associated with the container
+    */
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// @{
+
+    /*!
+    @brief a type for an object
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+    > An object is an unordered collection of zero or more name/value pairs,
+    > where a name is a string and a value is a string, number, boolean, null,
+    > object, or array.
+
+    To store objects in C++, a type is defined by the template parameters @a
+    ObjectType which chooses the container (e.g., `std::map` or
+    `std::unordered_map`), @a StringType which chooses the type of the keys or
+    names, and @a AllocatorType which chooses the allocator to use.
+
+    #### Default type
+
+    With the default values for @a ObjectType (`std::map`), @a StringType
+    (`std::string`), and @a AllocatorType (`std::allocator`), the default value
+    for @a object_t is:
+
+    @code {.cpp}
+    std::map<
+      std::string, // key_type
+      basic_json, // value_type
+      std::less<std::string>, // key_compare
+      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+    >
+    @endcode
+
+    #### Behavior
+
+    The choice of @a object_t influences the behavior of the JSON class. With
+    the default type, objects have the following behavior:
+
+    - When all names are unique, objects will be interoperable in the sense
+      that all software implementations receiving that object will agree on the
+      name-value mappings.
+    - When the names within an object are not unique, later stored name/value
+      pairs overwrite previously stored name/value pairs, leaving the used
+      names unique. For instance, `{"key": 1}` and `{"key": 2, "key": 1}` will
+      be treated as equal and both stored as `{"key": 1}`.
+    - Internally, name/value pairs are stored in lexicographical order of the
+      names. Objects will also be serialized (see @ref dump) in this order. For
+      instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored and
+      serialized as `{"a": 2, "b": 1}`.
+    - When comparing objects, the order of the name/value pairs is irrelevant.
+      This makes objects interoperable in the sense that they will not be
+      affected by these differences. For instance, `{"b": 1, "a": 2}` and
+      `{"a": 2, "b": 1}` will be treated as equal.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the object's limit of nesting is not constraint explicitly.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the @ref
+    max_size function of a JSON object.
+
+    #### Storage
+
+    Objects are stored as pointers in a `basic_json` type. That is, for any
+    access to object values, a pointer of type `object_t*` must be dereferenced.
+
+    @sa array_t
+    */
+    using object_t = ObjectType<StringType,
+          basic_json,
+          std::less<StringType>,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /*!
+    @brief a type for an array
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+    > An array is an ordered sequence of zero or more values.
+
+    To store objects in C++, a type is defined by the template parameters @a
+    ArrayType which chooses the container (e.g., `std::vector` or `std::list`)
+    and @a AllocatorType which chooses the allocator to use.
+
+    #### Default type
+
+    With the default values for @a ArrayType (`std::vector`) and @a
+    AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+    @code {.cpp}
+    std::vector<
+      basic_json, // value_type
+      std::allocator<basic_json> // allocator_type
+    >
+    @endcode
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the array's limit of nesting is not constraint explicitly.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the @ref
+    max_size function of a JSON array.
+
+    #### Storage
+
+    Arrays are stored as pointers in a `basic_json` type. That is, for any
+    access to array values, a pointer of type `array_t*` must be dereferenced.
+    */
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /*!
+    @brief a type for a string
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+    > A string is a sequence of zero or more Unicode characters.
+
+    To store objects in C++, a type is defined by the template parameters @a
+    StringType which chooses the container (e.g., `std::string`) to use.
+
+    Unicode values are split by the JSON class into byte-sized characters
+    during deserialization.
+
+    #### Default type
+
+    With the default values for @a StringType (`std::string`), the default
+    value for @a string_t is:
+
+    @code {.cpp}
+    std::string
+    @endcode
+
+    #### String comparison
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > Software implementations are typically required to test names of object
+    > members for equality. Implementations that transform the textual
+    > representation into sequences of Unicode code units and then perform the
+    > comparison numerically, code unit by code unit, are interoperable in the
+    > sense that implementations will agree in all cases on equality or
+    > inequality of two strings. For example, implementations that compare
+    > strings with escaped characters unconverted may incorrectly find that
+    > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+    This implementation is interoperable as it does compare strings code unit
+    by code unit.
+
+    #### Storage
+
+    String values are stored as pointers in a `basic_json` type. That is, for
+    any access to string values, a pointer of type `string_t*` must be
+    dereferenced.
+    */
+    using string_t = StringType;
+
+    /*!
+    @brief a type for a boolean
+
+    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+    type which differentiates the two literals `true` and `false`.
+
+    To store objects in C++, a type is defined by the template parameter @a
+    BooleanType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a BooleanType (`bool`), the default value for
+    @a boolean_t is:
+
+    @code {.cpp}
+    bool
+    @endcode
+
+    #### Storage
+
+    Boolean values are stored directly inside a `basic_json` type.
+    */
+    using boolean_t = BooleanType;
+
+    /*!
+    @brief a type for a number (integer)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most programming
+    > languages. A number is represented in base 10 using decimal digits. It
+    > contains an integer component that may be prefixed with an optional minus
+    > sign, which may be followed by a fraction part and/or an exponent part.
+    > Leading zeros are not allowed. (...) Numeric values that cannot be
+    > represented in the grammar below (such as Infinity and NaN) are not
+    > permitted.
+
+    This description includes both integer and floating-point numbers. However,
+    C++ allows more precise storage if it is known whether the number is an
+    integer or a floating-point number. Therefore, two different types, @ref
+    number_integer_t and @ref number_float_t are used.
+
+    To store integer numbers in C++, a type is defined by the template
+    parameter @a NumberIntegerType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberIntegerType (`int64_t`), the default
+    value for @a number_integer_t is:
+
+    @code {.cpp}
+    int64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+    that are out of range will yield over/underflow when used in a constructor.
+    During deserialization, too large or small integer numbers will be
+    automatically be stored as @ref number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange of the exactly supported range [INT64_MIN,
+    INT64_MAX], this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a `basic_json` type.
+    */
+    using number_integer_t = NumberIntegerType;
+
+    /*!
+    @brief a type for a number (floating-point)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most programming
+    > languages. A number is represented in base 10 using decimal digits. It
+    > contains an integer component that may be prefixed with an optional minus
+    > sign, which may be followed by a fraction part and/or an exponent part.
+    > Leading zeros are not allowed. (...) Numeric values that cannot be
+    > represented in the grammar below (such as Infinity and NaN) are not
+    > permitted.
+
+    This description includes both integer and floating-point numbers. However,
+    C++ allows more precise storage if it is known whether the number is an
+    integer or a floating-point number. Therefore, two different types, @ref
+    number_integer_t and @ref number_float_t are used.
+
+    To store floating-point numbers in C++, a type is defined by the template
+    parameter @a NumberFloatType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberFloatType (`double`), the default
+    value for @a number_float_t is:
+
+    @code {.cpp}
+    double
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in floating-point literals will be ignored. Internally, the
+      value will be stored as decimal number. For instance, the C++
+      floating-point literal `01.2` will be serialized to `1.2`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > This specification allows implementations to set limits on the range and
+    > precision of numbers accepted. Since software that implements IEEE
+    > 754-2008 binary64 (double precision) numbers is generally available and
+    > widely used, good interoperability can be achieved by implementations that
+    > expect no more precision or range than these provide, in the sense that
+    > implementations will approximate JSON numbers within the expected
+    > precision.
+
+    This implementation does exactly follow this approach, as it uses double
+    precision floating-point numbers. Note values smaller than
+    `-1.79769313486232e+308` and values greather than `1.79769313486232e+308`
+    will be stored as NaN internally and be serialized to `null`.
+
+    #### Storage
+
+    Floating-point number values are stored directly inside a `basic_json` type.
+    */
+    using number_float_t = NumberFloatType;
+
+    /// @}
+
+
+    ///////////////////////////
+    // JSON type enumeration //
+    ///////////////////////////
+
+    /*!
+    @brief the JSON type enumeration
+
+    This enumeration collects the different JSON types. It is internally used
+    to distinguish the stored values, and the functions is_null, is_object,
+    is_array, is_string, is_boolean, is_number, and is_discarded rely on it.
+    */
+    enum class value_t : uint8_t
+    {
+        null,           ///< null value
+        object,         ///< object (unordered set of name/value pairs)
+        array,          ///< array (ordered collection of values)
+        string,         ///< string value
+        boolean,        ///< boolean value
+        number_integer, ///< number value (integer)
+        number_float,   ///< number value (floating-point)
+        discarded       ///< discarded by the the parser callback function
+    };
+
+
+  private:
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+    /// a JSON value
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() noexcept = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case (value_t::null):
+                case (value_t::discarded):
+                {
+                    break;
+                }
+
+                case (value_t::object):
+                {
+                    AllocatorType<object_t> alloc;
+                    object = alloc.allocate(1);
+                    alloc.construct(object);
+                    break;
+                }
+
+                case (value_t::array):
+                {
+                    AllocatorType<array_t> alloc;
+                    array = alloc.allocate(1);
+                    alloc.construct(array);
+                    break;
+                }
+
+                case (value_t::string):
+                {
+                    AllocatorType<string_t> alloc;
+                    string = alloc.allocate(1);
+                    alloc.construct(string, "");
+                    break;
+                }
+
+                case (value_t::boolean):
+                {
+                    boolean = boolean_t(false);
+                    break;
+                }
+
+                case (value_t::number_integer):
+                {
+                    number_integer = number_integer_t(0);
+                    break;
+                }
+
+                case (value_t::number_float):
+                {
+                    number_float = number_float_t(0.0);
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value)
+        {
+            AllocatorType<string_t> alloc;
+            string = alloc.allocate(1);
+            alloc.construct(string, value);
+        }
+
+        /// constructor for objects
+        json_value(const object_t& value)
+        {
+            AllocatorType<object_t> alloc;
+            object = alloc.allocate(1);
+            alloc.construct(object, value);
+        }
+
+        /// constructor for arrays
+        json_value(const array_t& value)
+        {
+            AllocatorType<array_t> alloc;
+            array = alloc.allocate(1);
+            alloc.construct(array, value);
+        }
+    };
+
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /*!
+    @brief JSON callback events
+
+    This enumeration lists the parser events that can trigger calling a
+    callback function of type @ref parser_callback_t during parsing.
+    */
+    enum class parse_event_t : uint8_t
+    {
+        /// the parser read `{` and started to process a JSON object
+        object_start,
+        /// the parser read `}` and finished processing a JSON object
+        object_end,
+        /// the parser read `[` and started to process a JSON array
+        array_start,
+        /// the parser read `]` and finished processing a JSON array
+        array_end,
+        /// the parser read a key of a value in an object
+        key,
+        /// the parser finished reading a JSON value
+        value
+    };
+
+    /*!
+    @brief per-element parser callback type
+
+    With a parser callback function, the result of parsing a JSON text can be
+    influenced. When passed to @ref parse(std::istream&, parser_callback_t) or
+    @ref parse(const string_t&, parser_callback_t), it is called on certain
+    events (passed as @ref parse_event_t via parameter @a event) with a set
+    recursion depth @a depth and context JSON value @a parsed. The return value
+    of the callback function is a boolean indicating whether the element that
+    emitted the callback shall be kept or not.
+
+    We distinguish six scenarios (determined by the event type) in which the
+    callback function can be called. The following table describes the values
+    of the parameters @a depth, @a event, and @a parsed.
+
+    parameter @a event | description | parameter @a depth | parameter @a parsed
+    ------------------ | ----------- | ------------------ | -------------------
+    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+    Discarding a value (i.e., returning `false`) has different effects depending on the
+    context in which function was called:
+
+    - Discarded values in structured types are skipped. That is, the parser
+      will behave as if the discarded value was never read.
+    - In case a value outside a structured type is skipped, it is replaced with
+      `null`. This case happens if the top-level element is skipped.
+
+    @param[in] depth   the depth of the recursion during parsing
+
+    @param[in] event   an event of type parse_event_t indicating the context in
+    the callback function has been called
+
+    @param[in,out] parsed  the current intermediate parse result; note that
+    writing to this value has no effect for parse_event_t::key events
+
+    @return Whether the JSON value which called the function during parsing
+    should be kept (`true`) or not (`false`). In the latter case, it is either
+    skipped completely or replaced by an empty discarded object.
+
+    @sa @ref parse(std::istream&, parser_callback_t) or
+    @ref parse(const string_t&, parser_callback_t) for examples
+    */
+    using parser_callback_t = std::function<bool(
+                                  int depth, parse_event_t event, basic_json& parsed)>;
+
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /*!
+    @brief create an empty value with a given type
+
+    Create an empty JSON value with a given type. The value will be default
+    initialized with an empty value which depends on the type:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @param[in] value  the type of the value to create
+
+    @complexity Constant.
+
+    @throw std::bad_alloc if allocation for object, array, or string value
+    fails
+
+    @liveexample{The following code shows the constructor for different @ref
+    value_t values,basic_json__value_t}
+    */
+    basic_json(const value_t value)
+        : m_type(value), m_value(value)
+    {}
+
+    /*!
+    @brief create a null object (implicitly)
+
+    Create a `null` JSON value. This is the implicit version of the `null`
+    value constructor as it takes no parameters.
+
+    @complexity Constant.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - As postcondition, it holds: `basic_json().empty() == true`.
+
+    @liveexample{The following code shows the constructor for a `null` JSON
+    value.,basic_json}
+
+    @sa basic_json(std::nullptr_t)
+    */
+    basic_json() noexcept = default;
+
+    /*!
+    @brief create a null object (explicitly)
+
+    Create a `null` JSON value. This is the explicitly version of the `null`
+    value constructor as it takes a null pointer as parameter. It allows to
+    create `null` values by explicitly assigning a @c nullptr to a JSON value.
+    The passed null pointer itself is not read - it is only used to choose the
+    right constructor.
+
+    @complexity Constant.
+
+    @liveexample{The following code shows the constructor with null pointer
+    parameter.,basic_json__nullptr_t}
+
+    @sa basic_json()
+    */
+    basic_json(std::nullptr_t) noexcept
+        : basic_json(value_t::null)
+    {}
+
+    /*!
+    @brief create an object (explicit)
+
+    Create an object JSON value with a given content.
+
+    @param[in] value  a value for the object
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for object value fails
+
+    @liveexample{The following code shows the constructor with an @ref object_t
+    parameter.,basic_json__object_t}
+
+    @sa basic_json(const CompatibleObjectType&)
+    */
+    basic_json(const object_t& value)
+        : m_type(value_t::object), m_value(value)
+    {}
+
+    /*!
+    @brief create an object (implicit)
+
+    Create an object JSON value with a given content. This constructor allows
+    any type that can be used to construct values of type @ref object_t.
+    Examples include the types `std::map` and `std::unordered_map`.
+
+    @tparam CompatibleObjectType an object type whose `key_type` and
+    `value_type` is compatible to @ref object_t
+
+    @param[in] value  a value for the object
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for object value fails
+
+    @liveexample{The following code shows the constructor with several
+    compatible object type parameters.,basic_json__CompatibleObjectType}
+
+    @sa basic_json(const object_t&)
+    */
+    template <class CompatibleObjectType, typename
+              std::enable_if<
+                  std::is_constructible<typename object_t::key_type, typename CompatibleObjectType::key_type>::value and
+                  std::is_constructible<basic_json, typename CompatibleObjectType::mapped_type>::value, int>::type
+              = 0>
+    basic_json(const CompatibleObjectType& value)
+        : m_type(value_t::object)
+    {
+        AllocatorType<object_t> alloc;
+        m_value.object = alloc.allocate(1);
+        using std::begin;
+        using std::end;
+        alloc.construct(m_value.object, begin(value), end(value));
+    }
+
+    /*!
+    @brief create an array (explicit)
+
+    Create an array JSON value with a given content.
+
+    @param[in] value  a value for the array
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for array value fails
+
+    @liveexample{The following code shows the constructor with an @ref array_t
+    parameter.,basic_json__array_t}
+
+    @sa basic_json(const CompatibleArrayType&)
+    */
+    basic_json(const array_t& value)
+        : m_type(value_t::array), m_value(value)
+    {}
+
+    /*!
+    @brief create an array (implicit)
+
+    Create an array JSON value with a given content. This constructor allows
+    any type that can be used to construct values of type @ref array_t.
+    Examples include the types `std::vector`, `std::list`, and `std::set`.
+
+    @tparam CompatibleArrayType an object type whose `value_type` is compatible
+    to @ref array_t
+
+    @param[in] value  a value for the array
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for array value fails
+
+    @liveexample{The following code shows the constructor with several
+    compatible array type parameters.,basic_json__CompatibleArrayType}
+
+    @sa basic_json(const array_t&)
+    */
+    template <class CompatibleArrayType, typename
+              std::enable_if<
+                  not std::is_same<CompatibleArrayType, typename basic_json_t::iterator>::value and
+                  not std::is_same<CompatibleArrayType, typename basic_json_t::const_iterator>::value and
+                  not std::is_same<CompatibleArrayType, typename basic_json_t::reverse_iterator>::value and
+                  not std::is_same<CompatibleArrayType, typename basic_json_t::const_reverse_iterator>::value and
+                  not std::is_same<CompatibleArrayType, typename array_t::iterator>::value and
+                  not std::is_same<CompatibleArrayType, typename array_t::const_iterator>::value and
+                  std::is_constructible<basic_json, typename CompatibleArrayType::value_type>::value, int>::type
+              = 0>
+    basic_json(const CompatibleArrayType& value)
+        : m_type(value_t::array)
+    {
+        AllocatorType<array_t> alloc;
+        m_value.array = alloc.allocate(1);
+        using std::begin;
+        using std::end;
+        alloc.construct(m_value.array, begin(value), end(value));
+    }
+
+    /*!
+    @brief create a string (explicit)
+
+    Create an string JSON value with a given content.
+
+    @param[in] value  a value for the string
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for string value fails
+
+    @liveexample{The following code shows the constructor with an @ref string_t
+    parameter.,basic_json__string_t}
+
+    @sa basic_json(const typename string_t::value_type*)
+    @sa basic_json(const CompatibleStringType&)
+    */
+    basic_json(const string_t& value)
+        : m_type(value_t::string), m_value(value)
+    {}
+
+    /*!
+    @brief create a string (explicit)
+
+    Create a string JSON value with a given content.
+
+    @param[in] value  a literal value for the string
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for string value fails
+
+    @liveexample{The following code shows the constructor with string literal
+    parameter.,basic_json__string_t_value_type}
+
+    @sa basic_json(const string_t&)
+    @sa basic_json(const CompatibleStringType&)
+    */
+    basic_json(const typename string_t::value_type* value)
+        : basic_json(string_t(value))
+    {}
+
+    /*!
+    @brief create a string (implicit)
+
+    Create a string JSON value with a given content.
+
+    @param[in] value  a value for the string
+
+    @tparam CompatibleStringType an string type which is compatible to @ref
+    string_t
+
+    @complexity Linear in the size of the passed @a value.
+
+    @throw std::bad_alloc if allocation for string value fails
+
+    @liveexample{The following code shows the construction of a string value
+    from a compatible type.,basic_json__CompatibleStringType}
+
+    @sa basic_json(const string_t&)
+    */
+    template <class CompatibleStringType, typename
+              std::enable_if<
+                  std::is_constructible<string_t, CompatibleStringType>::value, int>::type
+              = 0>
+    basic_json(const CompatibleStringType& value)
+        : basic_json(string_t(value))
+    {}
+
+    /*!
+    @brief create a boolean (explicit)
+
+    Creates a JSON boolean type from a given value.
+
+    @param[in] value  a boolean value to store
+
+    @complexity Constant.
+
+    @liveexample{The example below demonstrates boolean
+    values.,basic_json__boolean_t}
+    */
+    basic_json(boolean_t value)
+        : m_type(value_t::boolean), m_value(value)
+    {}
+
+    /*!
+    @brief create an integer number (explicit)
+
+    Create an interger number JSON value with a given content.
+
+    @tparam T  helper type to compare number_integer_t and int (not visible in)
+    the interface.
+
+    @param[in] value  an integer to create a JSON number from
+
+    @note This constructor would have the same signature as @ref
+    basic_json(const int value), so we need to switch this one off in case
+    number_integer_t is the same as int. This is done via the helper type @a T.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows the construction of a JSON integer
+    number value.,basic_json__number_integer_t}
+
+    @sa basic_json(const int)
+    */
+    template<typename T,
+             typename std::enable_if<
+                 not (std::is_same<T, int>::value)
+                 and std::is_same<T, number_integer_t>::value
+                 , int>::type = 0>
+    basic_json(const number_integer_t value)
+        : m_type(value_t::number_integer), m_value(value)
+    {}
+
+    /*!
+    @brief create an integer number from an enum type (explicit)
+
+    Create an integer number JSON value with a given content.
+
+    @param[in] value  an integer to create a JSON number from
+
+    @note This constructor allows to pass enums directly to a constructor. As
+    C++ has no way of specifying the type of an anonymous enum explicitly, we
+    can only rely on the fact that such values implicitly convert to int. As
+    int may already be the same type of number_integer_t, we may need to switch
+    off the constructor @ref basic_json(const number_integer_t).
+
+    @complexity Constant.
+
+    @liveexample{The example below shows the construction of a JSON integer
+    number value from an anonymous enum.,basic_json__const_int}
+
+    @sa basic_json(const number_integer_t)
+    */
+    basic_json(const int value)
+        : m_type(value_t::number_integer),
+          m_value(static_cast<number_integer_t>(value))
+    {}
+
+    /*!
+    @brief create an integer number (implicit)
+
+    Create an integer number JSON value with a given content. This constructor
+    allows any type that can be used to construct values of type @ref
+    number_integer_t. Examples may include the types `int`, `int32_t`, or
+    `short`.
+
+    @tparam CompatibleNumberIntegerType an integer type which is compatible to
+    @ref number_integer_t.
+
+    @param[in] value  an integer to create a JSON number from
+
+    @complexity Constant.
+
+    @liveexample{The example below shows the construction of several JSON
+    integer number values from compatible
+    types.,basic_json__CompatibleIntegerNumberType}
+
+    @sa basic_json(const number_integer_t)
+    */
+    template<typename CompatibleNumberIntegerType, typename
+             std::enable_if<
+                 std::is_constructible<number_integer_t, CompatibleNumberIntegerType>::value and
+                 std::numeric_limits<CompatibleNumberIntegerType>::is_integer, CompatibleNumberIntegerType>::type
+             = 0>
+    basic_json(const CompatibleNumberIntegerType value) noexcept
+        : m_type(value_t::number_integer),
+          m_value(static_cast<number_integer_t>(value))
+    {}
+
+    /*!
+    @brief create a floating-point number (explicit)
+
+    Create a floating-point number JSON value with a given content.
+
+    @param[in] value  a floating-point value to create a JSON number from
+
+    @note RFC 7159 <http://www.rfc-editor.org/rfc/rfc7159.txt>, section 6
+    disallows NaN values:
+    > Numeric values that cannot be represented in the grammar below (such
+    > as Infinity and NaN) are not permitted.
+    In case the parameter @a value is not a number, a JSON null value is
+    created instead.
+
+    @complexity Constant.
+
+    @liveexample{The following example creates several floating-point
+    values.,basic_json__number_float_t}
+    */
+    basic_json(const number_float_t value)
+        : m_type(value_t::number_float), m_value(value)
+    {
+        // replace infinity and NAN by null
+        if (not std::isfinite(value))
+        {
+            m_type = value_t::null;
+            m_value = json_value();
+        }
+    }
+
+    /*!
+    @brief create an floating-point number (implicit)
+
+    Create an floating-point number JSON value with a given content. This
+    constructor allows any type that can be used to construct values of type
+    @ref number_float_t. Examples may include the types `float`.
+
+    @tparam CompatibleNumberFloatType a floating-point type which is compatible
+    to @ref number_float_t.
+
+    @param[in] value  a floating-point to create a JSON number from
+
+    @note RFC 7159 <http://www.rfc-editor.org/rfc/rfc7159.txt>, section 6
+    disallows NaN values:
+    > Numeric values that cannot be represented in the grammar below (such
+    > as Infinity and NaN) are not permitted.
+    In case the parameter @a value is not a number, a JSON null value is
+    created instead.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows the construction of several JSON
+    floating-point number values from compatible
+    types.,basic_json__CompatibleNumberFloatType}
+
+    @sa basic_json(const number_float_t)
+    */
+    template<typename CompatibleNumberFloatType, typename = typename
+             std::enable_if<
+                 std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and
+                 std::is_floating_point<CompatibleNumberFloatType>::value>::type
+             >
+    basic_json(const CompatibleNumberFloatType value) noexcept
+        : basic_json(number_float_t(value))
+    {}
+
+    /*!
+    @brief create a container (array or object) from an initializer list
+
+    Creates a JSON value of type array or object from the passed initializer
+    list @a init. In case @a type_deduction is `true` (default), the type of
+    the JSON value to be created is deducted from the initializer list @a init
+    according to the following rules:
+
+    1. If the list is empty, an empty JSON object value `{}` is created.
+    2. If the list consists of pairs whose first element is a string, a JSON
+    object value is created where the first elements of the pairs are treated
+    as keys and the second elements are as values.
+    3. In all other cases, an array is created.
+
+    The rules aim to create the best fit between a C++ initializer list and
+    JSON values. The ratioinale is as follows:
+
+    1. The empty initializer list is written as `{}` which is exactly an empty
+    JSON object.
+    2. C++ has now way of describing mapped types other than to list a list of
+    pairs. As JSON requires that keys must be of type string, rule 2 is the
+    weakest constraint one can pose on initializer lists to interpret them as
+    an object.
+    3. In all other cases, the initializer list could not be interpreted as
+    JSON object type, so interpreting it as JSON array type is safe.
+
+    With the rules described above, the following JSON values cannot be
+    expressed by an initializer list:
+
+    - the empty array (`[]`): use @ref array(std::initializer_list<basic_json>)
+      with an empty initializer list in this case
+    - arrays whose elements satisfy rule 2: use @ref
+      array(std::initializer_list<basic_json>) with the same initializer list
+      in this case
+
+    @note When used without parentheses around an empty initializer list, @ref
+    basic_json() is called instead of this function, yielding the JSON null
+    value.
+
+    @param[in] init  initializer list with JSON values
+
+    @param[in] type_deduction internal parameter; when set to `true`, the type
+    of the JSON value is deducted from the initializer list @a init; when set
+    to `false`, the type provided via @a manual_type is forced. This mode is
+    used by the functions @ref array(std::initializer_list<basic_json>) and
+    @ref object(std::initializer_list<basic_json>).
+
+    @param[in] manual_type internal parameter; when @a type_deduction is set to
+    `false`, the created JSON value will use the provided type (only @ref
+    value_t::array and @ref value_t::object are valid); when @a type_deduction
+    is set to `true`, this parameter has no effect
+
+    @throw std::domain_error if @a type_deduction is `false`, @a manual_type is
+    `value_t::object`, but @a init contains an element which is not a pair
+    whose first element is a string
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @liveexample{The example below shows how JSON values are created from
+    initializer lists,basic_json__list_init_t}
+
+    @sa basic_json array(std::initializer_list<basic_json>) - create a JSON
+    array value from an initializer list
+    @sa basic_json object(std::initializer_list<basic_json>) - create a JSON
+    object value from an initializer list
+    */
+    basic_json(std::initializer_list<basic_json> init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // the initializer list could describe an object
+        bool is_object = true;
+
+        // check if each element is an array with two elements whose first element
+        // is a string
+        for (const auto& element : init)
+        {
+            if (element.m_type != value_t::array or element.size() != 2
+                    or element[0].m_type != value_t::string)
+            {
+                // we found an element that makes it impossible to use the
+                // initializer list as object
+                is_object = false;
+                break;
+            }
+        }
+
+        // adjust type if type deduction is not wanted
+        if (not type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (manual_type == value_t::object and not is_object)
+            {
+                throw std::domain_error("cannot create object from initializer list");
+            }
+        }
+
+        if (is_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            for (auto& element : init)
+            {
+                m_value.object->emplace(std::move(*(element[0].m_value.string)), std::move(element[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            AllocatorType<array_t> alloc;
+            m_value.array = alloc.allocate(1);
+            alloc.construct(m_value.array, std::move(init));
+        }
+    }
+
+    /*!
+    @brief explicitly create an array from an initializer list
+
+    Creates a JSON array value from a given initializer list. That is, given a
+    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+    initializer list is empty, the empty array `[]` is created.
+
+    @note This function is only needed to express two edge cases that cannot be
+    realized with the initializer list constructor (@ref
+    basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases
+    are:
+    1. creating an array whose elements are all pairs whose first element is a
+    string - in this case, the initializer list constructor would create an
+    object, taking the first elements as keys
+    2. creating an empty array - passing the empty initializer list to the
+    initializer list constructor yields an empty object
+
+    @param[in] init  initializer list with JSON values to create an array from
+    (optional)
+
+    @return JSON array value
+
+    @complexity Linear in the size of @a init.
+
+    @liveexample{The following code shows an example for the @ref array
+    function.,array}
+
+    @sa basic_json(std::initializer_list<basic_json>, bool, value_t) - create a
+    JSON value from an initializer list
+    @sa basic_json object(std::initializer_list<basic_json>) - create a JSON
+    object value from an initializer list
+    */
+    static basic_json array(std::initializer_list<basic_json> init =
+                                std::initializer_list<basic_json>())
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /*!
+    @brief explicitly create an object from an initializer list
+
+    Creates a JSON object value from a given initializer list. The initializer
+    lists elements must be pairs, and their first elments must be strings. If
+    the initializer list is empty, the empty object `{}` is created.
+
+    @note This function is only added for symmetry reasons. In contrast to the
+    related function @ref basic_json array(std::initializer_list<basic_json>),
+    there are no cases which can only be expressed by this function. That is,
+    any initializer list @a init can also be passed to the initializer list
+    constructor @ref basic_json(std::initializer_list<basic_json>, bool,
+    value_t).
+
+    @param[in] init  initializer list to create an object from (optional)
+
+    @return JSON object value
+
+    @throw std::domain_error if @a init is not a pair whose first elements are
+    strings; thrown by @ref basic_json(std::initializer_list<basic_json>, bool,
+    value_t)
+
+    @complexity Linear in the size of @a init.
+
+    @liveexample{The following code shows an example for the @ref object
+    function.,object}
+
+    @sa basic_json(std::initializer_list<basic_json>, bool, value_t) - create a
+    JSON value from an initializer list
+    @sa basic_json array(std::initializer_list<basic_json>) - create a JSON
+    array value from an initializer list
+    */
+    static basic_json object(std::initializer_list<basic_json> init =
+                                 std::initializer_list<basic_json>())
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /*!
+    @brief construct an array with count copies of given value
+
+    Constructs a JSON array value by creating @a count copies of a passed
+    value. In case @a count is `0`, an empty array is created. As postcondition,
+    `std::distance(begin(),end()) == count` holds.
+
+    @param[in] count  the number of JSON copies of @a value to create
+    @param[in] value  the JSON value to copy
+
+    @complexity Linear in @a count.
+
+    @liveexample{The following code shows examples for the @ref
+    basic_json(size_type\, const basic_json&)
+    constructor.,basic_json__size_type_basic_json}
+    */
+    basic_json(size_type count, const basic_json& value)
+        : m_type(value_t::array)
+    {
+        AllocatorType<array_t> alloc;
+        m_value.array = alloc.allocate(1);
+        alloc.construct(m_value.array, count, value);
+    }
+
+    /*!
+    @brief construct a JSON container given an iterator range
+
+    Constructs the JSON value with the contents of the range `[first, last)`.
+    The semantics depends on the different types a JSON value can have:
+    - In case of primitive types (number, boolean, or string), @a first must
+      be `begin()` and @a last must be `end()`. In this case, the value is
+      copied. Otherwise, std::out_of_range is thrown.
+    - In case of structured types (array, object), the constructor behaves
+      as similar versions for `std::vector`.
+    - In case of a null type, std::domain_error is thrown.
+
+    @tparam InputIT an input iterator type (@ref iterator or @ref
+    const_iterator)
+
+    @param[in] first begin of the range to copy from (included)
+    @param[in] last end of the range to copy from (excluded)
+
+    @throw std::domain_error if iterators are not compatible; that is, do not
+    belong to the same JSON value
+    @throw std::out_of_range if iterators are for a primitive type (number,
+    boolean, or string) where an out of range error can be detected easily
+    @throw std::bad_alloc if allocation for object, array, or string fails
+    @throw std::domain_error if called with a null value
+
+    @complexity Linear in distance between @a first and @a last.
+
+    @liveexample{The example below shows several ways to create JSON values by
+    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+    */
+    template <class InputIT, typename
+              std::enable_if<
+                  std::is_same<InputIT, typename basic_json_t::iterator>::value or
+                  std::is_same<InputIT, typename basic_json_t::const_iterator>::value
+                  , int>::type
+              = 0>
+    basic_json(InputIT first, InputIT last) : m_type(first.m_object->m_type)
+    {
+        // make sure iterator fits the current value
+        if (first.m_object != last.m_object)
+        {
+            throw std::domain_error("iterators are not compatible");
+        }
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            case value_t::number_float:
+            case value_t::boolean:
+            case value_t::string:
+            {
+                if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+                {
+                    throw std::out_of_range("iterators out of range");
+                }
+                break;
+            }
+
+            default:
+            {
+                break;
+            }
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                AllocatorType<object_t> alloc;
+                m_value.object = alloc.allocate(1);
+                alloc.construct(m_value.object, first.m_it.object_iterator, last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                AllocatorType<array_t> alloc;
+                m_value.array = alloc.allocate(1);
+                alloc.construct(m_value.array, first.m_it.array_iterator, last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+            {
+                throw std::domain_error("cannot use construct with iterators from " + first.m_object->type_name());
+            }
+        }
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    /*!
+    @brief copy constructor
+
+    Creates a copy of a given JSON value.
+
+    @param[in] other  the JSON value to copy
+
+    @complexity Linear in the size of @a other.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is linear.
+    - As postcondition, it holds: `other == basic_json(other)`.
+
+    @throw std::bad_alloc if allocation for object, array, or string fails.
+
+    @liveexample{The following code shows an example for the copy
+    constructor.,basic_json__basic_json}
+    */
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        switch (m_type)
+        {
+            case (value_t::null):
+            case (value_t::discarded):
+            {
+                break;
+            }
+
+            case (value_t::object):
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case (value_t::array):
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case (value_t::string):
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case (value_t::boolean):
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case (value_t::number_integer):
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case (value_t::number_float):
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief move constructor
+
+    Move constructor. Constructs a JSON value with the contents of the given
+    value @a other using move semantics. It "steals" the resources from @a
+    other and leaves it as JSON null value.
+
+    @param[in,out] other  value to move to this object
+
+    @post @a other is a JSON null value
+
+    @complexity Constant.
+
+    @liveexample{The code below shows the move constructor explicitly called
+    via std::move.,basic_json__moveconstructor}
+    */
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+    }
+
+    /*!
+    @brief copy assignment
+
+    Copy assignment operator. Copies a JSON value via the "copy and swap"
+    strategy: It is expressed in terms of the copy constructor, destructor, and
+    the swap() member function.
+
+    @param[in] other  value to copy from
+
+    @complexity Linear.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is linear.
+
+    @liveexample{The code below shows and example for the copy assignment. It
+    creates a copy of value `a` which is then swapped with `b`. Finally\, the
+    copy of `a` (which is the null value after the swap) is
+    destroyed.,basic_json__copyassignment}
+    */
+    reference& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        using std::swap;
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+        return *this;
+    }
+
+    /*!
+    @brief destructor
+
+    Destroys the JSON value and frees all allocated memory.
+
+    @complexity Linear.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
+    */
+    ~basic_json()
+    {
+        switch (m_type)
+        {
+            case (value_t::object):
+            {
+                AllocatorType<object_t> alloc;
+                alloc.destroy(m_value.object);
+                alloc.deallocate(m_value.object, 1);
+                m_value.object = nullptr;
+                break;
+            }
+
+            case (value_t::array):
+            {
+                AllocatorType<array_t> alloc;
+                alloc.destroy(m_value.array);
+                alloc.deallocate(m_value.array, 1);
+                m_value.array = nullptr;
+                break;
+            }
+
+            case (value_t::string):
+            {
+                AllocatorType<string_t> alloc;
+                alloc.destroy(m_value.string);
+                alloc.deallocate(m_value.string, 1);
+                m_value.string = nullptr;
+                break;
+            }
+
+            default:
+            {
+                // all other types need no specific destructor
+                break;
+            }
+        }
+    }
+
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// @{
+
+    /*!
+    @brief serialization
+
+    Serialization function for JSON values. The function tries to mimick
+    Python's @p json.dumps() function, and currently supports its @p indent
+    parameter.
+
+    @param[in] indent if indent is nonnegative, then array elements and object
+    members will be pretty-printed with that indent level. An indent level of 0
+    will only insert newlines. -1 (the default) selects the most compact
+    representation
+
+    @return string containing the serialization of the JSON value
+
+    @complexity Linear.
+
+    @liveexample{The following example shows the effect of different @a indent
+    parameters to the result of the serializaion.,dump}
+
+    @see https://docs.python.org/2/library/json.html#json.dump
+    */
+    string_t dump(const int indent = -1) const
+    {
+        std::stringstream ss;
+
+        if (indent >= 0)
+        {
+            dump(ss, true, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            dump(ss, false, 0);
+        }
+
+        return ss.str();
+    }
+
+    /*!
+    @brief return the type of the JSON value (explicit)
+
+    Return the type of the JSON value as a value from the @ref value_t
+    enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref type() for all JSON
+    types.,type}
+    */
+    value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /*!
+    @brief return whether type is primitive
+
+    This function returns true iff the JSON type is primitive (string, number,
+    boolean, or null).
+
+    @return `true` if type is primitive (string, number, boolean, or null),
+    `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_primitive for all JSON
+    types.,is_primitive}
+    */
+    bool is_primitive() const noexcept
+    {
+        return is_null() or is_string() or is_boolean() or is_number();
+    }
+
+    /*!
+    @brief return whether type is structured
+
+    This function returns true iff the JSON type is structured (array or
+    object).
+
+    @return `true` if type is structured (array or object), `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_structured for all JSON
+    types.,is_structured}
+    */
+    bool is_structured() const noexcept
+    {
+        return is_array() or is_object();
+    }
+
+    /*!
+    @brief return whether value is null
+
+    This function returns true iff the JSON value is null.
+
+    @return `true` if type is null, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_null for all JSON
+    types.,is_null}
+    */
+    bool is_null() const noexcept
+    {
+        return m_type == value_t::null;
+    }
+
+    /*!
+    @brief return whether value is a boolean
+
+    This function returns true iff the JSON value is a boolean.
+
+    @return `true` if type is boolean, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_boolean for all JSON
+    types.,is_boolean}
+    */
+    bool is_boolean() const noexcept
+    {
+        return m_type == value_t::boolean;
+    }
+
+    /*!
+    @brief return whether value is a number
+
+    This function returns true iff the JSON value is a number. This includes
+    both integer and floating-point values.
+
+    @return `true` if type is number, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_number for all JSON
+    types.,is_number}
+    */
+    bool is_number() const noexcept
+    {
+        return is_number_integer() or is_number_float();
+    }
+
+    /*!
+    @brief return whether value is an integer number
+
+    This function returns true iff the JSON value is an integer number. This
+    excludes floating-point values.
+
+    @return `true` if type is an integer number, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_number_integer for all
+    JSON types.,is_number_integer}
+    */
+    bool is_number_integer() const noexcept
+    {
+        return m_type == value_t::number_integer;
+    }
+
+    /*!
+    @brief return whether value is a floating-point number
+
+    This function returns true iff the JSON value is a floating-point number.
+    This excludes integer values.
+
+    @return `true` if type is a floating-point number, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_number_float for all
+    JSON types.,is_number_float}
+    */
+    bool is_number_float() const noexcept
+    {
+        return m_type == value_t::number_float;
+    }
+
+    /*!
+    @brief return whether value is an object
+
+    This function returns true iff the JSON value is an object.
+
+    @return `true` if type is object, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_object for all JSON
+    types.,is_object}
+    */
+    bool is_object() const noexcept
+    {
+        return m_type == value_t::object;
+    }
+
+    /*!
+    @brief return whether value is an array
+
+    This function returns true iff the JSON value is an array.
+
+    @return `true` if type is array, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_array for all JSON
+    types.,is_array}
+    */
+    bool is_array() const noexcept
+    {
+        return m_type == value_t::array;
+    }
+
+    /*!
+    @brief return whether value is a string
+
+    This function returns true iff the JSON value is a string.
+
+    @return `true` if type is string, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_string for all JSON
+    types.,is_string}
+    */
+    bool is_string() const noexcept
+    {
+        return m_type == value_t::string;
+    }
+
+    /*!
+    @brief return whether value is discarded
+
+    This function returns true iff the JSON value was discarded during parsing
+    with a callback function (see @ref parser_callback_t).
+
+    @note This function will always be `false` for JSON values after parsing.
+    That is, discarded values can only occur during parsing, but will be
+    removed when inside a structured value or replaced by null in other cases.
+
+    @return `true` if type is discarded, `false` otherwise.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies @ref is_discarded for all JSON
+    types.,is_discarded}
+    */
+    bool is_discarded() const noexcept
+    {
+        return m_type == value_t::discarded;
+    }
+
+    /*!
+    @brief return the type of the JSON value (implicit)
+
+    Implicitly return the type of the JSON value as a value from the @ref
+    value_t enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies the value_t operator for all
+    JSON types.,operator__value_t}
+    */
+    operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get an object (explicit)
+    template <class T, typename
+              std::enable_if<
+                  std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
+                  std::is_convertible<basic_json_t, typename T::mapped_type>::value
+                  , int>::type = 0>
+    T get_impl(T*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::object):
+            {
+                return T(m_value.object->begin(), m_value.object->end());
+            }
+            default:
+            {
+                throw std::domain_error("type must be object, but is " + type_name());
+            }
+        }
+    }
+
+    /// get an object (explicit)
+    object_t get_impl(object_t*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::object):
+            {
+                return *(m_value.object);
+            }
+            default:
+            {
+                throw std::domain_error("type must be object, but is " + type_name());
+            }
+        }
+    }
+
+    /// get an array (explicit)
+    template <class T, typename
+              std::enable_if<
+                  std::is_convertible<basic_json_t, typename T::value_type>::value and
+                  not std::is_same<basic_json_t, typename T::value_type>::value and
+                  not std::is_arithmetic<T>::value and
+                  not std::is_convertible<std::string, T>::value and
+                  not has_mapped_type<T>::value
+                  , int>::type = 0>
+    T get_impl(T*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::array):
+            {
+                T to_vector;
+                std::transform(m_value.array->begin(), m_value.array->end(),
+                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
+                {
+                    return i.get<typename T::value_type>();
+                });
+                return to_vector;
+            }
+            default:
+            {
+                throw std::domain_error("type must be array, but is " + type_name());
+            }
+        }
+    }
+
+    /// get an array (explicit)
+    template <class T, typename
+              std::enable_if<
+                  std::is_convertible<basic_json_t, T>::value and
+                  not std::is_same<basic_json_t, T>::value
+                  , int>::type = 0>
+    std::vector<T> get_impl(std::vector<T>*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::array):
+            {
+                std::vector<T> to_vector;
+                to_vector.reserve(m_value.array->size());
+                std::transform(m_value.array->begin(), m_value.array->end(),
+                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
+                {
+                    return i.get<T>();
+                });
+                return to_vector;
+            }
+            default:
+            {
+                throw std::domain_error("type must be array, but is " + type_name());
+            }
+        }
+    }
+
+    /// get an array (explicit)
+    template <class T, typename
+              std::enable_if<
+                  std::is_same<basic_json, typename T::value_type>::value and
+                  not has_mapped_type<T>::value
+                  , int>::type = 0>
+    T get_impl(T*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::array):
+            {
+                return T(m_value.array->begin(), m_value.array->end());
+            }
+            default:
+            {
+                throw std::domain_error("type must be array, but is " + type_name());
+            }
+        }
+    }
+
+    /// get an array (explicit)
+    array_t get_impl(array_t*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::array):
+            {
+                return *(m_value.array);
+            }
+            default:
+            {
+                throw std::domain_error("type must be array, but is " + type_name());
+            }
+        }
+    }
+
+    /// get a string (explicit)
+    template <typename T, typename
+              std::enable_if<
+                  std::is_convertible<string_t, T>::value
+                  , int>::type = 0>
+    T get_impl(T*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::string):
+            {
+                return *m_value.string;
+            }
+            default:
+            {
+                throw std::domain_error("type must be string, but is " + type_name());
+            }
+        }
+    }
+
+    /// get a number (explicit)
+    template<typename T, typename
+             std::enable_if<
+                 std::is_arithmetic<T>::value
+                 , int>::type = 0>
+    T get_impl(T*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::number_integer):
+            {
+                return static_cast<T>(m_value.number_integer);
+            }
+            case (value_t::number_float):
+            {
+                return static_cast<T>(m_value.number_float);
+            }
+            default:
+            {
+                throw std::domain_error("type must be number, but is " + type_name());
+            }
+        }
+    }
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t*) const
+    {
+        switch (m_type)
+        {
+            case (value_t::boolean):
+            {
+                return m_value.boolean;
+            }
+            default:
+            {
+                throw std::domain_error("type must be boolean, but is " + type_name());
+            }
+        }
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t*) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    const object_t* get_impl_ptr(const object_t*) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t*) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    const array_t* get_impl_ptr(const array_t*) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t*) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    const string_t* get_impl_ptr(const string_t*) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t*) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    const boolean_t* get_impl_ptr(const boolean_t*) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t*) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    const number_integer_t* get_impl_ptr(const number_integer_t*) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t*) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    const number_float_t* get_impl_ptr(const number_float_t*) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+  public:
+
+    /// @name value access
+    /// @{
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw std::domain_error in case passed type @a ValueType is incompatible
+    to JSON
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows serveral conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    assiciative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @internal
+    The idea of using a casted null pointer to choose the correct
+    implementation is from <http://stackoverflow.com/a/8315197/266378>.
+    @endinternal
+
+    @sa @ref operator ValueType() const for implicit conversion
+    @sa @ref get() for pointer-member access
+    */
+    template<typename ValueType, typename
+             std::enable_if<
+                 not std::is_pointer<ValueType>::value
+                 , int>::type = 0>
+    ValueType get() const
+    {
+        return get_impl(static_cast<ValueType*>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or @ref
+    number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested pointer
+    type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa @ref get_ptr() for explicit pointer-member access
+    */
+    template<typename PointerType, typename
+             std::enable_if<
+                 std::is_pointer<PointerType>::value
+                 , int>::type = 0>
+    PointerType get() noexcept
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType, typename
+             std::enable_if<
+                 std::is_pointer<PointerType>::value
+                 , int>::type = 0>
+    const PointerType get() const noexcept
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+
+    Implict pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or @ref
+    number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested pointer
+    type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get_ptr}
+    */
+    template<typename PointerType, typename
+             std::enable_if<
+                 std::is_pointer<PointerType>::value
+                 , int>::type = 0>
+    PointerType get_ptr() noexcept
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+    @copydoc get_ptr()
+    */
+    template<typename PointerType, typename
+             std::enable_if<
+                 std::is_pointer<PointerType>::value
+                 and std::is_const<PointerType>::value
+                 , int>::type = 0>
+    const PointerType get_ptr() const noexcept
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<const PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implict type conversion between the JSON value and a compatible value. The
+    call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw std::domain_error in case passed type @a ValueType is incompatible
+    to JSON, thrown by @ref get() const
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows serveral conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    assiciative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+    */
+    template<typename ValueType, typename
+             std::enable_if<
+                 not std::is_pointer<ValueType>::value
+                 , int>::type = 0>
+    operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// @{
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw std::domain_error if JSON is not an array
+    @throw std::out_of_range if the index @a idx is out of range of the array;
+    that is, `idx >= size()`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using at.,at__size_type}
+    */
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use at() with " + type_name());
+        }
+
+        return m_value.array->at(idx);
+    }
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a const reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw std::domain_error if JSON is not an array
+    @throw std::out_of_range if the index @a idx is out of range of the array;
+    that is, `idx >= size()`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    at.,at__size_type_const}
+    */
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use at() with " + type_name());
+        }
+
+        return m_value.array->at(idx);
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object
+    @throw std::out_of_range if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using at.,at__object_t_key_type}
+    */
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use at() with " + type_name());
+        }
+
+        return m_value.object->at(key);
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a const reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object
+    @throw std::out_of_range if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    at.,at__object_t_key_type_const}
+    */
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use at() with " + type_name());
+        }
+
+        return m_value.object->at(key);
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a reference to the element at specified location @a idx.
+
+    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+    then the array is silently filled up with `null` values to make `idx` a
+    valid reference to the last stored element.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw std::domain_error if JSON is not an array or null
+
+    @complexity Constant if @a idx is in the range of the array. Otherwise
+    linear in `idx - size()`.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using [] operator. Note the addition of `null`
+    values.,operatorarray__size_type}
+    */
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null to object
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::array;
+            AllocatorType<array_t> alloc;
+            m_value.array = alloc.allocate(1);
+            alloc.construct(m_value.array);
+        }
+
+        // [] only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        for (size_t i = m_value.array->size(); i <= idx; ++i)
+        {
+            m_value.array->push_back(basic_json());
+        }
+
+        return m_value.array->operator[](idx);
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a const reference to the element at specified location @a idx.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw std::domain_error if JSON is not an array
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    the [] operator.,operatorarray__size_type_const}
+    */
+    const_reference operator[](size_type idx) const
+    {
+        // at only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        return m_value.array->operator[](idx);
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object or null
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the [] operator.,operatorarray__key_type}
+    */
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null to object
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::object;
+            AllocatorType<object_t> alloc;
+            m_value.object = alloc.allocate(1);
+            alloc.construct(m_value.object);
+        }
+
+        // [] only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        return m_value.object->operator[](key);
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object or null
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the [] operator.,operatorarray__key_type_const}
+    */
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        return m_value.object->operator[](key);
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @note This function is required for compatibility reasons with Clang.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object or null
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the [] operator.,operatorarray__key_type}
+    */
+    template<typename T, std::size_t n>
+    reference operator[](const T (&key)[n])
+    {
+        // implicitly convert null to object
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+        }
+
+        // at only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        return m_value.object->operator[](key);
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note This function is required for compatibility reasons with Clang.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw std::domain_error if JSON is not an object or null
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the [] operator.,operatorarray__key_type_const}
+    */
+    template<typename T, std::size_t n>
+    const_reference operator[](const T (&key)[n]) const
+    {
+        // at only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use operator[] with " + type_name());
+        }
+
+        return m_value.object->operator[](key);
+    }
+
+    /*!
+    @brief access the first element
+
+    Returns a reference to the first element in the container. For a JSON
+    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+    @return In case of a structured type (array or object), a reference to the
+    first element is returned. In cast of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @note Calling `front` on an empty container is undefined.
+
+    @throw std::out_of_range when called on null value
+
+    @liveexample{The following code shows an example for @ref front.,front}
+    */
+    reference front()
+    {
+        return *begin();
+    }
+
+    /*!
+    @copydoc basic_json::front()
+    */
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /*!
+    @brief access the last element
+
+    Returns a reference to the last element in the container. For a JSON
+    container `c`, the expression `c.back()` is equivalent to `{ auto tmp =
+    c.end(); --tmp; return *tmp; }`.
+
+    @return In case of a structured type (array or object), a reference to the
+    last element is returned. In cast of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @note Calling `back` on an empty container is undefined.
+
+    @throw std::out_of_range when called on null value.
+
+    @liveexample{The following code shows an example for @ref back.,back}
+    */
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @copydoc basic_json::back()
+    */
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @brief remove element given an iterator
+
+    Removes the element specified by iterator @a pos. Invalidates iterators and
+    references at or after the point of the erase, including the end()
+    iterator. The iterator @a pos must be valid and dereferenceable. Thus the
+    end() iterator (which is valid, but is not dereferencable) cannot be used
+    as a value for @a pos.
+
+    If called on a primitive type other than null, the resulting JSON value
+    will be `null`.
+
+    @param[in] pos iterator to the element to remove
+    @return Iterator following the last removed element. If the iterator @a pos
+    refers to the last element, the end() iterator is returned.
+
+    @tparam InteratorType an @ref iterator or @ref const_iterator
+
+    @throw std::domain_error if called on a `null` value
+    @throw std::domain_error if called on an iterator which does not belong to
+    the current JSON value
+    @throw std::out_of_range if called on a primitive type with invalid iterator
+    (i.e., any iterator which is not end())
+
+    @complexity The complexity depends on the type:
+    - objects: amortized constant
+    - arrays: linear in distance between pos and the end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of erase for different JSON
+    types.,erase__IteratorType}
+    */
+    template <class InteratorType, typename
+              std::enable_if<
+                  std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+                  std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+                  , int>::type
+              = 0>
+    InteratorType erase(InteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (this != pos.m_object)
+        {
+            throw std::domain_error("iterator does not fit current value");
+        }
+
+        InteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            case value_t::number_float:
+            case value_t::boolean:
+            case value_t::string:
+            {
+                if (not pos.m_it.primitive_iterator.is_begin())
+                {
+                    throw std::out_of_range("iterator out of range");
+                }
+
+                if (m_type == value_t::string)
+                {
+                    delete m_value.string;
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            default:
+            {
+                throw std::domain_error("cannot use erase() with " + type_name());
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove elements given an iterator range
+
+    Removes the element specified by the range `[first; last)`. Invalidates
+    iterators and references at or after the point of the erase, including the
+    end() iterator. The iterator @a first does not need to be dereferenceable
+    if `first == last`: erasing an empty range is a no-op.
+
+    If called on a primitive type other than null, the resulting JSON value
+    will be `null`.
+
+    @param[in] first iterator to the beginning of the range to remove
+    @param[in] last iterator past the end of the range to remove
+    @return Iterator following the last removed element. If the iterator @a
+    second refers to the last element, the end() iterator is returned.
+
+    @tparam InteratorType an @ref iterator or @ref const_iterator
+
+    @throw std::domain_error if called on a `null` value
+    @throw std::domain_error if called on iterators which does not belong to
+    the current JSON value
+    @throw std::out_of_range if called on a primitive type with invalid iterators
+    (i.e., if `first != begin()` and `last != end()`)
+
+    @complexity The complexity depends on the type:
+    - objects: `log(size()) + std::distance(first, last)`
+    - arrays: linear in the distance between @a first and @a last, plus linear
+      in the distance between @a last and end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of erase for different JSON
+    types.,erase__IteratorType_IteratorType}
+    */
+    template <class InteratorType, typename
+              std::enable_if<
+                  std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+                  std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+                  , int>::type
+              = 0>
+    InteratorType erase(InteratorType first, InteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (this != first.m_object or this != last.m_object)
+        {
+            throw std::domain_error("iterators do not fit current value");
+        }
+
+        InteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            case value_t::number_float:
+            case value_t::boolean:
+            case value_t::string:
+            {
+                if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+                {
+                    throw std::out_of_range("iterators out of range");
+                }
+
+                if (m_type == value_t::string)
+                {
+                    delete m_value.string;
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+            {
+                throw std::domain_error("cannot use erase with " + type_name());
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove element from a JSON object given a key
+
+    Removes elements from a JSON object with the key value @a key.
+
+    @param[in] key value of the elements to remove
+
+    @return Number of elements removed. If ObjectType is the default `std::map`
+    type, the return value will always be `0` (@a key was not found) or `1` (@a
+    key was found).
+
+    @throw std::domain_error when called on a type other than JSON object
+
+    @complexity `log(size()) + count(key)`
+
+    @liveexample{The example shows the effect of erase.,erase__key_type}
+    */
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use erase() with " + type_name());
+        }
+
+        return m_value.object->erase(key);
+    }
+
+    /*!
+    @brief remove element from a JSON array given an index
+
+    Removes element from a JSON array at the index @a idx.
+
+    @param[in] idx index of the element to remove
+
+    @throw std::domain_error when called on a type other than JSON array
+    @throw std::out_of_range when `idx >= size()`
+
+    @complexity Linear in distance between @a idx and the end of the container.
+
+    @liveexample{The example shows the effect of erase.,erase__size_type}
+    */
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use erase() with " + type_name());
+        }
+
+        if (idx >= size())
+        {
+            throw std::out_of_range("index out of range");
+        }
+
+        m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+    }
+
+    /*!
+    @brief find an element in a JSON object
+
+    Finds an element in a JSON object with key equivalent to @a key. If the
+    element is not found or the JSON value is not an object, end() is returned.
+
+    @param[in] key key value of the element to search for
+
+    @return Iterator to an element with key equivalent to @a key. If no such
+    element is found, past-the-end (see end()) iterator is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how find is used.,find__key_type}
+    */
+    iterator find(typename object_t::key_type key)
+    {
+        auto result = end();
+
+        if (m_type == value_t::object)
+        {
+            result.m_it.object_iterator = m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief find an element in a JSON object
+    @copydoc find(typename object_t::key_type)
+    */
+    const_iterator find(typename object_t::key_type key) const
+    {
+        auto result = cend();
+
+        if (m_type == value_t::object)
+        {
+            result.m_it.object_iterator = m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief returns the number of occurrences of a key in a JSON object
+
+    Returns the number of elements with key @a key. If ObjectType is the
+    default `std::map` type, the return value will always be `0` (@a key was
+    not found) or `1` (@a key was found).
+
+    @param[in] key key value of the element to count
+
+    @return Number of elements with key @a key. If the JSON value is not an
+    object, the return value will be `0`.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how count is used.,count}
+    */
+    size_type count(typename object_t::key_type key) const
+    {
+        // return 0 for all nonobject types
+        return (m_type == value_t::object) ? m_value.object->count(key) : 0;
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /*!
+    @brief returns an iterator to the first element
+
+    Returns an iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for @ref begin.,begin}
+    */
+    iterator begin()
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cbegin()
+    */
+    const_iterator begin() const
+    {
+        return cbegin();
+    }
+
+    /*!
+    @brief returns a const iterator to the first element
+
+    Returns a const iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+    @liveexample{The following code shows an example for @ref cbegin.,cbegin}
+    */
+    const_iterator cbegin() const
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to one past the last element
+
+    Returns an iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for @ref end.,end}
+    */
+    iterator end()
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cend()
+    */
+    const_iterator end() const
+    {
+        return cend();
+    }
+
+    /*!
+    @brief returns a const iterator to one past the last element
+
+    Returns a const iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+    @liveexample{The following code shows an example for @ref cend.,cend}
+    */
+    const_iterator cend() const
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-beginning
+
+    Returns an iterator to the reverse-beginning; that is, the last element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function satisfies the ReversibleContainer requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(end())`.
+
+    @liveexample{The following code shows an example for @ref rbegin.,rbegin}
+    */
+    reverse_iterator rbegin()
+    {
+        return reverse_iterator(end());
+    }
+
+    /*!
+    @copydoc basic_json::crbegin()
+    */
+    const_reverse_iterator rbegin() const
+    {
+        return crbegin();
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-end
+
+    Returns an iterator to the reverse-end; that is, one before the first
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function satisfies the ReversibleContainer requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(begin())`.
+
+    @liveexample{The following code shows an example for @ref rend.,rend}
+    */
+    reverse_iterator rend()
+    {
+        return reverse_iterator(begin());
+    }
+
+    /*!
+    @copydoc basic_json::crend()
+    */
+    const_reverse_iterator rend() const
+    {
+        return crend();
+    }
+
+    /*!
+    @brief returns a const reverse iterator to the last element
+
+    Returns a const iterator to the reverse-beginning; that is, the last
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function satisfies the ReversibleContainer requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+    @liveexample{The following code shows an example for @ref crbegin.,crbegin}
+    */
+    const_reverse_iterator crbegin() const
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /*!
+    @brief returns a const reverse iterator to one before the first
+
+    Returns a const reverse iterator to the reverse-end; that is, one before
+    the first element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function satisfies the ReversibleContainer requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+    @liveexample{The following code shows an example for @ref crend.,crend}
+    */
+    const_reverse_iterator crend() const
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /*!
+    @brief checks whether the container is empty
+
+    Checks if a JSON value has no elements.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | @c true
+            boolean     | @c false
+            string      | @c false
+            number      | @c false
+            object      | result of function object_t::empty()
+            array       | result of function array_t::empty()
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+                Container concept; that is, their empty() functions have
+                constant complexity.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - Has the semantics of `begin() == end()`.
+
+    @liveexample{The following code uses @ref empty to check if a @ref json
+    object contains any elements.,empty}
+    */
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case (value_t::null):
+            {
+                return true;
+            }
+
+            case (value_t::array):
+            {
+                return m_value.array->empty();
+            }
+
+            case (value_t::object):
+            {
+                return m_value.object->empty();
+            }
+
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the number of elements
+
+    Returns the number of elements in a JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | @c 0
+            boolean     | @c 1
+            string      | @c 1
+            number      | @c 1
+            object      | result of function object_t::size()
+            array       | result of function array_t::size()
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+                Container concept; that is, their size() functions have
+                constant complexity.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - Has the semantics of `std::distance(begin(), end())`.
+
+    @liveexample{The following code calls @ref size on the different value
+    types.,size}
+    */
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case (value_t::null):
+            {
+                return 0;
+            }
+
+            case (value_t::array):
+            {
+                return m_value.array->size();
+            }
+
+            case (value_t::object):
+            {
+                return m_value.object->size();
+            }
+
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the maximum possible number of elements
+
+    Returns the maximum number of elements a JSON value is able to hold due to
+    system or library implementation limitations, i.e. `std::distance(begin(),
+    end())` for the JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | @c 0 (same as size())
+            boolean     | @c 1 (same as size())
+            string      | @c 1 (same as size())
+            number      | @c 1 (same as size())
+            object      | result of function object_t::max_size()
+            array       | result of function array_t::max_size()
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+                Container concept; that is, their max_size() functions have
+                constant complexity.
+
+    @requirement This function satisfies the Container requirements:
+    - The complexity is constant.
+    - Has the semantics of returning `b.size()` where `b` is the largest
+      possible JSON value.
+
+    @liveexample{The following code calls @ref max_size on the different value
+    types. Note the output is implementation specific.,max_size}
+    */
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case (value_t::array):
+            {
+                return m_value.array->max_size();
+            }
+
+            case (value_t::object):
+            {
+                return m_value.object->max_size();
+            }
+
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /*!
+    @brief clears the contents
+
+    Clears the content of a JSON value and resets it to the default value as
+    if @ref basic_json(value_t) would have been called:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @note Floating-point numbers are set to `0.0` which will be serialized to
+    `0`. The vale type remains @ref number_float_t.
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows the effect of @ref clear to different
+    JSON types.,clear}
+    */
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case (value_t::null):
+            case (value_t::discarded):
+            {
+                break;
+            }
+
+            case (value_t::number_integer):
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case (value_t::number_float):
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case (value_t::boolean):
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case (value_t::string):
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case (value_t::array):
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case (value_t::object):
+            {
+                m_value.object->clear();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Appends the given element @a value to the end of the JSON value. If the
+    function is called on a JSON null value, an empty array is created before
+    appending @a value.
+
+    @param value the value to add to the JSON array
+
+    @throw std::domain_error when called on a type other than JSON array or null
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back` and `+=` can be used to add
+    elements to a JSON array. Note how the `null` value was silently converted
+    to a JSON array.,push_back}
+    */
+    void push_back(basic_json&& value)
+    {
+        // push_back only works for null objects or arrays
+        if (not(m_type == value_t::null or m_type == value_t::array))
+        {
+            throw std::domain_error("cannot use push_back() with " + type_name());
+        }
+
+        // transform null object into an array
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+        }
+
+        // add element to array (move semantics)
+        m_value.array->push_back(std::move(value));
+        // invalidate object
+        value.m_type = value_t::null;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(basic_json&& value)
+    {
+        push_back(std::move(value));
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    void push_back(const basic_json& value)
+    {
+        // push_back only works for null objects or arrays
+        if (not(m_type == value_t::null or m_type == value_t::array))
+        {
+            throw std::domain_error("cannot use push_back() with " + type_name());
+        }
+
+        // transform null object into an array
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+        }
+
+        // add element to array
+        m_value.array->push_back(value);
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(const basic_json& value)
+    {
+        push_back(value);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    Inserts the given element @a value to the JSON object. If the function is
+    called on a JSON null value, an empty object is created before inserting @a
+    value.
+
+    @param[in] value the value to add to the JSON object
+
+    @throw std::domain_error when called on a type other than JSON object or
+    null
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `push_back` and `+=` can be used to add
+    elements to a JSON object. Note how the `null` value was silently converted
+    to a JSON object.,push_back__object_t__value}
+    */
+    void push_back(const typename object_t::value_type& value)
+    {
+        // push_back only works for null objects or objects
+        if (not(m_type == value_t::null or m_type == value_t::object))
+        {
+            throw std::domain_error("cannot use push_back() with " + type_name());
+        }
+
+        // transform null object into an object
+        if (m_type == value_t::null)
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+        }
+
+        // add element to array
+        m_value.object->insert(value);
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(const typename object_t::value_type&)
+    */
+    reference operator+=(const typename object_t::value_type& value)
+    {
+        push_back(value);
+        return operator[](value.first);
+    }
+
+    /*!
+    @brief inserts element
+
+    Inserts element @a value before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] value element to insert
+    @return iterator pointing to the inserted @a value.
+
+    @throw std::domain_error if called on JSON values other than arrays
+    @throw std::domain_error if @a pos is not an iterator of *this
+
+    @complexity Constant plus linear in the distance between pos and end of the
+    container.
+
+    @liveexample{The example shows how insert is used.,insert}
+    */
+    iterator insert(const_iterator pos, const basic_json& value)
+    {
+        // insert only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use insert() with " + type_name());
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (pos.m_object != this)
+        {
+            throw std::domain_error("iterator does not fit current value");
+        }
+
+        // insert to array and return iterator
+        iterator result(this);
+        result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, value);
+        return result;
+    }
+
+    /*!
+    @brief inserts element
+    @copydoc insert(const_iterator, const basic_json&)
+    */
+    iterator insert(const_iterator pos, basic_json&& value)
+    {
+        return insert(pos, value);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts @a count copies of @a value before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] count number of copies of @a value to insert
+    @param[in] value element to insert
+    @return iterator pointing to the first element inserted, or @a pos if
+    `count==0`
+
+    @throw std::domain_error if called on JSON values other than arrays
+    @throw std::domain_error if @a pos is not an iterator of *this
+
+    @complexity Linear in @a count plus linear in the distance between @a pos
+    and end of the container.
+
+    @liveexample{The example shows how insert is used.,insert__count}
+    */
+    iterator insert(const_iterator pos, size_type count, const basic_json& value)
+    {
+        // insert only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use insert() with " + type_name());
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (pos.m_object != this)
+        {
+            throw std::domain_error("iterator does not fit current value");
+        }
+
+        // insert to array and return iterator
+        iterator result(this);
+        result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, count, value);
+        return result;
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)` before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw std::domain_error if called on JSON values other than arrays
+    @throw std::domain_error if @a pos is not an iterator of *this
+    @throw std::domain_error if @a first and @a last do not belong to the same
+    JSON value
+    @throw std::domain_error if @a first or @a last are iterators into
+    container for which insert is called
+    @return iterator pointing to the first element inserted, or @a pos if
+    `first==last`
+
+    @complexity Linear in `std::distance(first, last)` plus linear in the
+    distance between @a pos and end of the container.
+
+    @liveexample{The example shows how insert is used.,insert__range}
+    */
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use insert() with " + type_name());
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (pos.m_object != this)
+        {
+            throw std::domain_error("iterator does not fit current value");
+        }
+
+        if (first.m_object != last.m_object)
+        {
+            throw std::domain_error("iterators does not fit");
+        }
+
+        if (first.m_object == this or last.m_object == this)
+        {
+            throw std::domain_error("passed iterators may not belong to container");
+        }
+
+        // insert to array and return iterator
+        iterator result(this);
+        result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator,
+                                     first.m_it.array_iterator, last.m_it.array_iterator);
+        return result;
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from initializer list @a ilist before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] ilist initializer list to insert the values from
+
+    @throw std::domain_error if called on JSON values other than arrays
+    @throw std::domain_error if @a pos is not an iterator of *this
+    @return iterator pointing to the first element inserted, or @a pos if
+    `ilist` is empty
+
+    @complexity Linear in `ilist.size()` plus linear in the distance between @a
+    pos and end of the container.
+
+    @liveexample{The example shows how insert is used.,insert__ilist}
+    */
+    iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
+    {
+        // insert only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use insert() with " + type_name());
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (pos.m_object != this)
+        {
+            throw std::domain_error("iterator does not fit current value");
+        }
+
+        // insert to array and return iterator
+        iterator result(this);
+        result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
+        return result;
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON arrays can be
+    swapped.,swap__reference}
+    */
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON array with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other array to exchange the contents with
+
+    @throw std::domain_error when JSON value is not an array
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be
+    swapped.,swap__array_t}
+    */
+    void swap(array_t& other)
+    {
+        // swap only works for arrays
+        if (m_type != value_t::array)
+        {
+            throw std::domain_error("cannot use swap() with " + type_name());
+        }
+
+        // swap arrays
+        std::swap(*(m_value.array), other);
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON object with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other object to exchange the contents with
+
+    @throw std::domain_error when JSON value is not an object
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be
+    swapped.,swap__object_t}
+    */
+    void swap(object_t& other)
+    {
+        // swap only works for objects
+        if (m_type != value_t::object)
+        {
+            throw std::domain_error("cannot use swap() with " + type_name());
+        }
+
+        // swap objects
+        std::swap(*(m_value.object), other);
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other string to exchange the contents with
+
+    @throw std::domain_error when JSON value is not a string
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be
+    swapped.,swap__string_t}
+    */
+    void swap(string_t& other)
+    {
+        // swap only works for strings
+        if (m_type != value_t::string)
+        {
+            throw std::domain_error("cannot use swap() with " + type_name());
+        }
+
+        // swap strings
+        std::swap(*(m_value.string), other);
+    }
+
+    /// @}
+
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+  private:
+    /*!
+    @brief comparison operator for JSON types
+
+    Returns an ordering that is similar to Python:
+    - order: null < boolean < number < object < array < string
+    - furthermore, each type is not smaller than itself
+    */
+    friend bool operator<(const value_t lhs, const value_t rhs)
+    {
+        static constexpr std::array<uint8_t, 7> order = {{
+                0, // null
+                3, // object
+                4, // array
+                5, // string
+                1, // boolean
+                2, // integer
+                2  // float
+            }
+        };
+
+        // discarded values are not comparable
+        if (lhs == value_t::discarded or rhs == value_t::discarded)
+        {
+            return false;
+        }
+
+        return order[static_cast<std::size_t>(lhs)] < order[static_cast<std::size_t>(rhs)];
+    }
+
+  public:
+    /*!
+    @brief comparison: equal
+
+    Compares two JSON values for equality according to the following rules:
+    - Two JSON values are equal if (1) they are from the same type and (2)
+      their stored values are the same.
+    - Integer and floating-point numbers are automatically converted before
+      comparison. Floating-point numbers are compared indirectly: two
+      floating-point numbers `f1` and `f2` are considered equal if neither
+      `f1 > f2` nor `f2 > f1` holds.
+    - Two JSON null values are equal.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are equal
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__equal}
+    */
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case (value_t::array):
+                    return *lhs.m_value.array == *rhs.m_value.array;
+                case (value_t::object):
+                    return *lhs.m_value.object == *rhs.m_value.object;
+                case (value_t::null):
+                    return true;
+                case (value_t::string):
+                    return *lhs.m_value.string == *rhs.m_value.string;
+                case (value_t::boolean):
+                    return lhs.m_value.boolean == rhs.m_value.boolean;
+                case (value_t::number_integer):
+                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+                case (value_t::number_float):
+                    return approx(lhs.m_value.number_float, rhs.m_value.number_float);
+                case (value_t::discarded):
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return approx(static_cast<number_float_t>(lhs.m_value.number_integer),
+                          rhs.m_value.number_float);
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return approx(lhs.m_value.number_float,
+                          static_cast<number_float_t>(rhs.m_value.number_integer));
+        }
+        return false;
+    }
+
+    /*!
+    @brief comparison: equal
+
+    The functions compares the given JSON value against a null pointer. As the
+    null pointer can be used to initialize a JSON value to null, a comparison
+    of JSON value @a v with a null pointer should be equivalent to call
+    `v.is_null()`.
+
+    @param[in] v  JSON value to consider
+    @return whether @a v is null
+
+    @complexity Constant.
+
+    @liveexample{The example compares several JSON types to the null pointer.
+    ,operator__equal__nullptr_t}
+    */
+    friend bool operator==(const_reference v, std::nullptr_t) noexcept
+    {
+        return v.is_null();
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, std::nullptr_t)
+    */
+    friend bool operator==(std::nullptr_t, const_reference v) noexcept
+    {
+        return v.is_null();
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are not equal
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__notequal}
+    */
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    The functions compares the given JSON value against a null pointer. As the
+    null pointer can be used to initialize a JSON value to null, a comparison
+    of JSON value @a v with a null pointer should be equivalent to call
+    `not v.is_null()`.
+
+    @param[in] v  JSON value to consider
+    @return whether @a v is not null
+
+    @complexity Constant.
+
+    @liveexample{The example compares several JSON types to the null pointer.
+    ,operator__notequal__nullptr_t}
+    */
+    friend bool operator!=(const_reference v, std::nullptr_t) noexcept
+    {
+        return not v.is_null();
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, std::nullptr_t)
+    */
+    friend bool operator!=(std::nullptr_t, const_reference v) noexcept
+    {
+        return not v.is_null();
+    }
+
+    /*!
+    @brief comparison: less than
+
+    Compares whether one JSON value @a lhs is less than another JSON value @a
+    rhs according to the following rules:
+    - If @a lhs and @a rhs have the same type, the values are compared using
+      the default `<` operator.
+    - Integer and floating-point numbers are automatically converted before
+      comparison
+    - In case @a lhs and @a rhs have different types, the values are ignored
+      and the order of the types is considered, see
+      @ref operator<(const value_t, const value_t).
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than @a rhs
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__less}
+    */
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case (value_t::array):
+                    return *lhs.m_value.array < *rhs.m_value.array;
+                case (value_t::object):
+                    return *lhs.m_value.object < *rhs.m_value.object;
+                case (value_t::null):
+                    return false;
+                case (value_t::string):
+                    return *lhs.m_value.string < *rhs.m_value.string;
+                case (value_t::boolean):
+                    return lhs.m_value.boolean < rhs.m_value.boolean;
+                case (value_t::number_integer):
+                    return lhs.m_value.number_integer < rhs.m_value.number_integer;
+                case (value_t::number_float):
+                    return lhs.m_value.number_float < rhs.m_value.number_float;
+                case (value_t::discarded):
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) <
+                   rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float <
+                   static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+
+    Compares whether one JSON value @a lhs is less than or equal to another
+    JSON value by calculating `not (rhs < lhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than or equal to @a rhs
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greater}
+    */
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (rhs < lhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+
+    Compares whether one JSON value @a lhs is greater than another
+    JSON value by calculating `not (lhs <= rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than to @a rhs
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__lessequal}
+    */
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+
+    Compares whether one JSON value @a lhs is greater than or equal to another
+    JSON value by calculating `not (lhs < rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than or equal to @a rhs
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greaterequal}
+    */
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs < rhs);
+    }
+
+    /// @}
+
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+
+    /*!
+    @brief serialize to stream
+
+    Serialize the given JSON value @a j to the output stream @a o. The JSON
+    value will be serialized using the @ref dump member function. The
+    indentation of the output can be controlled with the member variable
+    `width` of the output stream @a o. For instance, using the manipulator
+    `std::setw(4)` on @a o sets the indentation level to `4` and the
+    serialization result is the same as calling `dump(4)`.
+
+    @param[in,out] o  stream to serialize to
+    @param[in] j  JSON value to serialize
+
+    @return the stream @a o
+
+    @complexity Linear.
+
+    @liveexample{The example below shows the serialization with different
+    parameters to `width` to adjust the indentation level.,operator_serialize}
+    */
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = (o.width() > 0);
+        const auto indentation = (pretty_print ? o.width() : 0);
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        j.dump(o, pretty_print, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /*!
+    @brief serialize to stream
+    @copydoc operator<<(std::ostream&, const basic_json&)
+    */
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /*!
+    @brief deserialize from string
+
+    @param[in] s  string to read a serialized JSON value from
+    @param[in] cb a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+
+    @return result of the deserialization
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @liveexample{The example below demonstrates the parse function with and
+    without callback function.,parse__string__parser_callback_t}
+
+    @sa parse(std::istream&, parser_callback_t) for a version that reads from
+    an input stream
+    */
+    static basic_json parse(const string_t& s, parser_callback_t cb = nullptr)
+    {
+        return parser(s, cb).parse();
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    @param[in,out] i  stream to read a serialized JSON value from
+    @param[in] cb a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+
+    @return result of the deserialization
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @liveexample{The example below demonstrates the parse function with and
+    without callback function.,parse__istream__parser_callback_t}
+
+    @sa parse(const string_t&, parser_callback_t) for a version that reads
+    from a string
+    */
+    static basic_json parse(std::istream& i, parser_callback_t cb = nullptr)
+    {
+        return parser(i, cb).parse();
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    Deserializes an input stream to a JSON value.
+
+    @param[in,out] i  input stream to read a serialized JSON value from
+    @param[in,out] j  JSON value to write the deserialized input to
+
+    @throw std::invalid_argument in case of parse errors
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @liveexample{The example below shows how a JSON value is constructed by
+    reading a serialization from a stream.,operator_deserialize}
+
+    @sa parse(std::istream&, parser_callback_t) for a variant with a parser
+    callback function to filter values while parsing
+    */
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        j = parser(i).parse();
+        return i;
+    }
+
+    /*!
+    @brief deserialize from stream
+    @copydoc operator<<(basic_json&, std::istream&)
+    */
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        j = parser(i).parse();
+        return i;
+    }
+
+    /// @}
+
+
+  private:
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// return the type as string
+    string_t type_name() const
+    {
+        switch (m_type)
+        {
+            case (value_t::null):
+            {
+                return "null";
+            }
+
+            case (value_t::object):
+            {
+                return "object";
+            }
+
+            case (value_t::array):
+            {
+                return "array";
+            }
+
+            case (value_t::string):
+            {
+                return "string";
+            }
+
+            case (value_t::boolean):
+            {
+                return "boolean";
+            }
+
+            case (value_t::discarded):
+            {
+                return "discarded";
+            }
+
+            default:
+            {
+                return "number";
+            }
+        }
+    }
+
+    /*!
+    @brief calculates the extra space to escape a JSON string
+
+    @param[in] s  the string to escape
+    @return the number of characters required to escape string @a s
+
+    @complexity Linear in the length of string @a s.
+    */
+    static std::size_t extra_space(const string_t& s) noexcept
+    {
+        std::size_t result = 0;
+
+        for (const auto& c : s)
+        {
+            switch (c)
+            {
+                case '"':
+                case '\\':
+                case '\b':
+                case '\f':
+                case '\n':
+                case '\r':
+                case '\t':
+                {
+                    // from c (1 byte) to \x (2 bytes)
+                    result += 1;
+                    break;
+                }
+
+                default:
+                {
+                    if (c >= 0x00 and c <= 0x1f)
+                    {
+                        // from c (1 byte) to \uxxxx (6 bytes)
+                        result += 5;
+                    }
+                    break;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief escape a string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation.
+
+    @param[in] s  the string to escape
+    @return  the escaped string
+
+    @complexity Linear in the length of string @a s.
+    */
+    static string_t escape_string(const string_t& s) noexcept
+    {
+        const auto space = extra_space(s);
+        if (space == 0)
+        {
+            return s;
+        }
+
+        // create a result string of necessary size
+        string_t result(s.size() + space, '\\');
+        std::size_t pos = 0;
+
+        for (const auto& c : s)
+        {
+            switch (c)
+            {
+                // quotation mark (0x22)
+                case '"':
+                {
+                    result[pos + 1] = '"';
+                    pos += 2;
+                    break;
+                }
+
+                // reverse solidus (0x5c)
+                case '\\':
+                {
+                    // nothing to change
+                    pos += 2;
+                    break;
+                }
+
+                // backspace (0x08)
+                case '\b':
+                {
+                    result[pos + 1] = 'b';
+                    pos += 2;
+                    break;
+                }
+
+                // formfeed (0x0c)
+                case '\f':
+                {
+                    result[pos + 1] = 'f';
+                    pos += 2;
+                    break;
+                }
+
+                // newline (0x0a)
+                case '\n':
+                {
+                    result[pos + 1] = 'n';
+                    pos += 2;
+                    break;
+                }
+
+                // carriage return (0x0d)
+                case '\r':
+                {
+                    result[pos + 1] = 'r';
+                    pos += 2;
+                    break;
+                }
+
+                // horizontal tab (0x09)
+                case '\t':
+                {
+                    result[pos + 1] = 't';
+                    pos += 2;
+                    break;
+                }
+
+                default:
+                {
+                    if (c >= 0x00 and c <= 0x1f)
+                    {
+                        // print character c as \uxxxx
+                        sprintf(&result[pos + 1], "u%04x", int(c));
+                        pos += 6;
+                        // overwrite trailing null character
+                        result[pos] = '\\';
+                    }
+                    else
+                    {
+                        // all other characters are added as-is
+                        result[pos++] = c;
+                    }
+                    break;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serializaion internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is called
+    recursively. Note that
+
+    - strings and object keys are escaped using escape_string()
+    - integer numbers are converted implictly via operator<<
+    - floating-point numbers are converted to a string using "%g" format
+
+    @param[out] o              stream to write to
+    @param[in] pretty_print    whether the output shall be pretty-printed
+    @param[in] indent_step     the indent level
+    @param[in] current_indent  the current indent level (only used internally)
+    */
+    void dump(std::ostream& o, const bool pretty_print, const unsigned int indent_step,
+              const unsigned int current_indent = 0) const
+    {
+        // variable to hold indentation for recursive calls
+        unsigned int new_indent = current_indent;
+
+        switch (m_type)
+        {
+            case (value_t::object):
+            {
+                if (m_value.object->empty())
+                {
+                    o << "{}";
+                    return;
+                }
+
+                o << "{";
+
+                // increase indentation
+                if (pretty_print)
+                {
+                    new_indent += indent_step;
+                    o << "\n";
+                }
+
+                for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
+                {
+                    if (i != m_value.object->cbegin())
+                    {
+                        o << (pretty_print ? ",\n" : ",");
+                    }
+                    o << string_t(new_indent, ' ') << "\""
+                      << escape_string(i->first) << "\":"
+                      << (pretty_print ? " " : "");
+                    i->second.dump(o, pretty_print, indent_step, new_indent);
+                }
+
+                // decrease indentation
+                if (pretty_print)
+                {
+                    new_indent -= indent_step;
+                    o << "\n";
+                }
+
+                o << string_t(new_indent, ' ') + "}";
+                return;
+            }
+
+            case (value_t::array):
+            {
+                if (m_value.array->empty())
+                {
+                    o << "[]";
+                    return;
+                }
+
+                o << "[";
+
+                // increase indentation
+                if (pretty_print)
+                {
+                    new_indent += indent_step;
+                    o << "\n";
+                }
+
+                for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
+                {
+                    if (i != m_value.array->cbegin())
+                    {
+                        o << (pretty_print ? ",\n" : ",");
+                    }
+                    o << string_t(new_indent, ' ');
+                    i->dump(o, pretty_print, indent_step, new_indent);
+                }
+
+                // decrease indentation
+                if (pretty_print)
+                {
+                    new_indent -= indent_step;
+                    o << "\n";
+                }
+
+                o << string_t(new_indent, ' ') << "]";
+                return;
+            }
+
+            case (value_t::string):
+            {
+                o << string_t("\"") << escape_string(*m_value.string) << "\"";
+                return;
+            }
+
+            case (value_t::boolean):
+            {
+                o << (m_value.boolean ? "true" : "false");
+                return;
+            }
+
+            case (value_t::number_integer):
+            {
+                o << m_value.number_integer;
+                return;
+            }
+
+            case (value_t::number_float):
+            {
+                // 15 digits of precision allows round-trip IEEE 754
+                // string->double->string; to be safe, we read this value from
+                // std::numeric_limits<number_float_t>::digits10
+                o << std::setprecision(std::numeric_limits<number_float_t>::digits10) << m_value.number_float;
+                return;
+            }
+
+            case (value_t::discarded):
+            {
+                o << "<discarded>";
+                return;
+            }
+
+            default:
+            {
+                o << "null";
+                return;
+            }
+        }
+    }
+
+  private:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+
+  private:
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /*!
+    @brief an iterator for primitive JSON types
+
+    This class models an iterator for primitive JSON types (boolean, number,
+    string). It's only purpose is to allow the iterator/const_iterator classes
+    to "iterate" over primitive values. Internally, the iterator is modeled by
+    a `difference_type` variable. Value begin_value (`0`) models the begin,
+    end_value (`1`) models past the end.
+    */
+    class primitive_iterator_t
+    {
+      public:
+        /// set iterator to a defined beginning
+        void set_begin()
+        {
+            m_it = begin_value;
+        }
+
+        /// set iterator to a defined past the end
+        void set_end()
+        {
+            m_it = end_value;
+        }
+
+        /// return whether the iterator can be dereferenced
+        bool is_begin() const
+        {
+            return (m_it == begin_value);
+        }
+
+        /// return whether the iterator is at end
+        bool is_end() const
+        {
+            return (m_it == end_value);
+        }
+
+        /// return reference to the value to change and compare
+        operator difference_type& ()
+        {
+            return m_it;
+        }
+
+        /// return value to compare
+        operator difference_type () const
+        {
+            return m_it;
+        }
+
+      private:
+        static constexpr difference_type begin_value = 0;
+        static constexpr difference_type end_value = begin_value + 1;
+
+        /// iterator as signed integer type
+        difference_type m_it = std::numeric_limits<std::ptrdiff_t>::min();
+    };
+
+    /*!
+    @brief an iterator value
+
+    @note This structure could easily be a union, but MSVC currently does not
+    allow unions members with complex constructors, see
+    https://github.com/nlohmann/json/pull/105.
+    */
+    struct internal_iterator
+    {
+        /// iterator for JSON objects
+        typename object_t::iterator object_iterator;
+        /// iterator for JSON arrays
+        typename array_t::iterator array_iterator;
+        /// generic iterator for all other types
+        primitive_iterator_t primitive_iterator;
+
+        /// create an uninitialized internal_iterator
+        internal_iterator()
+            : object_iterator(), array_iterator(), primitive_iterator()
+        {}
+    };
+
+  public:
+    /*!
+    @brief a const random access iterator for the @ref basic_json class
+
+    This class implements a const iterator for the @ref basic_json class. From
+    this class, the @ref iterator class is derived.
+
+    @requirement The class satisfies the following concept requirements:
+    - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+      The iterator that can be moved to point (forward and backward) to any
+      element in constant time.
+    */
+    class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
+    {
+        /// allow basic_json to access private members
+        friend class basic_json;
+
+      public:
+        /// the type of the values when the iterator is dereferenced
+        using value_type = typename basic_json::value_type;
+        /// a type to represent differences between iterators
+        using difference_type = typename basic_json::difference_type;
+        /// defines a pointer to the type iterated over (value_type)
+        using pointer = typename basic_json::const_pointer;
+        /// defines a reference to the type iterated over (value_type)
+        using reference = typename basic_json::const_reference;
+        /// the category of the iterator
+        using iterator_category = std::bidirectional_iterator_tag;
+
+        /// default constructor
+        const_iterator() = default;
+
+        /// constructor for a given JSON instance
+        const_iterator(pointer object) : m_object(object)
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    m_it.object_iterator = typename object_t::iterator();
+                    break;
+                }
+                case (basic_json::value_t::array):
+                {
+                    m_it.array_iterator = typename array_t::iterator();
+                    break;
+                }
+                default:
+                {
+                    m_it.primitive_iterator = primitive_iterator_t();
+                    break;
+                }
+            }
+        }
+
+        /// copy constructor given a nonconst iterator
+        const_iterator(const iterator& other) : m_object(other.m_object)
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    m_it.object_iterator = other.m_it.object_iterator;
+                    break;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    m_it.array_iterator = other.m_it.array_iterator;
+                    break;
+                }
+
+                default:
+                {
+                    m_it.primitive_iterator = other.m_it.primitive_iterator;
+                    break;
+                }
+            }
+        }
+
+        /// copy constructor
+        const_iterator(const const_iterator& other) noexcept
+            : m_object(other.m_object), m_it(other.m_it)
+        {}
+
+        /// copy assignment
+        const_iterator& operator=(const_iterator other) noexcept(
+            std::is_nothrow_move_constructible<pointer>::value and
+            std::is_nothrow_move_assignable<pointer>::value and
+            std::is_nothrow_move_constructible<internal_iterator>::value and
+            std::is_nothrow_move_assignable<internal_iterator>::value
+        )
+        {
+            std::swap(m_object, other.m_object);
+            std::swap(m_it, other.m_it);
+            return *this;
+        }
+
+      private:
+        /// set the iterator to the first value
+        void set_begin()
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    m_it.object_iterator = m_object->m_value.object->begin();
+                    break;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    m_it.array_iterator = m_object->m_value.array->begin();
+                    break;
+                }
+
+                case (basic_json::value_t::null):
+                {
+                    // set to end so begin()==end() is true: null is empty
+                    m_it.primitive_iterator.set_end();
+                    break;
+                }
+
+                default:
+                {
+                    m_it.primitive_iterator.set_begin();
+                    break;
+                }
+            }
+        }
+
+        /// set the iterator past the last value
+        void set_end()
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    m_it.object_iterator = m_object->m_value.object->end();
+                    break;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    m_it.array_iterator = m_object->m_value.array->end();
+                    break;
+                }
+
+                default:
+                {
+                    m_it.primitive_iterator.set_end();
+                    break;
+                }
+            }
+        }
+
+      public:
+        /// return a reference to the value pointed to by the iterator
+        reference operator*() const
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    return m_it.object_iterator->second;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return *m_it.array_iterator;
+                }
+
+                case (basic_json::value_t::null):
+                {
+                    throw std::out_of_range("cannot get value");
+                }
+
+                default:
+                {
+                    if (m_it.primitive_iterator.is_begin())
+                    {
+                        return *m_object;
+                    }
+                    else
+                    {
+                        throw std::out_of_range("cannot get value");
+                    }
+                }
+            }
+        }
+
+        /// dereference the iterator
+        pointer operator->() const
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    return &(m_it.object_iterator->second);
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return &*m_it.array_iterator;
+                }
+
+                default:
+                {
+                    if (m_it.primitive_iterator.is_begin())
+                    {
+                        return m_object;
+                    }
+                    else
+                    {
+                        throw std::out_of_range("cannot get value");
+                    }
+                }
+            }
+        }
+
+        /// post-increment (it++)
+        const_iterator operator++(int)
+        {
+            auto result = *this;
+            ++(*this);
+
+            return result;
+        }
+
+        /// pre-increment (++it)
+        const_iterator& operator++()
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    ++m_it.object_iterator;
+                    break;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    ++m_it.array_iterator;
+                    break;
+                }
+
+                default:
+                {
+                    ++m_it.primitive_iterator;
+                    break;
+                }
+            }
+
+            return *this;
+        }
+
+        /// post-decrement (it--)
+        const_iterator operator--(int)
+        {
+            auto result = *this;
+            --(*this);
+
+            return result;
+        }
+
+        /// pre-decrement (--it)
+        const_iterator& operator--()
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    --m_it.object_iterator;
+                    break;
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    --m_it.array_iterator;
+                    break;
+                }
+
+                default:
+                {
+                    --m_it.primitive_iterator;
+                    break;
+                }
+            }
+
+            return *this;
+        }
+
+        /// comparison: equal
+        bool operator==(const const_iterator& other) const
+        {
+            // if objects are not the same, the comparison is undefined
+            if (m_object != other.m_object)
+            {
+                throw std::domain_error("cannot compare iterators of different containers");
+            }
+
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    return (m_it.object_iterator == other.m_it.object_iterator);
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return (m_it.array_iterator == other.m_it.array_iterator);
+                }
+
+                default:
+                {
+                    return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+                }
+            }
+        }
+
+        /// comparison: not equal
+        bool operator!=(const const_iterator& other) const
+        {
+            return not operator==(other);
+        }
+
+        /// comparison: smaller
+        bool operator<(const const_iterator& other) const
+        {
+            // if objects are not the same, the comparison is undefined
+            if (m_object != other.m_object)
+            {
+                throw std::domain_error("cannot compare iterators of different containers");
+            }
+
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    throw std::domain_error("cannot use operator< for object iterators");
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return (m_it.array_iterator < other.m_it.array_iterator);
+                }
+
+                default:
+                {
+                    return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+                }
+            }
+        }
+
+        /// comparison: less than or equal
+        bool operator<=(const const_iterator& other) const
+        {
+            return not other.operator < (*this);
+        }
+
+        /// comparison: greater than
+        bool operator>(const const_iterator& other) const
+        {
+            return not operator<=(other);
+        }
+
+        /// comparison: greater than or equal
+        bool operator>=(const const_iterator& other) const
+        {
+            return not operator<(other);
+        }
+
+        /// add to iterator
+        const_iterator& operator+=(difference_type i)
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    throw std::domain_error("cannot use operator+= for object iterators");
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    m_it.array_iterator += i;
+                    break;
+                }
+
+                default:
+                {
+                    m_it.primitive_iterator += i;
+                    break;
+                }
+            }
+
+            return *this;
+        }
+
+        /// subtract from iterator
+        const_iterator& operator-=(difference_type i)
+        {
+            return operator+=(-i);
+        }
+
+        /// add to iterator
+        const_iterator operator+(difference_type i)
+        {
+            auto result = *this;
+            result += i;
+            return result;
+        }
+
+        /// subtract from iterator
+        const_iterator operator-(difference_type i)
+        {
+            auto result = *this;
+            result -= i;
+            return result;
+        }
+
+        /// return difference
+        difference_type operator-(const const_iterator& other) const
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    throw std::domain_error("cannot use operator- for object iterators");
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return m_it.array_iterator - other.m_it.array_iterator;
+                }
+
+                default:
+                {
+                    return m_it.primitive_iterator - other.m_it.primitive_iterator;
+                }
+            }
+        }
+
+        /// access to successor
+        reference operator[](difference_type n) const
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    throw std::domain_error("cannot use operator[] for object iterators");
+                }
+
+                case (basic_json::value_t::array):
+                {
+                    return *(m_it.array_iterator + n);
+                }
+
+                case (basic_json::value_t::null):
+                {
+                    throw std::out_of_range("cannot get value");
+                }
+
+                default:
+                {
+                    if (m_it.primitive_iterator == -n)
+                    {
+                        return *m_object;
+                    }
+                    else
+                    {
+                        throw std::out_of_range("cannot get value");
+                    }
+                }
+            }
+        }
+
+        /// return the key of an object iterator
+        typename object_t::key_type key() const
+        {
+            switch (m_object->m_type)
+            {
+                case (basic_json::value_t::object):
+                {
+                    return m_it.object_iterator->first;
+                }
+
+                default:
+                {
+                    throw std::domain_error("cannot use key() for non-object iterators");
+                }
+            }
+        }
+
+        /// return the value of an iterator
+        reference value() const
+        {
+            return operator*();
+        }
+
+      private:
+        /// associated JSON instance
+        pointer m_object = nullptr;
+        /// the actual iterator of the associated instance
+        internal_iterator m_it = internal_iterator();
+    };
+
+    /*!
+    @brief a mutable random access iterator for the @ref basic_json class
+
+    @requirement The class satisfies the following concept requirements:
+    - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+      The iterator that can be moved to point (forward and backward) to any
+      element in constant time.
+    - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
+      It is possible to write to the pointed-to element.
+    */
+    class iterator : public const_iterator
+    {
+      public:
+        using base_iterator = const_iterator;
+        using pointer = typename basic_json::pointer;
+        using reference = typename basic_json::reference;
+
+        /// default constructor
+        iterator() = default;
+
+        /// constructor for a given JSON instance
+        iterator(pointer object) noexcept : base_iterator(object)
+        {}
+
+        /// copy constructor
+        iterator(const iterator& other) noexcept
+            : base_iterator(other)
+        {}
+
+        /// copy assignment
+        iterator& operator=(iterator other) noexcept(
+            std::is_nothrow_move_constructible<pointer>::value and
+            std::is_nothrow_move_assignable<pointer>::value and
+            std::is_nothrow_move_constructible<internal_iterator>::value and
+            std::is_nothrow_move_assignable<internal_iterator>::value
+        )
+        {
+            base_iterator::operator=(other);
+            return *this;
+        }
+
+        /// return a reference to the value pointed to by the iterator
+        reference operator*()
+        {
+            return const_cast<reference>(base_iterator::operator*());
+        }
+
+        /// dereference the iterator
+        pointer operator->()
+        {
+            return const_cast<pointer>(base_iterator::operator->());
+        }
+
+        /// post-increment (it++)
+        iterator operator++(int)
+        {
+            iterator result = *this;
+            base_iterator::operator++();
+            return result;
+        }
+
+        /// pre-increment (++it)
+        iterator& operator++()
+        {
+            base_iterator::operator++();
+            return *this;
+        }
+
+        /// post-decrement (it--)
+        iterator operator--(int)
+        {
+            iterator result = *this;
+            base_iterator::operator--();
+            return result;
+        }
+
+        /// pre-decrement (--it)
+        iterator& operator--()
+        {
+            base_iterator::operator--();
+            return *this;
+        }
+
+        /// add to iterator
+        iterator& operator+=(difference_type i)
+        {
+            base_iterator::operator+=(i);
+            return *this;
+        }
+
+        /// subtract from iterator
+        iterator& operator-=(difference_type i)
+        {
+            base_iterator::operator-=(i);
+            return *this;
+        }
+
+        /// add to iterator
+        iterator operator+(difference_type i)
+        {
+            auto result = *this;
+            result += i;
+            return result;
+        }
+
+        /// subtract from iterator
+        iterator operator-(difference_type i)
+        {
+            auto result = *this;
+            result -= i;
+            return result;
+        }
+
+        difference_type operator-(const iterator& other) const
+        {
+            return base_iterator::operator-(other);
+        }
+
+        /// access to successor
+        reference operator[](difference_type n) const
+        {
+            return const_cast<reference>(base_iterator::operator[](n));
+        }
+
+        /// return the value of an iterator
+        reference value() const
+        {
+            return const_cast<reference>(base_iterator::value());
+        }
+    };
+
+    /*!
+    @brief a template for a reverse iterator class
+
+    @tparam Base the base iterator type to reverse. Valid types are @ref
+    iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+    create @ref const_reverse_iterator).
+
+    @requirement The class satisfies the following concept requirements:
+    - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+      The iterator that can be moved to point (forward and backward) to any
+      element in constant time.
+    - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
+      It is possible to write to the pointed-to element (only if @a Base is
+      @ref iterator).
+    */
+    template<typename Base>
+    class json_reverse_iterator : public std::reverse_iterator<Base>
+    {
+      public:
+        /// shortcut to the reverse iterator adaptor
+        using base_iterator = std::reverse_iterator<Base>;
+        /// the reference type for the pointed-to element
+        using reference = typename Base::reference;
+
+        /// create reverse iterator from iterator
+        json_reverse_iterator(const typename base_iterator::iterator_type& it)
+            : base_iterator(it) {}
+
+        /// create reverse iterator from base class
+        json_reverse_iterator(const base_iterator& it) : base_iterator(it) {}
+
+        /// post-increment (it++)
+        json_reverse_iterator operator++(int)
+        {
+            return base_iterator::operator++(1);
+        }
+
+        /// pre-increment (++it)
+        json_reverse_iterator& operator++()
+        {
+            base_iterator::operator++();
+            return *this;
+        }
+
+        /// post-decrement (it--)
+        json_reverse_iterator operator--(int)
+        {
+            return base_iterator::operator--(1);
+        }
+
+        /// pre-decrement (--it)
+        json_reverse_iterator& operator--()
+        {
+            base_iterator::operator--();
+            return *this;
+        }
+
+        /// add to iterator
+        json_reverse_iterator& operator+=(difference_type i)
+        {
+            base_iterator::operator+=(i);
+            return *this;
+        }
+
+        /// add to iterator
+        json_reverse_iterator operator+(difference_type i) const
+        {
+            auto result = *this;
+            result += i;
+            return result;
+        }
+
+        /// subtract from iterator
+        json_reverse_iterator operator-(difference_type i) const
+        {
+            auto result = *this;
+            result -= i;
+            return result;
+        }
+
+        /// return difference
+        difference_type operator-(const json_reverse_iterator& other) const
+        {
+            return this->base() - other.base();
+        }
+
+        /// access to successor
+        reference operator[](difference_type n) const
+        {
+            return *(this->operator+(n));
+        }
+
+        /// return the key of an object iterator
+        typename object_t::key_type key() const
+        {
+            auto it = --this->base();
+            return it.key();
+        }
+
+        /// return the value of an iterator
+        reference value() const
+        {
+            auto it = --this->base();
+            return it.operator * ();
+        }
+    };
+
+    /*!
+    @brief wrapper to access iterator member functions in range-based for
+
+    This class allows to access @ref key() and @ref value() during range-based
+    for loops. In these loops, a reference to the JSON values is returned, so
+    there is no access to the underlying iterator.
+    */
+    class iterator_wrapper
+    {
+      private:
+        /// the container to iterate
+        basic_json& container;
+        /// the type of the iterator to use while iteration
+        using json_iterator = decltype(std::begin(container));
+
+        /// internal iterator wrapper
+        class iterator_wrapper_internal
+        {
+          private:
+            /// the iterator
+            json_iterator anchor;
+            /// an index for arrays
+            size_t array_index = 0;
+
+          public:
+            /// construct wrapper given an iterator
+            iterator_wrapper_internal(json_iterator i) : anchor(i)
+            {}
+
+            /// dereference operator (needed for range-based for)
+            iterator_wrapper_internal& operator*()
+            {
+                return *this;
+            }
+
+            /// increment operator (needed for range-based for)
+            iterator_wrapper_internal& operator++()
+            {
+                ++anchor;
+                ++array_index;
+
+                return *this;
+            }
+
+            /// inequality operator (needed for range-based for)
+            bool operator!= (const iterator_wrapper_internal& o)
+            {
+                return anchor != o.anchor;
+            }
+
+            /// stream operator
+            friend std::ostream& operator<<(std::ostream& o, const iterator_wrapper_internal& w)
+            {
+                return o << w.value();
+            }
+
+            /// return key of the iterator
+            typename basic_json::string_t key() const
+            {
+                switch (anchor.m_object->type())
+                {
+                    /// use integer array index as key
+                    case (value_t::array):
+                    {
+                        return std::to_string(array_index);
+                    }
+
+                    /// use key from the object
+                    case (value_t::object):
+                    {
+                        return anchor.key();
+                    }
+
+                    /// use an empty key for all primitive types
+                    default:
+                    {
+                        return "";
+                    }
+                }
+            }
+
+            /// return value of the iterator
+            typename json_iterator::reference value() const
+            {
+                return anchor.value();
+            }
+        };
+
+      public:
+        /// construct iterator wrapper from a container
+        iterator_wrapper(basic_json& cont)
+            : container(cont)
+        {}
+
+        /// return iterator begin (needed for range-based for)
+        iterator_wrapper_internal begin()
+        {
+            return iterator_wrapper_internal(container.begin());
+        }
+
+        /// return iterator end (needed for range-based for)
+        iterator_wrapper_internal end()
+        {
+            return iterator_wrapper_internal(container.end());
+        }
+    };
+
+  private:
+    //////////////////////
+    // lexer and parser //
+    //////////////////////
+
+    /*!
+    @brief lexical analysis
+
+    This class organizes the lexical analysis during JSON deserialization. The
+    core of it is a scanner generated by re2c <http://re2c.org> that processes
+    a buffer and recognizes tokens according to RFC 7159.
+    */
+    class lexer
+    {
+      public:
+        /// token types for the parser
+        enum class token_type
+        {
+            uninitialized,    ///< indicating the scanner is uninitialized
+            literal_true,     ///< the "true" literal
+            literal_false,    ///< the "false" literal
+            literal_null,     ///< the "null" literal
+            value_string,     ///< a string - use get_string() for actual value
+            value_number,     ///< a number - use get_number() for actual value
+            begin_array,      ///< the character for array begin "["
+            begin_object,     ///< the character for object begin "{"
+            end_array,        ///< the character for array end "]"
+            end_object,       ///< the character for object end "}"
+            name_separator,   ///< the name separator ":"
+            value_separator,  ///< the value separator ","
+            parse_error,      ///< indicating a parse error
+            end_of_input      ///< indicating the end of the input buffer
+        };
+
+        /// the char type to use in the lexer
+        using lexer_char_t = unsigned char;
+
+        /// constructor with a given buffer
+        explicit lexer(const string_t& s) noexcept
+            : m_stream(nullptr), m_buffer(s)
+        {
+            m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
+            m_start = m_cursor = m_content;
+            m_limit = m_content + s.size();
+        }
+        explicit lexer(std::istream* s) noexcept
+            : m_stream(s), m_buffer()
+        {
+            getline(*m_stream, m_buffer);
+            m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+            m_start = m_cursor = m_content;
+            m_limit = m_content + m_buffer.size();
+        }
+
+        /// default constructor
+        lexer() = default;
+
+        // switch of unwanted functions
+        lexer(const lexer&) = delete;
+        lexer operator=(const lexer&) = delete;
+
+        /*!
+        @brief create a string from a Unicode code point
+
+        @param[in] codepoint1  the code point (can be high surrogate)
+        @param[in] codepoint2  the code point (can be low surrogate or 0)
+        @return string representation of the code point
+        @throw std::out_of_range if code point is >0x10ffff
+        @throw std::invalid_argument if the low surrogate is invalid
+
+        @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
+        */
+        static string_t to_unicode(const std::size_t codepoint1,
+                                   const std::size_t codepoint2 = 0)
+        {
+            string_t result;
+
+            // calculate the codepoint from the given code points
+            std::size_t codepoint = codepoint1;
+
+            // check if codepoint1 is a high surrogate
+            if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
+            {
+                // check if codepoint2 is a low surrogate
+                if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
+                {
+                    codepoint =
+                        // high surrogate occupies the most significant 22 bits
+                        (codepoint1 << 10)
+                        // low surrogate occupies the least significant 15 bits
+                        + codepoint2
+                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                        // in the result so we have to substract with:
+                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                        - 0x35FDC00;
+                }
+                else
+                {
+                    throw std::invalid_argument("missing or wrong low surrogate");
+                }
+            }
+
+            if (codepoint < 0x80)
+            {
+                // 1-byte characters: 0xxxxxxx (ASCII)
+                result.append(1, static_cast<typename string_t::value_type>(codepoint));
+            }
+            else if (codepoint <= 0x7ff)
+            {
+                // 2-byte characters: 110xxxxx 10xxxxxx
+                result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+            }
+            else if (codepoint <= 0xffff)
+            {
+                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+            }
+            else if (codepoint <= 0x10ffff)
+            {
+                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+            }
+            else
+            {
+                throw std::out_of_range("code points above 0x10FFFF are invalid");
+            }
+
+            return result;
+        }
+
+        /// return name of values of type token_type
+        static std::string token_type_name(token_type t)
+        {
+            switch (t)
+            {
+                case (token_type::uninitialized):
+                    return "<uninitialized>";
+                case (token_type::literal_true):
+                    return "true literal";
+                case (token_type::literal_false):
+                    return "false literal";
+                case (token_type::literal_null):
+                    return "null literal";
+                case (token_type::value_string):
+                    return "string literal";
+                case (token_type::value_number):
+                    return "number literal";
+                case (token_type::begin_array):
+                    return "[";
+                case (token_type::begin_object):
+                    return "{";
+                case (token_type::end_array):
+                    return "]";
+                case (token_type::end_object):
+                    return "}";
+                case (token_type::name_separator):
+                    return ":";
+                case (token_type::value_separator):
+                    return ",";
+                case (token_type::end_of_input):
+                    return "<end of input>";
+                default:
+                    return "<parse error>";
+            }
+        }
+
+        /*!
+        This function implements a scanner for JSON. It is specified using
+        regular expressions that try to follow RFC 7159 as close as possible.
+        These regular expressions are then translated into a deterministic
+        finite automaton (DFA) by the tool re2c <http://re2c.org>. As a result,
+        the translated code for this function consists of a large block of code
+        with goto jumps.
+
+        @return the class of the next token read from the buffer
+        */
+        token_type scan() noexcept
+        {
+            // pointer for backtracking information
+            m_marker = nullptr;
+
+            // remember the begin of the token
+            m_start = m_cursor;
+
+
+            {
+                lexer_char_t yych;
+                unsigned int yyaccept = 0;
+                static const unsigned char yybm[] =
+                {
+                    0,   0,   0,   0,   0,   0,   0,   0,
+                    0,  32,  32,   0,   0,  32,   0,   0,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    96,  64,   0,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    192, 192, 192, 192, 192, 192, 192, 192,
+                    192, 192,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,   0,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                    64,  64,  64,  64,  64,  64,  64,  64,
+                };
+
+                if ((m_limit - m_cursor) < 5)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '9')
+                {
+                    if (yych <= ' ')
+                    {
+                        if (yych <= '\n')
+                        {
+                            if (yych <= 0x00)
+                            {
+                                goto basic_json_parser_27;
+                            }
+                            if (yych <= 0x08)
+                            {
+                                goto basic_json_parser_29;
+                            }
+                            if (yych >= '\n')
+                            {
+                                goto basic_json_parser_4;
+                            }
+                        }
+                        else
+                        {
+                            if (yych == '\r')
+                            {
+                                goto basic_json_parser_2;
+                            }
+                            if (yych <= 0x1F)
+                            {
+                                goto basic_json_parser_29;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (yych <= ',')
+                        {
+                            if (yych == '"')
+                            {
+                                goto basic_json_parser_26;
+                            }
+                            if (yych <= '+')
+                            {
+                                goto basic_json_parser_29;
+                            }
+                            goto basic_json_parser_14;
+                        }
+                        else
+                        {
+                            if (yych <= '-')
+                            {
+                                goto basic_json_parser_22;
+                            }
+                            if (yych <= '/')
+                            {
+                                goto basic_json_parser_29;
+                            }
+                            if (yych <= '0')
+                            {
+                                goto basic_json_parser_23;
+                            }
+                            goto basic_json_parser_25;
+                        }
+                    }
+                }
+                else
+                {
+                    if (yych <= 'm')
+                    {
+                        if (yych <= '\\')
+                        {
+                            if (yych <= ':')
+                            {
+                                goto basic_json_parser_16;
+                            }
+                            if (yych == '[')
+                            {
+                                goto basic_json_parser_6;
+                            }
+                            goto basic_json_parser_29;
+                        }
+                        else
+                        {
+                            if (yych <= ']')
+                            {
+                                goto basic_json_parser_8;
+                            }
+                            if (yych == 'f')
+                            {
+                                goto basic_json_parser_21;
+                            }
+                            goto basic_json_parser_29;
+                        }
+                    }
+                    else
+                    {
+                        if (yych <= 'z')
+                        {
+                            if (yych <= 'n')
+                            {
+                                goto basic_json_parser_18;
+                            }
+                            if (yych == 't')
+                            {
+                                goto basic_json_parser_20;
+                            }
+                            goto basic_json_parser_29;
+                        }
+                        else
+                        {
+                            if (yych <= '{')
+                            {
+                                goto basic_json_parser_10;
+                            }
+                            if (yych == '}')
+                            {
+                                goto basic_json_parser_12;
+                            }
+                            goto basic_json_parser_29;
+                        }
+                    }
+                }
+basic_json_parser_2:
+                ++m_cursor;
+                yych = *m_cursor;
+                goto basic_json_parser_5;
+basic_json_parser_3:
+                {
+                    return scan();
+                }
+basic_json_parser_4:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+basic_json_parser_5:
+                if (yybm[0 + yych] & 32)
+                {
+                    goto basic_json_parser_4;
+                }
+                goto basic_json_parser_3;
+basic_json_parser_6:
+                ++m_cursor;
+                {
+                    return token_type::begin_array;
+                }
+basic_json_parser_8:
+                ++m_cursor;
+                {
+                    return token_type::end_array;
+                }
+basic_json_parser_10:
+                ++m_cursor;
+                {
+                    return token_type::begin_object;
+                }
+basic_json_parser_12:
+                ++m_cursor;
+                {
+                    return token_type::end_object;
+                }
+basic_json_parser_14:
+                ++m_cursor;
+                {
+                    return token_type::value_separator;
+                }
+basic_json_parser_16:
+                ++m_cursor;
+                {
+                    return token_type::name_separator;
+                }
+basic_json_parser_18:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'u')
+                {
+                    goto basic_json_parser_59;
+                }
+basic_json_parser_19:
+                {
+                    return token_type::parse_error;
+                }
+basic_json_parser_20:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'r')
+                {
+                    goto basic_json_parser_55;
+                }
+                goto basic_json_parser_19;
+basic_json_parser_21:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'a')
+                {
+                    goto basic_json_parser_50;
+                }
+                goto basic_json_parser_19;
+basic_json_parser_22:
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_19;
+                }
+                if (yych <= '0')
+                {
+                    goto basic_json_parser_49;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_40;
+                }
+                goto basic_json_parser_19;
+basic_json_parser_23:
+                yyaccept = 1;
+                yych = *(m_marker = ++m_cursor);
+                if (yych <= 'D')
+                {
+                    if (yych == '.')
+                    {
+                        goto basic_json_parser_42;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                }
+basic_json_parser_24:
+                {
+                    return token_type::value_number;
+                }
+basic_json_parser_25:
+                yyaccept = 1;
+                yych = *(m_marker = ++m_cursor);
+                goto basic_json_parser_41;
+basic_json_parser_26:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych <= 0x0F)
+                {
+                    goto basic_json_parser_19;
+                }
+                goto basic_json_parser_31;
+basic_json_parser_27:
+                ++m_cursor;
+                {
+                    return token_type::end_of_input;
+                }
+basic_json_parser_29:
+                yych = *++m_cursor;
+                goto basic_json_parser_19;
+basic_json_parser_30:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+basic_json_parser_31:
+                if (yybm[0 + yych] & 64)
+                {
+                    goto basic_json_parser_30;
+                }
+                if (yych <= 0x0F)
+                {
+                    goto basic_json_parser_32;
+                }
+                if (yych <= '"')
+                {
+                    goto basic_json_parser_34;
+                }
+                goto basic_json_parser_33;
+basic_json_parser_32:
+                m_cursor = m_marker;
+                if (yyaccept == 0)
+                {
+                    goto basic_json_parser_19;
+                }
+                else
+                {
+                    goto basic_json_parser_24;
+                }
+basic_json_parser_33:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= 'e')
+                {
+                    if (yych <= '/')
+                    {
+                        if (yych == '"')
+                        {
+                            goto basic_json_parser_30;
+                        }
+                        if (yych <= '.')
+                        {
+                            goto basic_json_parser_32;
+                        }
+                        goto basic_json_parser_30;
+                    }
+                    else
+                    {
+                        if (yych <= '\\')
+                        {
+                            if (yych <= '[')
+                            {
+                                goto basic_json_parser_32;
+                            }
+                            goto basic_json_parser_30;
+                        }
+                        else
+                        {
+                            if (yych == 'b')
+                            {
+                                goto basic_json_parser_30;
+                            }
+                            goto basic_json_parser_32;
+                        }
+                    }
+                }
+                else
+                {
+                    if (yych <= 'q')
+                    {
+                        if (yych <= 'f')
+                        {
+                            goto basic_json_parser_30;
+                        }
+                        if (yych == 'n')
+                        {
+                            goto basic_json_parser_30;
+                        }
+                        goto basic_json_parser_32;
+                    }
+                    else
+                    {
+                        if (yych <= 's')
+                        {
+                            if (yych <= 'r')
+                            {
+                                goto basic_json_parser_30;
+                            }
+                            goto basic_json_parser_32;
+                        }
+                        else
+                        {
+                            if (yych <= 't')
+                            {
+                                goto basic_json_parser_30;
+                            }
+                            if (yych <= 'u')
+                            {
+                                goto basic_json_parser_36;
+                            }
+                            goto basic_json_parser_32;
+                        }
+                    }
+                }
+basic_json_parser_34:
+                ++m_cursor;
+                {
+                    return token_type::value_string;
+                }
+basic_json_parser_36:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= ':')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_37;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= 'g')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+basic_json_parser_37:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= ':')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_38;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= 'g')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+basic_json_parser_38:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= ':')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_39;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych >= 'g')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+basic_json_parser_39:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    goto basic_json_parser_32;
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= 'f')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    goto basic_json_parser_32;
+                }
+basic_json_parser_40:
+                yyaccept = 1;
+                m_marker = ++m_cursor;
+                if ((m_limit - m_cursor) < 3)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+basic_json_parser_41:
+                if (yybm[0 + yych] & 128)
+                {
+                    goto basic_json_parser_40;
+                }
+                if (yych <= 'D')
+                {
+                    if (yych != '.')
+                    {
+                        goto basic_json_parser_24;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    goto basic_json_parser_24;
+                }
+basic_json_parser_42:
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_32;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_47;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_43:
+                yych = *++m_cursor;
+                if (yych <= ',')
+                {
+                    if (yych != '+')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                }
+                else
+                {
+                    if (yych <= '-')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_45;
+                    }
+                    goto basic_json_parser_32;
+                }
+basic_json_parser_44:
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_32;
+                }
+                if (yych >= ':')
+                {
+                    goto basic_json_parser_32;
+                }
+basic_json_parser_45:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_24;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_45;
+                }
+                goto basic_json_parser_24;
+basic_json_parser_47:
+                yyaccept = 1;
+                m_marker = ++m_cursor;
+                if ((m_limit - m_cursor) < 3)
+                {
+                    yyfill();    // LCOV_EXCL_LINE;
+                }
+                yych = *m_cursor;
+                if (yych <= 'D')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_24;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_47;
+                    }
+                    goto basic_json_parser_24;
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    goto basic_json_parser_24;
+                }
+basic_json_parser_49:
+                yyaccept = 1;
+                yych = *(m_marker = ++m_cursor);
+                if (yych <= 'D')
+                {
+                    if (yych == '.')
+                    {
+                        goto basic_json_parser_42;
+                    }
+                    goto basic_json_parser_24;
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    goto basic_json_parser_24;
+                }
+basic_json_parser_50:
+                yych = *++m_cursor;
+                if (yych != 'l')
+                {
+                    goto basic_json_parser_32;
+                }
+                yych = *++m_cursor;
+                if (yych != 's')
+                {
+                    goto basic_json_parser_32;
+                }
+                yych = *++m_cursor;
+                if (yych != 'e')
+                {
+                    goto basic_json_parser_32;
+                }
+                ++m_cursor;
+                {
+                    return token_type::literal_false;
+                }
+basic_json_parser_55:
+                yych = *++m_cursor;
+                if (yych != 'u')
+                {
+                    goto basic_json_parser_32;
+                }
+                yych = *++m_cursor;
+                if (yych != 'e')
+                {
+                    goto basic_json_parser_32;
+                }
+                ++m_cursor;
+                {
+                    return token_type::literal_true;
+                }
+basic_json_parser_59:
+                yych = *++m_cursor;
+                if (yych != 'l')
+                {
+                    goto basic_json_parser_32;
+                }
+                yych = *++m_cursor;
+                if (yych != 'l')
+                {
+                    goto basic_json_parser_32;
+                }
+                ++m_cursor;
+                {
+                    return token_type::literal_null;
+                }
+            }
+
+
+        }
+
+        /// append data from the stream to the internal buffer
+        void yyfill() noexcept
+        {
+            if (not m_stream or not * m_stream)
+            {
+                return;
+            }
+
+            const ssize_t offset_start = m_start - m_content;
+            const ssize_t offset_marker = m_marker - m_start;
+            const ssize_t offset_cursor = m_cursor - m_start;
+
+            m_buffer.erase(0, static_cast<size_t>(offset_start));
+            std::string line;
+            std::getline(*m_stream, line);
+            m_buffer += "\n" + line; // add line with newline symbol
+
+            m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+            m_start  = m_content;
+            m_marker = m_start + offset_marker;
+            m_cursor = m_start + offset_cursor;
+            m_limit  = m_start + m_buffer.size() - 1;
+        }
+
+        /// return string representation of last read token
+        string_t get_token() const noexcept
+        {
+            return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
+                            static_cast<size_t>(m_cursor - m_start));
+        }
+
+        /*!
+        @brief return string value for string tokens
+
+        The function iterates the characters between the opening and closing
+        quotes of the string value. The complete string is the range
+        [m_start,m_cursor). Consequently, we iterate from m_start+1 to
+        m_cursor-1.
+
+        We differentiate two cases:
+
+        1. Escaped characters. In this case, a new character is constructed
+           according to the nature of the escape. Some escapes create new
+           characters (e.g., @c "\\n" is replaced by @c "\n"), some are copied
+           as is (e.g., @c "\\\\"). Furthermore, Unicode escapes of the shape
+           @c "\\uxxxx" need special care. In this case, to_unicode takes care
+           of the construction of the values.
+        2. Unescaped characters are copied as is.
+
+        @return string value of current token without opening and closing quotes
+        @throw std::out_of_range if to_unicode fails
+        */
+        string_t get_string() const
+        {
+            string_t result;
+            result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
+
+            // iterate the result between the quotes
+            for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
+            {
+                // process escaped characters
+                if (*i == '\\')
+                {
+                    // read next character
+                    ++i;
+
+                    switch (*i)
+                    {
+                        // the default escapes
+                        case 't':
+                        {
+                            result += "\t";
+                            break;
+                        }
+                        case 'b':
+                        {
+                            result += "\b";
+                            break;
+                        }
+                        case 'f':
+                        {
+                            result += "\f";
+                            break;
+                        }
+                        case 'n':
+                        {
+                            result += "\n";
+                            break;
+                        }
+                        case 'r':
+                        {
+                            result += "\r";
+                            break;
+                        }
+                        case '\\':
+                        {
+                            result += "\\";
+                            break;
+                        }
+                        case '/':
+                        {
+                            result += "/";
+                            break;
+                        }
+                        case '"':
+                        {
+                            result += "\"";
+                            break;
+                        }
+
+                        // unicode
+                        case 'u':
+                        {
+                            // get code xxxx from uxxxx
+                            auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
+                                                          4).c_str(), nullptr, 16);
+
+                            // check if codepoint is a high surrogate
+                            if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+                            {
+                                // make sure there is a subsequent unicode
+                                if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
+                                {
+                                    throw std::invalid_argument("missing low surrogate");
+                                }
+
+                                // get code yyyy from uxxxx\uyyyy
+                                auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
+                                                               (i + 7), 4).c_str(), nullptr, 16);
+                                result += to_unicode(codepoint, codepoint2);
+                                // skip the next 11 characters (xxxx\uyyyy)
+                                i += 11;
+                            }
+                            else
+                            {
+                                // add unicode character(s)
+                                result += to_unicode(codepoint);
+                                // skip the next four characters (xxxx)
+                                i += 4;
+                            }
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    // all other characters are just copied to the end of the
+                    // string
+                    result.append(1, static_cast<typename string_t::value_type>(*i));
+                }
+            }
+
+            return result;
+        }
+
+        /*!
+        @brief return number value for number tokens
+
+        This function translates the last token into a floating point number.
+        The pointer m_begin points to the beginning of the parsed number. We
+        pass this pointer to std::strtod which sets endptr to the first
+        character past the converted number. If this pointer is not the same as
+        m_cursor, then either more or less characters have been used during the
+        comparison. This can happen for inputs like "01" which will be treated
+        like number 0 followed by number 1.
+
+        @return the result of the number conversion or NAN if the conversion
+        read past the current token. The latter case needs to be treated by the
+        caller function.
+
+        @throw std::range_error if passed value is out of range
+        */
+        long double get_number() const
+        {
+            // conversion
+            typename string_t::value_type* endptr;
+            const auto float_val = std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start),
+                                                &endptr);
+
+            // return float_val if the whole number was translated and NAN
+            // otherwise
+            return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
+        }
+
+      private:
+        /// optional input stream
+        std::istream* m_stream;
+        /// the buffer
+        string_t m_buffer;
+        /// the buffer pointer
+        const lexer_char_t* m_content = nullptr;
+        /// pointer to the beginning of the current symbol
+        const lexer_char_t* m_start = nullptr;
+        /// pointer for backtracking information
+        const lexer_char_t* m_marker = nullptr;
+        /// pointer to the current symbol
+        const lexer_char_t* m_cursor = nullptr;
+        /// pointer to the end of the buffer
+        const lexer_char_t* m_limit = nullptr;
+    };
+
+    /*!
+    @brief syntax analysis
+    */
+    class parser
+    {
+      public:
+        /// constructor for strings
+        parser(const string_t& s, parser_callback_t cb = nullptr)
+            : callback(cb), m_lexer(s)
+        {
+            // read first token
+            get_token();
+        }
+
+        /// a parser reading from an input stream
+        parser(std::istream& _is, parser_callback_t cb = nullptr)
+            : callback(cb), m_lexer(&_is)
+        {
+            // read first token
+            get_token();
+        }
+
+        /// public parser interface
+        basic_json parse()
+        {
+            basic_json result = parse_internal(true);
+
+            expect(lexer::token_type::end_of_input);
+
+            // return parser result and replace it with null in case the
+            // top-level value was discarded by the callback function
+            return result.is_discarded() ? basic_json() : result;
+        }
+
+      private:
+        /// the actual parser
+        basic_json parse_internal(bool keep)
+        {
+            auto result = basic_json(value_t::discarded);
+
+            switch (last_token)
+            {
+                case (lexer::token_type::begin_object):
+                {
+                    if (keep and (not callback or (keep = callback(depth++, parse_event_t::object_start, result))))
+                    {
+                        // explicitly set result to object to cope with {}
+                        result.m_type = value_t::object;
+                        result.m_value = json_value(value_t::object);
+                    }
+
+                    // read next token
+                    get_token();
+
+                    // closing } -> we are done
+                    if (last_token == lexer::token_type::end_object)
+                    {
+                        get_token();
+                        if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+                        {
+                            result = basic_json(value_t::discarded);
+                        }
+                        return result;
+                    }
+
+                    // no comma is expected here
+                    unexpect(lexer::token_type::value_separator);
+
+                    // otherwise: parse key-value pairs
+                    do
+                    {
+                        // ugly, but could be fixed with loop reorganization
+                        if (last_token == lexer::token_type::value_separator)
+                        {
+                            get_token();
+                        }
+
+                        // store key
+                        expect(lexer::token_type::value_string);
+                        const auto key = m_lexer.get_string();
+
+                        bool keep_tag = false;
+                        if (keep)
+                        {
+                            if (callback)
+                            {
+                                basic_json k(key);
+                                keep_tag = callback(depth, parse_event_t::key, k);
+                            }
+                            else
+                            {
+                                keep_tag = true;
+                            }
+                        }
+
+                        // parse separator (:)
+                        get_token();
+                        expect(lexer::token_type::name_separator);
+
+                        // parse and add value
+                        get_token();
+                        auto value = parse_internal(keep);
+                        if (keep and keep_tag and not value.is_discarded())
+                        {
+                            result[key] = std::move(value);
+                        }
+                    }
+                    while (last_token == lexer::token_type::value_separator);
+
+                    // closing }
+                    expect(lexer::token_type::end_object);
+                    get_token();
+                    if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+                    {
+                        result = basic_json(value_t::discarded);
+                    }
+
+                    return result;
+                }
+
+                case (lexer::token_type::begin_array):
+                {
+                    if (keep and (not callback or (keep = callback(depth++, parse_event_t::array_start, result))))
+                    {
+                        // explicitly set result to object to cope with []
+                        result.m_type = value_t::array;
+                        result.m_value = json_value(value_t::array);
+                    }
+
+                    // read next token
+                    get_token();
+
+                    // closing ] -> we are done
+                    if (last_token == lexer::token_type::end_array)
+                    {
+                        get_token();
+                        if (callback and not callback(--depth, parse_event_t::array_end, result))
+                        {
+                            result = basic_json(value_t::discarded);
+                        }
+                        return result;
+                    }
+
+                    // no comma is expected here
+                    unexpect(lexer::token_type::value_separator);
+
+                    // otherwise: parse values
+                    do
+                    {
+                        // ugly, but could be fixed with loop reorganization
+                        if (last_token == lexer::token_type::value_separator)
+                        {
+                            get_token();
+                        }
+
+                        // parse value
+                        auto value = parse_internal(keep);
+                        if (keep and not value.is_discarded())
+                        {
+                            result.push_back(std::move(value));
+                        }
+                    }
+                    while (last_token == lexer::token_type::value_separator);
+
+                    // closing ]
+                    expect(lexer::token_type::end_array);
+                    get_token();
+                    if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+                    {
+                        result = basic_json(value_t::discarded);
+                    }
+
+                    return result;
+                }
+
+                case (lexer::token_type::literal_null):
+                {
+                    get_token();
+                    result.m_type = value_t::null;
+                    break;
+                }
+
+                case (lexer::token_type::value_string):
+                {
+                    const auto s = m_lexer.get_string();
+                    get_token();
+                    result = basic_json(s);
+                    break;
+                }
+
+                case (lexer::token_type::literal_true):
+                {
+                    get_token();
+                    result.m_type = value_t::boolean;
+                    result.m_value = true;
+                    break;
+                }
+
+                case (lexer::token_type::literal_false):
+                {
+                    get_token();
+                    result.m_type = value_t::boolean;
+                    result.m_value = false;
+                    break;
+                }
+
+                case (lexer::token_type::value_number):
+                {
+                    auto float_val = m_lexer.get_number();
+
+                    // NAN is returned if token could not be translated
+                    // completely
+                    if (std::isnan(float_val))
+                    {
+                        throw std::invalid_argument(std::string("parse error - ") +
+                                                    m_lexer.get_token() + " is not a number");
+                    }
+
+                    get_token();
+
+                    // check if conversion loses precision
+                    const auto int_val = static_cast<number_integer_t>(float_val);
+                    if (approx(float_val, static_cast<long double>(int_val)))
+                    {
+                        // we basic_json not lose precision -> return int
+                        result.m_type = value_t::number_integer;
+                        result.m_value = int_val;
+                    }
+                    else
+                    {
+                        // we would lose precision -> returnfloat
+                        result.m_type = value_t::number_float;
+                        result.m_value = static_cast<number_float_t>(float_val);
+                    }
+                    break;
+                }
+
+                default:
+                {
+                    // the last token was unexpected
+                    unexpect(last_token);
+                }
+            }
+
+            if (keep and callback and not callback(depth, parse_event_t::value, result))
+            {
+                result = basic_json(value_t::discarded);
+            }
+            return result;
+        }
+
+        /// get next token from lexer
+        typename lexer::token_type get_token()
+        {
+            last_token = m_lexer.scan();
+            return last_token;
+        }
+
+        void expect(typename lexer::token_type t) const
+        {
+            if (t != last_token)
+            {
+                std::string error_msg = "parse error - unexpected \'";
+                error_msg += m_lexer.get_token();
+                error_msg += "\' (" + lexer::token_type_name(last_token);
+                error_msg += "); expected " + lexer::token_type_name(t);
+                throw std::invalid_argument(error_msg);
+            }
+        }
+
+        void unexpect(typename lexer::token_type t) const
+        {
+            if (t == last_token)
+            {
+                std::string error_msg = "parse error - unexpected \'";
+                error_msg += m_lexer.get_token();
+                error_msg += "\' (";
+                error_msg += lexer::token_type_name(last_token) + ")";
+                throw std::invalid_argument(error_msg);
+            }
+        }
+
+      private:
+        /// current level of recursion
+        int depth = 0;
+        /// callback function
+        parser_callback_t callback;
+        /// the type of the last read token
+        typename lexer::token_type last_token = lexer::token_type::uninitialized;
+        /// the lexer
+        lexer m_lexer;
+    };
+};
+
+
+/////////////
+// presets //
+/////////////
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which uses
+the standard template types.
+*/
+using json = basic_json<>;
+}
+
+
+/////////////////////////
+// nonmember functions //
+/////////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+/*!
+@brief exchanges the values of two JSON objects
+*/
+template <>
+inline void swap(nlohmann::json& j1,
+                 nlohmann::json& j2) noexcept(
+                     is_nothrow_move_constructible<nlohmann::json>::value and
+                     is_nothrow_move_assignable<nlohmann::json>::value
+                 )
+{
+    j1.swap(j2);
+}
+
+/// hash value for JSON objects
+template <>
+struct hash<nlohmann::json>
+{
+    /// return a hash value for a JSON object
+    std::size_t operator()(const nlohmann::json& j) const
+    {
+        // a naive hashing via the string representation
+        const auto& h = hash<nlohmann::json::string_t>();
+        return h(j.dump());
+    }
+};
+}
+
+/*!
+@brief user-defined string literal for JSON values
+
+This operator implements a user-defined string literal for JSON objects. It can
+be used by adding \p "_json" to a string literal and returns a JSON object if
+no parse error occurred.
+
+@param[in] s  a string representation of a JSON object
+@return a JSON object
+*/
+inline nlohmann::json operator "" _json(const char* s, std::size_t)
+{
+    return nlohmann::json::parse(reinterpret_cast<nlohmann::json::string_t::value_type*>
+                                 (const_cast<char*>(s)));
+}
+
+#endif
diff --git a/ddl/out/IR.cpp b/ddl/out/IR.cpp
new file mode 100644
index 0000000..729bdd9
--- /dev/null
+++ b/ddl/out/IR.cpp
@@ -0,0 +1,2864 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.420877000000Z
+
+#include "IR.hpp"
+template<> json toJSON<std::shared_ptr<ArrayValue>>(std::shared_ptr<ArrayValue> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ArrayValue::tag::VBoolArray:
+      obj["tag"] = "VBoolArray";
+      {
+        std::shared_ptr<data::VBoolArray> tv = std::static_pointer_cast<data::VBoolArray>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::ArrayValue::tag::VIntArray:
+      obj["tag"] = "VIntArray";
+      {
+        std::shared_ptr<data::VIntArray> tv = std::static_pointer_cast<data::VIntArray>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::ArrayValue::tag::VWordArray:
+      obj["tag"] = "VWordArray";
+      {
+        std::shared_ptr<data::VWordArray> tv = std::static_pointer_cast<data::VWordArray>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::ArrayValue::tag::VFloatArray:
+      obj["tag"] = "VFloatArray";
+      {
+        std::shared_ptr<data::VFloatArray> tv = std::static_pointer_cast<data::VFloatArray>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ArrayValue> fromJSON<std::shared_ptr<ArrayValue>>(W<std::shared_ptr<ArrayValue>> v, json &obj) {
+  enum ::ArrayValue::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "VBoolArray") {
+    tagType = ::ArrayValue::tag::VBoolArray;
+    std::shared_ptr<data::VBoolArray> tv(new data::VBoolArray());
+    tv->_0 = fromJSON(W<std::vector<Bool>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VIntArray") {
+    tagType = ::ArrayValue::tag::VIntArray;
+    std::shared_ptr<data::VIntArray> tv(new data::VIntArray());
+    tv->_0 = fromJSON(W<std::vector<Int32>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VWordArray") {
+    tagType = ::ArrayValue::tag::VWordArray;
+    std::shared_ptr<data::VWordArray> tv(new data::VWordArray());
+    tv->_0 = fromJSON(W<std::vector<Word32>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VFloatArray") {
+    tagType = ::ArrayValue::tag::VFloatArray;
+    std::shared_ptr<data::VFloatArray> tv(new data::VFloatArray());
+    tv->_0 = fromJSON(W<std::vector<Float>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ArrayValue> o(new ::ArrayValue());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Value>>(std::shared_ptr<Value> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Value::tag::VBool:
+      obj["tag"] = "VBool";
+      {
+        std::shared_ptr<data::VBool> tv = std::static_pointer_cast<data::VBool>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV2B:
+      obj["tag"] = "VV2B";
+      {
+        std::shared_ptr<data::VV2B> tv = std::static_pointer_cast<data::VV2B>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV3B:
+      obj["tag"] = "VV3B";
+      {
+        std::shared_ptr<data::VV3B> tv = std::static_pointer_cast<data::VV3B>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV4B:
+      obj["tag"] = "VV4B";
+      {
+        std::shared_ptr<data::VV4B> tv = std::static_pointer_cast<data::VV4B>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VWord:
+      obj["tag"] = "VWord";
+      {
+        std::shared_ptr<data::VWord> tv = std::static_pointer_cast<data::VWord>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV2U:
+      obj["tag"] = "VV2U";
+      {
+        std::shared_ptr<data::VV2U> tv = std::static_pointer_cast<data::VV2U>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV3U:
+      obj["tag"] = "VV3U";
+      {
+        std::shared_ptr<data::VV3U> tv = std::static_pointer_cast<data::VV3U>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV4U:
+      obj["tag"] = "VV4U";
+      {
+        std::shared_ptr<data::VV4U> tv = std::static_pointer_cast<data::VV4U>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VInt:
+      obj["tag"] = "VInt";
+      {
+        std::shared_ptr<data::VInt> tv = std::static_pointer_cast<data::VInt>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV2I:
+      obj["tag"] = "VV2I";
+      {
+        std::shared_ptr<data::VV2I> tv = std::static_pointer_cast<data::VV2I>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV3I:
+      obj["tag"] = "VV3I";
+      {
+        std::shared_ptr<data::VV3I> tv = std::static_pointer_cast<data::VV3I>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV4I:
+      obj["tag"] = "VV4I";
+      {
+        std::shared_ptr<data::VV4I> tv = std::static_pointer_cast<data::VV4I>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VFloat:
+      obj["tag"] = "VFloat";
+      {
+        std::shared_ptr<data::VFloat> tv = std::static_pointer_cast<data::VFloat>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV2F:
+      obj["tag"] = "VV2F";
+      {
+        std::shared_ptr<data::VV2F> tv = std::static_pointer_cast<data::VV2F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV3F:
+      obj["tag"] = "VV3F";
+      {
+        std::shared_ptr<data::VV3F> tv = std::static_pointer_cast<data::VV3F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VV4F:
+      obj["tag"] = "VV4F";
+      {
+        std::shared_ptr<data::VV4F> tv = std::static_pointer_cast<data::VV4F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM22F:
+      obj["tag"] = "VM22F";
+      {
+        std::shared_ptr<data::VM22F> tv = std::static_pointer_cast<data::VM22F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM23F:
+      obj["tag"] = "VM23F";
+      {
+        std::shared_ptr<data::VM23F> tv = std::static_pointer_cast<data::VM23F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM24F:
+      obj["tag"] = "VM24F";
+      {
+        std::shared_ptr<data::VM24F> tv = std::static_pointer_cast<data::VM24F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM32F:
+      obj["tag"] = "VM32F";
+      {
+        std::shared_ptr<data::VM32F> tv = std::static_pointer_cast<data::VM32F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM33F:
+      obj["tag"] = "VM33F";
+      {
+        std::shared_ptr<data::VM33F> tv = std::static_pointer_cast<data::VM33F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM34F:
+      obj["tag"] = "VM34F";
+      {
+        std::shared_ptr<data::VM34F> tv = std::static_pointer_cast<data::VM34F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM42F:
+      obj["tag"] = "VM42F";
+      {
+        std::shared_ptr<data::VM42F> tv = std::static_pointer_cast<data::VM42F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM43F:
+      obj["tag"] = "VM43F";
+      {
+        std::shared_ptr<data::VM43F> tv = std::static_pointer_cast<data::VM43F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Value::tag::VM44F:
+      obj["tag"] = "VM44F";
+      {
+        std::shared_ptr<data::VM44F> tv = std::static_pointer_cast<data::VM44F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Value> fromJSON<std::shared_ptr<Value>>(W<std::shared_ptr<Value>> v, json &obj) {
+  enum ::Value::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "VBool") {
+    tagType = ::Value::tag::VBool;
+    std::shared_ptr<data::VBool> tv(new data::VBool());
+    tv->_0 = fromJSON(W<Bool>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV2B") {
+    tagType = ::Value::tag::VV2B;
+    std::shared_ptr<data::VV2B> tv(new data::VV2B());
+    tv->_0 = fromJSON(W<V2B>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV3B") {
+    tagType = ::Value::tag::VV3B;
+    std::shared_ptr<data::VV3B> tv(new data::VV3B());
+    tv->_0 = fromJSON(W<V3B>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV4B") {
+    tagType = ::Value::tag::VV4B;
+    std::shared_ptr<data::VV4B> tv(new data::VV4B());
+    tv->_0 = fromJSON(W<V4B>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VWord") {
+    tagType = ::Value::tag::VWord;
+    std::shared_ptr<data::VWord> tv(new data::VWord());
+    tv->_0 = fromJSON(W<Word32>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV2U") {
+    tagType = ::Value::tag::VV2U;
+    std::shared_ptr<data::VV2U> tv(new data::VV2U());
+    tv->_0 = fromJSON(W<V2U>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV3U") {
+    tagType = ::Value::tag::VV3U;
+    std::shared_ptr<data::VV3U> tv(new data::VV3U());
+    tv->_0 = fromJSON(W<V3U>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV4U") {
+    tagType = ::Value::tag::VV4U;
+    std::shared_ptr<data::VV4U> tv(new data::VV4U());
+    tv->_0 = fromJSON(W<V4U>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VInt") {
+    tagType = ::Value::tag::VInt;
+    std::shared_ptr<data::VInt> tv(new data::VInt());
+    tv->_0 = fromJSON(W<Int32>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV2I") {
+    tagType = ::Value::tag::VV2I;
+    std::shared_ptr<data::VV2I> tv(new data::VV2I());
+    tv->_0 = fromJSON(W<V2I>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV3I") {
+    tagType = ::Value::tag::VV3I;
+    std::shared_ptr<data::VV3I> tv(new data::VV3I());
+    tv->_0 = fromJSON(W<V3I>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV4I") {
+    tagType = ::Value::tag::VV4I;
+    std::shared_ptr<data::VV4I> tv(new data::VV4I());
+    tv->_0 = fromJSON(W<V4I>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VFloat") {
+    tagType = ::Value::tag::VFloat;
+    std::shared_ptr<data::VFloat> tv(new data::VFloat());
+    tv->_0 = fromJSON(W<Float>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV2F") {
+    tagType = ::Value::tag::VV2F;
+    std::shared_ptr<data::VV2F> tv(new data::VV2F());
+    tv->_0 = fromJSON(W<V2F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV3F") {
+    tagType = ::Value::tag::VV3F;
+    std::shared_ptr<data::VV3F> tv(new data::VV3F());
+    tv->_0 = fromJSON(W<V3F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VV4F") {
+    tagType = ::Value::tag::VV4F;
+    std::shared_ptr<data::VV4F> tv(new data::VV4F());
+    tv->_0 = fromJSON(W<V4F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM22F") {
+    tagType = ::Value::tag::VM22F;
+    std::shared_ptr<data::VM22F> tv(new data::VM22F());
+    tv->_0 = fromJSON(W<M22F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM23F") {
+    tagType = ::Value::tag::VM23F;
+    std::shared_ptr<data::VM23F> tv(new data::VM23F());
+    tv->_0 = fromJSON(W<M23F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM24F") {
+    tagType = ::Value::tag::VM24F;
+    std::shared_ptr<data::VM24F> tv(new data::VM24F());
+    tv->_0 = fromJSON(W<M24F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM32F") {
+    tagType = ::Value::tag::VM32F;
+    std::shared_ptr<data::VM32F> tv(new data::VM32F());
+    tv->_0 = fromJSON(W<M32F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM33F") {
+    tagType = ::Value::tag::VM33F;
+    std::shared_ptr<data::VM33F> tv(new data::VM33F());
+    tv->_0 = fromJSON(W<M33F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM34F") {
+    tagType = ::Value::tag::VM34F;
+    std::shared_ptr<data::VM34F> tv(new data::VM34F());
+    tv->_0 = fromJSON(W<M34F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM42F") {
+    tagType = ::Value::tag::VM42F;
+    std::shared_ptr<data::VM42F> tv(new data::VM42F());
+    tv->_0 = fromJSON(W<M42F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM43F") {
+    tagType = ::Value::tag::VM43F;
+    std::shared_ptr<data::VM43F> tv(new data::VM43F());
+    tv->_0 = fromJSON(W<M43F>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "VM44F") {
+    tagType = ::Value::tag::VM44F;
+    std::shared_ptr<data::VM44F> tv(new data::VM44F());
+    tv->_0 = fromJSON(W<M44F>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Value> o(new ::Value());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<InputType>>(std::shared_ptr<InputType> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::InputType::tag::Bool:
+      obj["tag"] = "Bool";
+      break;
+    case ::InputType::tag::V2B:
+      obj["tag"] = "V2B";
+      break;
+    case ::InputType::tag::V3B:
+      obj["tag"] = "V3B";
+      break;
+    case ::InputType::tag::V4B:
+      obj["tag"] = "V4B";
+      break;
+    case ::InputType::tag::Word:
+      obj["tag"] = "Word";
+      break;
+    case ::InputType::tag::V2U:
+      obj["tag"] = "V2U";
+      break;
+    case ::InputType::tag::V3U:
+      obj["tag"] = "V3U";
+      break;
+    case ::InputType::tag::V4U:
+      obj["tag"] = "V4U";
+      break;
+    case ::InputType::tag::Int:
+      obj["tag"] = "Int";
+      break;
+    case ::InputType::tag::V2I:
+      obj["tag"] = "V2I";
+      break;
+    case ::InputType::tag::V3I:
+      obj["tag"] = "V3I";
+      break;
+    case ::InputType::tag::V4I:
+      obj["tag"] = "V4I";
+      break;
+    case ::InputType::tag::Float:
+      obj["tag"] = "Float";
+      break;
+    case ::InputType::tag::V2F:
+      obj["tag"] = "V2F";
+      break;
+    case ::InputType::tag::V3F:
+      obj["tag"] = "V3F";
+      break;
+    case ::InputType::tag::V4F:
+      obj["tag"] = "V4F";
+      break;
+    case ::InputType::tag::M22F:
+      obj["tag"] = "M22F";
+      break;
+    case ::InputType::tag::M23F:
+      obj["tag"] = "M23F";
+      break;
+    case ::InputType::tag::M24F:
+      obj["tag"] = "M24F";
+      break;
+    case ::InputType::tag::M32F:
+      obj["tag"] = "M32F";
+      break;
+    case ::InputType::tag::M33F:
+      obj["tag"] = "M33F";
+      break;
+    case ::InputType::tag::M34F:
+      obj["tag"] = "M34F";
+      break;
+    case ::InputType::tag::M42F:
+      obj["tag"] = "M42F";
+      break;
+    case ::InputType::tag::M43F:
+      obj["tag"] = "M43F";
+      break;
+    case ::InputType::tag::M44F:
+      obj["tag"] = "M44F";
+      break;
+    case ::InputType::tag::STexture1D:
+      obj["tag"] = "STexture1D";
+      break;
+    case ::InputType::tag::STexture2D:
+      obj["tag"] = "STexture2D";
+      break;
+    case ::InputType::tag::STextureCube:
+      obj["tag"] = "STextureCube";
+      break;
+    case ::InputType::tag::STexture1DArray:
+      obj["tag"] = "STexture1DArray";
+      break;
+    case ::InputType::tag::STexture2DArray:
+      obj["tag"] = "STexture2DArray";
+      break;
+    case ::InputType::tag::STexture2DRect:
+      obj["tag"] = "STexture2DRect";
+      break;
+    case ::InputType::tag::FTexture1D:
+      obj["tag"] = "FTexture1D";
+      break;
+    case ::InputType::tag::FTexture2D:
+      obj["tag"] = "FTexture2D";
+      break;
+    case ::InputType::tag::FTexture3D:
+      obj["tag"] = "FTexture3D";
+      break;
+    case ::InputType::tag::FTextureCube:
+      obj["tag"] = "FTextureCube";
+      break;
+    case ::InputType::tag::FTexture1DArray:
+      obj["tag"] = "FTexture1DArray";
+      break;
+    case ::InputType::tag::FTexture2DArray:
+      obj["tag"] = "FTexture2DArray";
+      break;
+    case ::InputType::tag::FTexture2DMS:
+      obj["tag"] = "FTexture2DMS";
+      break;
+    case ::InputType::tag::FTexture2DMSArray:
+      obj["tag"] = "FTexture2DMSArray";
+      break;
+    case ::InputType::tag::FTextureBuffer:
+      obj["tag"] = "FTextureBuffer";
+      break;
+    case ::InputType::tag::FTexture2DRect:
+      obj["tag"] = "FTexture2DRect";
+      break;
+    case ::InputType::tag::ITexture1D:
+      obj["tag"] = "ITexture1D";
+      break;
+    case ::InputType::tag::ITexture2D:
+      obj["tag"] = "ITexture2D";
+      break;
+    case ::InputType::tag::ITexture3D:
+      obj["tag"] = "ITexture3D";
+      break;
+    case ::InputType::tag::ITextureCube:
+      obj["tag"] = "ITextureCube";
+      break;
+    case ::InputType::tag::ITexture1DArray:
+      obj["tag"] = "ITexture1DArray";
+      break;
+    case ::InputType::tag::ITexture2DArray:
+      obj["tag"] = "ITexture2DArray";
+      break;
+    case ::InputType::tag::ITexture2DMS:
+      obj["tag"] = "ITexture2DMS";
+      break;
+    case ::InputType::tag::ITexture2DMSArray:
+      obj["tag"] = "ITexture2DMSArray";
+      break;
+    case ::InputType::tag::ITextureBuffer:
+      obj["tag"] = "ITextureBuffer";
+      break;
+    case ::InputType::tag::ITexture2DRect:
+      obj["tag"] = "ITexture2DRect";
+      break;
+    case ::InputType::tag::UTexture1D:
+      obj["tag"] = "UTexture1D";
+      break;
+    case ::InputType::tag::UTexture2D:
+      obj["tag"] = "UTexture2D";
+      break;
+    case ::InputType::tag::UTexture3D:
+      obj["tag"] = "UTexture3D";
+      break;
+    case ::InputType::tag::UTextureCube:
+      obj["tag"] = "UTextureCube";
+      break;
+    case ::InputType::tag::UTexture1DArray:
+      obj["tag"] = "UTexture1DArray";
+      break;
+    case ::InputType::tag::UTexture2DArray:
+      obj["tag"] = "UTexture2DArray";
+      break;
+    case ::InputType::tag::UTexture2DMS:
+      obj["tag"] = "UTexture2DMS";
+      break;
+    case ::InputType::tag::UTexture2DMSArray:
+      obj["tag"] = "UTexture2DMSArray";
+      break;
+    case ::InputType::tag::UTextureBuffer:
+      obj["tag"] = "UTextureBuffer";
+      break;
+    case ::InputType::tag::UTexture2DRect:
+      obj["tag"] = "UTexture2DRect";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<InputType> fromJSON<std::shared_ptr<InputType>>(W<std::shared_ptr<InputType>> v, json &obj) {
+  enum ::InputType::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Bool") {
+    tagType = ::InputType::tag::Bool;
+  }
+  else if (tag == "V2B") {
+    tagType = ::InputType::tag::V2B;
+  }
+  else if (tag == "V3B") {
+    tagType = ::InputType::tag::V3B;
+  }
+  else if (tag == "V4B") {
+    tagType = ::InputType::tag::V4B;
+  }
+  else if (tag == "Word") {
+    tagType = ::InputType::tag::Word;
+  }
+  else if (tag == "V2U") {
+    tagType = ::InputType::tag::V2U;
+  }
+  else if (tag == "V3U") {
+    tagType = ::InputType::tag::V3U;
+  }
+  else if (tag == "V4U") {
+    tagType = ::InputType::tag::V4U;
+  }
+  else if (tag == "Int") {
+    tagType = ::InputType::tag::Int;
+  }
+  else if (tag == "V2I") {
+    tagType = ::InputType::tag::V2I;
+  }
+  else if (tag == "V3I") {
+    tagType = ::InputType::tag::V3I;
+  }
+  else if (tag == "V4I") {
+    tagType = ::InputType::tag::V4I;
+  }
+  else if (tag == "Float") {
+    tagType = ::InputType::tag::Float;
+  }
+  else if (tag == "V2F") {
+    tagType = ::InputType::tag::V2F;
+  }
+  else if (tag == "V3F") {
+    tagType = ::InputType::tag::V3F;
+  }
+  else if (tag == "V4F") {
+    tagType = ::InputType::tag::V4F;
+  }
+  else if (tag == "M22F") {
+    tagType = ::InputType::tag::M22F;
+  }
+  else if (tag == "M23F") {
+    tagType = ::InputType::tag::M23F;
+  }
+  else if (tag == "M24F") {
+    tagType = ::InputType::tag::M24F;
+  }
+  else if (tag == "M32F") {
+    tagType = ::InputType::tag::M32F;
+  }
+  else if (tag == "M33F") {
+    tagType = ::InputType::tag::M33F;
+  }
+  else if (tag == "M34F") {
+    tagType = ::InputType::tag::M34F;
+  }
+  else if (tag == "M42F") {
+    tagType = ::InputType::tag::M42F;
+  }
+  else if (tag == "M43F") {
+    tagType = ::InputType::tag::M43F;
+  }
+  else if (tag == "M44F") {
+    tagType = ::InputType::tag::M44F;
+  }
+  else if (tag == "STexture1D") {
+    tagType = ::InputType::tag::STexture1D;
+  }
+  else if (tag == "STexture2D") {
+    tagType = ::InputType::tag::STexture2D;
+  }
+  else if (tag == "STextureCube") {
+    tagType = ::InputType::tag::STextureCube;
+  }
+  else if (tag == "STexture1DArray") {
+    tagType = ::InputType::tag::STexture1DArray;
+  }
+  else if (tag == "STexture2DArray") {
+    tagType = ::InputType::tag::STexture2DArray;
+  }
+  else if (tag == "STexture2DRect") {
+    tagType = ::InputType::tag::STexture2DRect;
+  }
+  else if (tag == "FTexture1D") {
+    tagType = ::InputType::tag::FTexture1D;
+  }
+  else if (tag == "FTexture2D") {
+    tagType = ::InputType::tag::FTexture2D;
+  }
+  else if (tag == "FTexture3D") {
+    tagType = ::InputType::tag::FTexture3D;
+  }
+  else if (tag == "FTextureCube") {
+    tagType = ::InputType::tag::FTextureCube;
+  }
+  else if (tag == "FTexture1DArray") {
+    tagType = ::InputType::tag::FTexture1DArray;
+  }
+  else if (tag == "FTexture2DArray") {
+    tagType = ::InputType::tag::FTexture2DArray;
+  }
+  else if (tag == "FTexture2DMS") {
+    tagType = ::InputType::tag::FTexture2DMS;
+  }
+  else if (tag == "FTexture2DMSArray") {
+    tagType = ::InputType::tag::FTexture2DMSArray;
+  }
+  else if (tag == "FTextureBuffer") {
+    tagType = ::InputType::tag::FTextureBuffer;
+  }
+  else if (tag == "FTexture2DRect") {
+    tagType = ::InputType::tag::FTexture2DRect;
+  }
+  else if (tag == "ITexture1D") {
+    tagType = ::InputType::tag::ITexture1D;
+  }
+  else if (tag == "ITexture2D") {
+    tagType = ::InputType::tag::ITexture2D;
+  }
+  else if (tag == "ITexture3D") {
+    tagType = ::InputType::tag::ITexture3D;
+  }
+  else if (tag == "ITextureCube") {
+    tagType = ::InputType::tag::ITextureCube;
+  }
+  else if (tag == "ITexture1DArray") {
+    tagType = ::InputType::tag::ITexture1DArray;
+  }
+  else if (tag == "ITexture2DArray") {
+    tagType = ::InputType::tag::ITexture2DArray;
+  }
+  else if (tag == "ITexture2DMS") {
+    tagType = ::InputType::tag::ITexture2DMS;
+  }
+  else if (tag == "ITexture2DMSArray") {
+    tagType = ::InputType::tag::ITexture2DMSArray;
+  }
+  else if (tag == "ITextureBuffer") {
+    tagType = ::InputType::tag::ITextureBuffer;
+  }
+  else if (tag == "ITexture2DRect") {
+    tagType = ::InputType::tag::ITexture2DRect;
+  }
+  else if (tag == "UTexture1D") {
+    tagType = ::InputType::tag::UTexture1D;
+  }
+  else if (tag == "UTexture2D") {
+    tagType = ::InputType::tag::UTexture2D;
+  }
+  else if (tag == "UTexture3D") {
+    tagType = ::InputType::tag::UTexture3D;
+  }
+  else if (tag == "UTextureCube") {
+    tagType = ::InputType::tag::UTextureCube;
+  }
+  else if (tag == "UTexture1DArray") {
+    tagType = ::InputType::tag::UTexture1DArray;
+  }
+  else if (tag == "UTexture2DArray") {
+    tagType = ::InputType::tag::UTexture2DArray;
+  }
+  else if (tag == "UTexture2DMS") {
+    tagType = ::InputType::tag::UTexture2DMS;
+  }
+  else if (tag == "UTexture2DMSArray") {
+    tagType = ::InputType::tag::UTexture2DMSArray;
+  }
+  else if (tag == "UTextureBuffer") {
+    tagType = ::InputType::tag::UTextureBuffer;
+  }
+  else if (tag == "UTexture2DRect") {
+    tagType = ::InputType::tag::UTexture2DRect;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::InputType> o(new ::InputType());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<PointSpriteCoordOrigin>>(std::shared_ptr<PointSpriteCoordOrigin> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::PointSpriteCoordOrigin::tag::LowerLeft:
+      obj["tag"] = "LowerLeft";
+      break;
+    case ::PointSpriteCoordOrigin::tag::UpperLeft:
+      obj["tag"] = "UpperLeft";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<PointSpriteCoordOrigin> fromJSON<std::shared_ptr<PointSpriteCoordOrigin>>(W<std::shared_ptr<PointSpriteCoordOrigin>> v, json &obj) {
+  enum ::PointSpriteCoordOrigin::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "LowerLeft") {
+    tagType = ::PointSpriteCoordOrigin::tag::LowerLeft;
+  }
+  else if (tag == "UpperLeft") {
+    tagType = ::PointSpriteCoordOrigin::tag::UpperLeft;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::PointSpriteCoordOrigin> o(new ::PointSpriteCoordOrigin());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<PointSize>>(std::shared_ptr<PointSize> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::PointSize::tag::PointSize:
+      obj["tag"] = "PointSize";
+      {
+        std::shared_ptr<data::PointSize> tv = std::static_pointer_cast<data::PointSize>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::PointSize::tag::ProgramPointSize:
+      obj["tag"] = "ProgramPointSize";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<PointSize> fromJSON<std::shared_ptr<PointSize>>(W<std::shared_ptr<PointSize>> v, json &obj) {
+  enum ::PointSize::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "PointSize") {
+    tagType = ::PointSize::tag::PointSize;
+    std::shared_ptr<data::PointSize> tv(new data::PointSize());
+    tv->_0 = fromJSON(W<Float>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "ProgramPointSize") {
+    tagType = ::PointSize::tag::ProgramPointSize;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::PointSize> o(new ::PointSize());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<PolygonOffset>>(std::shared_ptr<PolygonOffset> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::PolygonOffset::tag::NoOffset:
+      obj["tag"] = "NoOffset";
+      break;
+    case ::PolygonOffset::tag::Offset:
+      obj["tag"] = "Offset";
+      {
+        std::shared_ptr<data::Offset> tv = std::static_pointer_cast<data::Offset>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<PolygonOffset> fromJSON<std::shared_ptr<PolygonOffset>>(W<std::shared_ptr<PolygonOffset>> v, json &obj) {
+  enum ::PolygonOffset::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "NoOffset") {
+    tagType = ::PolygonOffset::tag::NoOffset;
+  }
+  else if (tag == "Offset") {
+    tagType = ::PolygonOffset::tag::Offset;
+    std::shared_ptr<data::Offset> tv(new data::Offset());
+    tv->_0 = fromJSON(W<Float>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Float>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::PolygonOffset> o(new ::PolygonOffset());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<FrontFace>>(std::shared_ptr<FrontFace> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::FrontFace::tag::CCW:
+      obj["tag"] = "CCW";
+      break;
+    case ::FrontFace::tag::CW:
+      obj["tag"] = "CW";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<FrontFace> fromJSON<std::shared_ptr<FrontFace>>(W<std::shared_ptr<FrontFace>> v, json &obj) {
+  enum ::FrontFace::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "CCW") {
+    tagType = ::FrontFace::tag::CCW;
+  }
+  else if (tag == "CW") {
+    tagType = ::FrontFace::tag::CW;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::FrontFace> o(new ::FrontFace());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<PolygonMode>>(std::shared_ptr<PolygonMode> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::PolygonMode::tag::PolygonPoint:
+      obj["tag"] = "PolygonPoint";
+      {
+        std::shared_ptr<data::PolygonPoint> tv = std::static_pointer_cast<data::PolygonPoint>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::PolygonMode::tag::PolygonLine:
+      obj["tag"] = "PolygonLine";
+      {
+        std::shared_ptr<data::PolygonLine> tv = std::static_pointer_cast<data::PolygonLine>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::PolygonMode::tag::PolygonFill:
+      obj["tag"] = "PolygonFill";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<PolygonMode> fromJSON<std::shared_ptr<PolygonMode>>(W<std::shared_ptr<PolygonMode>> v, json &obj) {
+  enum ::PolygonMode::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "PolygonPoint") {
+    tagType = ::PolygonMode::tag::PolygonPoint;
+    std::shared_ptr<data::PolygonPoint> tv(new data::PolygonPoint());
+    tv->_0 = fromJSON(W<std::shared_ptr<::PointSize>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "PolygonLine") {
+    tagType = ::PolygonMode::tag::PolygonLine;
+    std::shared_ptr<data::PolygonLine> tv(new data::PolygonLine());
+    tv->_0 = fromJSON(W<Float>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "PolygonFill") {
+    tagType = ::PolygonMode::tag::PolygonFill;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::PolygonMode> o(new ::PolygonMode());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ProvokingVertex>>(std::shared_ptr<ProvokingVertex> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ProvokingVertex::tag::FirstVertex:
+      obj["tag"] = "FirstVertex";
+      break;
+    case ::ProvokingVertex::tag::LastVertex:
+      obj["tag"] = "LastVertex";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ProvokingVertex> fromJSON<std::shared_ptr<ProvokingVertex>>(W<std::shared_ptr<ProvokingVertex>> v, json &obj) {
+  enum ::ProvokingVertex::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "FirstVertex") {
+    tagType = ::ProvokingVertex::tag::FirstVertex;
+  }
+  else if (tag == "LastVertex") {
+    tagType = ::ProvokingVertex::tag::LastVertex;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ProvokingVertex> o(new ::ProvokingVertex());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<CullMode>>(std::shared_ptr<CullMode> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::CullMode::tag::CullNone:
+      obj["tag"] = "CullNone";
+      break;
+    case ::CullMode::tag::CullFront:
+      obj["tag"] = "CullFront";
+      {
+        std::shared_ptr<data::CullFront> tv = std::static_pointer_cast<data::CullFront>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::CullMode::tag::CullBack:
+      obj["tag"] = "CullBack";
+      {
+        std::shared_ptr<data::CullBack> tv = std::static_pointer_cast<data::CullBack>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<CullMode> fromJSON<std::shared_ptr<CullMode>>(W<std::shared_ptr<CullMode>> v, json &obj) {
+  enum ::CullMode::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "CullNone") {
+    tagType = ::CullMode::tag::CullNone;
+  }
+  else if (tag == "CullFront") {
+    tagType = ::CullMode::tag::CullFront;
+    std::shared_ptr<data::CullFront> tv(new data::CullFront());
+    tv->_0 = fromJSON(W<std::shared_ptr<::FrontFace>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "CullBack") {
+    tagType = ::CullMode::tag::CullBack;
+    std::shared_ptr<data::CullBack> tv(new data::CullBack());
+    tv->_0 = fromJSON(W<std::shared_ptr<::FrontFace>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::CullMode> o(new ::CullMode());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ComparisonFunction>>(std::shared_ptr<ComparisonFunction> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ComparisonFunction::tag::Never:
+      obj["tag"] = "Never";
+      break;
+    case ::ComparisonFunction::tag::Less:
+      obj["tag"] = "Less";
+      break;
+    case ::ComparisonFunction::tag::Equal:
+      obj["tag"] = "Equal";
+      break;
+    case ::ComparisonFunction::tag::Lequal:
+      obj["tag"] = "Lequal";
+      break;
+    case ::ComparisonFunction::tag::Greater:
+      obj["tag"] = "Greater";
+      break;
+    case ::ComparisonFunction::tag::Notequal:
+      obj["tag"] = "Notequal";
+      break;
+    case ::ComparisonFunction::tag::Gequal:
+      obj["tag"] = "Gequal";
+      break;
+    case ::ComparisonFunction::tag::Always:
+      obj["tag"] = "Always";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ComparisonFunction> fromJSON<std::shared_ptr<ComparisonFunction>>(W<std::shared_ptr<ComparisonFunction>> v, json &obj) {
+  enum ::ComparisonFunction::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Never") {
+    tagType = ::ComparisonFunction::tag::Never;
+  }
+  else if (tag == "Less") {
+    tagType = ::ComparisonFunction::tag::Less;
+  }
+  else if (tag == "Equal") {
+    tagType = ::ComparisonFunction::tag::Equal;
+  }
+  else if (tag == "Lequal") {
+    tagType = ::ComparisonFunction::tag::Lequal;
+  }
+  else if (tag == "Greater") {
+    tagType = ::ComparisonFunction::tag::Greater;
+  }
+  else if (tag == "Notequal") {
+    tagType = ::ComparisonFunction::tag::Notequal;
+  }
+  else if (tag == "Gequal") {
+    tagType = ::ComparisonFunction::tag::Gequal;
+  }
+  else if (tag == "Always") {
+    tagType = ::ComparisonFunction::tag::Always;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ComparisonFunction> o(new ::ComparisonFunction());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<StencilOperation>>(std::shared_ptr<StencilOperation> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::StencilOperation::tag::OpZero:
+      obj["tag"] = "OpZero";
+      break;
+    case ::StencilOperation::tag::OpKeep:
+      obj["tag"] = "OpKeep";
+      break;
+    case ::StencilOperation::tag::OpReplace:
+      obj["tag"] = "OpReplace";
+      break;
+    case ::StencilOperation::tag::OpIncr:
+      obj["tag"] = "OpIncr";
+      break;
+    case ::StencilOperation::tag::OpIncrWrap:
+      obj["tag"] = "OpIncrWrap";
+      break;
+    case ::StencilOperation::tag::OpDecr:
+      obj["tag"] = "OpDecr";
+      break;
+    case ::StencilOperation::tag::OpDecrWrap:
+      obj["tag"] = "OpDecrWrap";
+      break;
+    case ::StencilOperation::tag::OpInvert:
+      obj["tag"] = "OpInvert";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<StencilOperation> fromJSON<std::shared_ptr<StencilOperation>>(W<std::shared_ptr<StencilOperation>> v, json &obj) {
+  enum ::StencilOperation::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "OpZero") {
+    tagType = ::StencilOperation::tag::OpZero;
+  }
+  else if (tag == "OpKeep") {
+    tagType = ::StencilOperation::tag::OpKeep;
+  }
+  else if (tag == "OpReplace") {
+    tagType = ::StencilOperation::tag::OpReplace;
+  }
+  else if (tag == "OpIncr") {
+    tagType = ::StencilOperation::tag::OpIncr;
+  }
+  else if (tag == "OpIncrWrap") {
+    tagType = ::StencilOperation::tag::OpIncrWrap;
+  }
+  else if (tag == "OpDecr") {
+    tagType = ::StencilOperation::tag::OpDecr;
+  }
+  else if (tag == "OpDecrWrap") {
+    tagType = ::StencilOperation::tag::OpDecrWrap;
+  }
+  else if (tag == "OpInvert") {
+    tagType = ::StencilOperation::tag::OpInvert;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::StencilOperation> o(new ::StencilOperation());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<BlendEquation>>(std::shared_ptr<BlendEquation> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::BlendEquation::tag::FuncAdd:
+      obj["tag"] = "FuncAdd";
+      break;
+    case ::BlendEquation::tag::FuncSubtract:
+      obj["tag"] = "FuncSubtract";
+      break;
+    case ::BlendEquation::tag::FuncReverseSubtract:
+      obj["tag"] = "FuncReverseSubtract";
+      break;
+    case ::BlendEquation::tag::Min:
+      obj["tag"] = "Min";
+      break;
+    case ::BlendEquation::tag::Max:
+      obj["tag"] = "Max";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<BlendEquation> fromJSON<std::shared_ptr<BlendEquation>>(W<std::shared_ptr<BlendEquation>> v, json &obj) {
+  enum ::BlendEquation::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "FuncAdd") {
+    tagType = ::BlendEquation::tag::FuncAdd;
+  }
+  else if (tag == "FuncSubtract") {
+    tagType = ::BlendEquation::tag::FuncSubtract;
+  }
+  else if (tag == "FuncReverseSubtract") {
+    tagType = ::BlendEquation::tag::FuncReverseSubtract;
+  }
+  else if (tag == "Min") {
+    tagType = ::BlendEquation::tag::Min;
+  }
+  else if (tag == "Max") {
+    tagType = ::BlendEquation::tag::Max;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::BlendEquation> o(new ::BlendEquation());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<BlendingFactor>>(std::shared_ptr<BlendingFactor> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::BlendingFactor::tag::Zero:
+      obj["tag"] = "Zero";
+      break;
+    case ::BlendingFactor::tag::One:
+      obj["tag"] = "One";
+      break;
+    case ::BlendingFactor::tag::SrcColor:
+      obj["tag"] = "SrcColor";
+      break;
+    case ::BlendingFactor::tag::OneMinusSrcColor:
+      obj["tag"] = "OneMinusSrcColor";
+      break;
+    case ::BlendingFactor::tag::DstColor:
+      obj["tag"] = "DstColor";
+      break;
+    case ::BlendingFactor::tag::OneMinusDstColor:
+      obj["tag"] = "OneMinusDstColor";
+      break;
+    case ::BlendingFactor::tag::SrcAlpha:
+      obj["tag"] = "SrcAlpha";
+      break;
+    case ::BlendingFactor::tag::OneMinusSrcAlpha:
+      obj["tag"] = "OneMinusSrcAlpha";
+      break;
+    case ::BlendingFactor::tag::DstAlpha:
+      obj["tag"] = "DstAlpha";
+      break;
+    case ::BlendingFactor::tag::OneMinusDstAlpha:
+      obj["tag"] = "OneMinusDstAlpha";
+      break;
+    case ::BlendingFactor::tag::ConstantColor:
+      obj["tag"] = "ConstantColor";
+      break;
+    case ::BlendingFactor::tag::OneMinusConstantColor:
+      obj["tag"] = "OneMinusConstantColor";
+      break;
+    case ::BlendingFactor::tag::ConstantAlpha:
+      obj["tag"] = "ConstantAlpha";
+      break;
+    case ::BlendingFactor::tag::OneMinusConstantAlpha:
+      obj["tag"] = "OneMinusConstantAlpha";
+      break;
+    case ::BlendingFactor::tag::SrcAlphaSaturate:
+      obj["tag"] = "SrcAlphaSaturate";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<BlendingFactor> fromJSON<std::shared_ptr<BlendingFactor>>(W<std::shared_ptr<BlendingFactor>> v, json &obj) {
+  enum ::BlendingFactor::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Zero") {
+    tagType = ::BlendingFactor::tag::Zero;
+  }
+  else if (tag == "One") {
+    tagType = ::BlendingFactor::tag::One;
+  }
+  else if (tag == "SrcColor") {
+    tagType = ::BlendingFactor::tag::SrcColor;
+  }
+  else if (tag == "OneMinusSrcColor") {
+    tagType = ::BlendingFactor::tag::OneMinusSrcColor;
+  }
+  else if (tag == "DstColor") {
+    tagType = ::BlendingFactor::tag::DstColor;
+  }
+  else if (tag == "OneMinusDstColor") {
+    tagType = ::BlendingFactor::tag::OneMinusDstColor;
+  }
+  else if (tag == "SrcAlpha") {
+    tagType = ::BlendingFactor::tag::SrcAlpha;
+  }
+  else if (tag == "OneMinusSrcAlpha") {
+    tagType = ::BlendingFactor::tag::OneMinusSrcAlpha;
+  }
+  else if (tag == "DstAlpha") {
+    tagType = ::BlendingFactor::tag::DstAlpha;
+  }
+  else if (tag == "OneMinusDstAlpha") {
+    tagType = ::BlendingFactor::tag::OneMinusDstAlpha;
+  }
+  else if (tag == "ConstantColor") {
+    tagType = ::BlendingFactor::tag::ConstantColor;
+  }
+  else if (tag == "OneMinusConstantColor") {
+    tagType = ::BlendingFactor::tag::OneMinusConstantColor;
+  }
+  else if (tag == "ConstantAlpha") {
+    tagType = ::BlendingFactor::tag::ConstantAlpha;
+  }
+  else if (tag == "OneMinusConstantAlpha") {
+    tagType = ::BlendingFactor::tag::OneMinusConstantAlpha;
+  }
+  else if (tag == "SrcAlphaSaturate") {
+    tagType = ::BlendingFactor::tag::SrcAlphaSaturate;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::BlendingFactor> o(new ::BlendingFactor());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<LogicOperation>>(std::shared_ptr<LogicOperation> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::LogicOperation::tag::Clear:
+      obj["tag"] = "Clear";
+      break;
+    case ::LogicOperation::tag::And:
+      obj["tag"] = "And";
+      break;
+    case ::LogicOperation::tag::AndReverse:
+      obj["tag"] = "AndReverse";
+      break;
+    case ::LogicOperation::tag::Copy:
+      obj["tag"] = "Copy";
+      break;
+    case ::LogicOperation::tag::AndInverted:
+      obj["tag"] = "AndInverted";
+      break;
+    case ::LogicOperation::tag::Noop:
+      obj["tag"] = "Noop";
+      break;
+    case ::LogicOperation::tag::Xor:
+      obj["tag"] = "Xor";
+      break;
+    case ::LogicOperation::tag::Or:
+      obj["tag"] = "Or";
+      break;
+    case ::LogicOperation::tag::Nor:
+      obj["tag"] = "Nor";
+      break;
+    case ::LogicOperation::tag::Equiv:
+      obj["tag"] = "Equiv";
+      break;
+    case ::LogicOperation::tag::Invert:
+      obj["tag"] = "Invert";
+      break;
+    case ::LogicOperation::tag::OrReverse:
+      obj["tag"] = "OrReverse";
+      break;
+    case ::LogicOperation::tag::CopyInverted:
+      obj["tag"] = "CopyInverted";
+      break;
+    case ::LogicOperation::tag::OrInverted:
+      obj["tag"] = "OrInverted";
+      break;
+    case ::LogicOperation::tag::Nand:
+      obj["tag"] = "Nand";
+      break;
+    case ::LogicOperation::tag::Set:
+      obj["tag"] = "Set";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<LogicOperation> fromJSON<std::shared_ptr<LogicOperation>>(W<std::shared_ptr<LogicOperation>> v, json &obj) {
+  enum ::LogicOperation::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Clear") {
+    tagType = ::LogicOperation::tag::Clear;
+  }
+  else if (tag == "And") {
+    tagType = ::LogicOperation::tag::And;
+  }
+  else if (tag == "AndReverse") {
+    tagType = ::LogicOperation::tag::AndReverse;
+  }
+  else if (tag == "Copy") {
+    tagType = ::LogicOperation::tag::Copy;
+  }
+  else if (tag == "AndInverted") {
+    tagType = ::LogicOperation::tag::AndInverted;
+  }
+  else if (tag == "Noop") {
+    tagType = ::LogicOperation::tag::Noop;
+  }
+  else if (tag == "Xor") {
+    tagType = ::LogicOperation::tag::Xor;
+  }
+  else if (tag == "Or") {
+    tagType = ::LogicOperation::tag::Or;
+  }
+  else if (tag == "Nor") {
+    tagType = ::LogicOperation::tag::Nor;
+  }
+  else if (tag == "Equiv") {
+    tagType = ::LogicOperation::tag::Equiv;
+  }
+  else if (tag == "Invert") {
+    tagType = ::LogicOperation::tag::Invert;
+  }
+  else if (tag == "OrReverse") {
+    tagType = ::LogicOperation::tag::OrReverse;
+  }
+  else if (tag == "CopyInverted") {
+    tagType = ::LogicOperation::tag::CopyInverted;
+  }
+  else if (tag == "OrInverted") {
+    tagType = ::LogicOperation::tag::OrInverted;
+  }
+  else if (tag == "Nand") {
+    tagType = ::LogicOperation::tag::Nand;
+  }
+  else if (tag == "Set") {
+    tagType = ::LogicOperation::tag::Set;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::LogicOperation> o(new ::LogicOperation());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<StencilOps>>(std::shared_ptr<StencilOps> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::StencilOps::tag::StencilOps:
+      obj["tag"] = "StencilOps";
+      {
+        std::shared_ptr<data::StencilOps> tv = std::static_pointer_cast<data::StencilOps>(v);
+        obj["frontStencilOp"] = toJSON(tv->frontStencilOp);
+        obj["backStencilOp"] = toJSON(tv->backStencilOp);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<StencilOps> fromJSON<std::shared_ptr<StencilOps>>(W<std::shared_ptr<StencilOps>> v, json &obj) {
+  enum ::StencilOps::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "StencilOps") {
+    tagType = ::StencilOps::tag::StencilOps;
+    std::shared_ptr<data::StencilOps> tv(new data::StencilOps());
+    tv->frontStencilOp = fromJSON(W<std::shared_ptr<::StencilOperation>>(), obj["frontStencilOp"]);
+    tv->backStencilOp = fromJSON(W<std::shared_ptr<::StencilOperation>>(), obj["backStencilOp"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::StencilOps> o(new ::StencilOps());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<StencilTest>>(std::shared_ptr<StencilTest> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::StencilTest::tag::StencilTest:
+      obj["tag"] = "StencilTest";
+      {
+        std::shared_ptr<data::StencilTest> tv = std::static_pointer_cast<data::StencilTest>(v);
+        obj["stencilComparision"] = toJSON(tv->stencilComparision);
+        obj["stencilReference"] = toJSON(tv->stencilReference);
+        obj["stencilMask"] = toJSON(tv->stencilMask);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<StencilTest> fromJSON<std::shared_ptr<StencilTest>>(W<std::shared_ptr<StencilTest>> v, json &obj) {
+  enum ::StencilTest::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "StencilTest") {
+    tagType = ::StencilTest::tag::StencilTest;
+    std::shared_ptr<data::StencilTest> tv(new data::StencilTest());
+    tv->stencilComparision = fromJSON(W<std::shared_ptr<::ComparisonFunction>>(), obj["stencilComparision"]);
+    tv->stencilReference = fromJSON(W<Int32>(), obj["stencilReference"]);
+    tv->stencilMask = fromJSON(W<Word32>(), obj["stencilMask"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::StencilTest> o(new ::StencilTest());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<StencilTests>>(std::shared_ptr<StencilTests> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::StencilTests::tag::StencilTests:
+      obj["tag"] = "StencilTests";
+      {
+        std::shared_ptr<data::StencilTests> tv = std::static_pointer_cast<data::StencilTests>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<StencilTests> fromJSON<std::shared_ptr<StencilTests>>(W<std::shared_ptr<StencilTests>> v, json &obj) {
+  enum ::StencilTests::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "StencilTests") {
+    tagType = ::StencilTests::tag::StencilTests;
+    std::shared_ptr<data::StencilTests> tv(new data::StencilTests());
+    tv->_0 = fromJSON(W<std::shared_ptr<::StencilTest>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::StencilTest>>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::StencilTests> o(new ::StencilTests());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<FetchPrimitive>>(std::shared_ptr<FetchPrimitive> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::FetchPrimitive::tag::Points:
+      obj["tag"] = "Points";
+      break;
+    case ::FetchPrimitive::tag::Lines:
+      obj["tag"] = "Lines";
+      break;
+    case ::FetchPrimitive::tag::Triangles:
+      obj["tag"] = "Triangles";
+      break;
+    case ::FetchPrimitive::tag::LinesAdjacency:
+      obj["tag"] = "LinesAdjacency";
+      break;
+    case ::FetchPrimitive::tag::TrianglesAdjacency:
+      obj["tag"] = "TrianglesAdjacency";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<FetchPrimitive> fromJSON<std::shared_ptr<FetchPrimitive>>(W<std::shared_ptr<FetchPrimitive>> v, json &obj) {
+  enum ::FetchPrimitive::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Points") {
+    tagType = ::FetchPrimitive::tag::Points;
+  }
+  else if (tag == "Lines") {
+    tagType = ::FetchPrimitive::tag::Lines;
+  }
+  else if (tag == "Triangles") {
+    tagType = ::FetchPrimitive::tag::Triangles;
+  }
+  else if (tag == "LinesAdjacency") {
+    tagType = ::FetchPrimitive::tag::LinesAdjacency;
+  }
+  else if (tag == "TrianglesAdjacency") {
+    tagType = ::FetchPrimitive::tag::TrianglesAdjacency;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::FetchPrimitive> o(new ::FetchPrimitive());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<OutputPrimitive>>(std::shared_ptr<OutputPrimitive> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::OutputPrimitive::tag::TrianglesOutput:
+      obj["tag"] = "TrianglesOutput";
+      break;
+    case ::OutputPrimitive::tag::LinesOutput:
+      obj["tag"] = "LinesOutput";
+      break;
+    case ::OutputPrimitive::tag::PointsOutput:
+      obj["tag"] = "PointsOutput";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<OutputPrimitive> fromJSON<std::shared_ptr<OutputPrimitive>>(W<std::shared_ptr<OutputPrimitive>> v, json &obj) {
+  enum ::OutputPrimitive::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "TrianglesOutput") {
+    tagType = ::OutputPrimitive::tag::TrianglesOutput;
+  }
+  else if (tag == "LinesOutput") {
+    tagType = ::OutputPrimitive::tag::LinesOutput;
+  }
+  else if (tag == "PointsOutput") {
+    tagType = ::OutputPrimitive::tag::PointsOutput;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::OutputPrimitive> o(new ::OutputPrimitive());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ColorArity>>(std::shared_ptr<ColorArity> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ColorArity::tag::Red:
+      obj["tag"] = "Red";
+      break;
+    case ::ColorArity::tag::RG:
+      obj["tag"] = "RG";
+      break;
+    case ::ColorArity::tag::RGB:
+      obj["tag"] = "RGB";
+      break;
+    case ::ColorArity::tag::RGBA:
+      obj["tag"] = "RGBA";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ColorArity> fromJSON<std::shared_ptr<ColorArity>>(W<std::shared_ptr<ColorArity>> v, json &obj) {
+  enum ::ColorArity::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Red") {
+    tagType = ::ColorArity::tag::Red;
+  }
+  else if (tag == "RG") {
+    tagType = ::ColorArity::tag::RG;
+  }
+  else if (tag == "RGB") {
+    tagType = ::ColorArity::tag::RGB;
+  }
+  else if (tag == "RGBA") {
+    tagType = ::ColorArity::tag::RGBA;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ColorArity> o(new ::ColorArity());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Blending>>(std::shared_ptr<Blending> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Blending::tag::NoBlending:
+      obj["tag"] = "NoBlending";
+      break;
+    case ::Blending::tag::BlendLogicOp:
+      obj["tag"] = "BlendLogicOp";
+      {
+        std::shared_ptr<data::BlendLogicOp> tv = std::static_pointer_cast<data::BlendLogicOp>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Blending::tag::Blend:
+      obj["tag"] = "Blend";
+      {
+        std::shared_ptr<data::Blend> tv = std::static_pointer_cast<data::Blend>(v);
+        obj["colorEqSrc"] = toJSON(tv->colorEqSrc);
+        obj["alphaEqSrc"] = toJSON(tv->alphaEqSrc);
+        obj["colorFSrc"] = toJSON(tv->colorFSrc);
+        obj["colorFDst"] = toJSON(tv->colorFDst);
+        obj["alphaFSrc"] = toJSON(tv->alphaFSrc);
+        obj["alphaFDst"] = toJSON(tv->alphaFDst);
+        obj["color"] = toJSON(tv->color);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Blending> fromJSON<std::shared_ptr<Blending>>(W<std::shared_ptr<Blending>> v, json &obj) {
+  enum ::Blending::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "NoBlending") {
+    tagType = ::Blending::tag::NoBlending;
+  }
+  else if (tag == "BlendLogicOp") {
+    tagType = ::Blending::tag::BlendLogicOp;
+    std::shared_ptr<data::BlendLogicOp> tv(new data::BlendLogicOp());
+    tv->_0 = fromJSON(W<std::shared_ptr<::LogicOperation>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "Blend") {
+    tagType = ::Blending::tag::Blend;
+    std::shared_ptr<data::Blend> tv(new data::Blend());
+    tv->colorEqSrc = fromJSON(W<std::shared_ptr<::BlendEquation>>(), obj["colorEqSrc"]);
+    tv->alphaEqSrc = fromJSON(W<std::shared_ptr<::BlendEquation>>(), obj["alphaEqSrc"]);
+    tv->colorFSrc = fromJSON(W<std::shared_ptr<::BlendingFactor>>(), obj["colorFSrc"]);
+    tv->colorFDst = fromJSON(W<std::shared_ptr<::BlendingFactor>>(), obj["colorFDst"]);
+    tv->alphaFSrc = fromJSON(W<std::shared_ptr<::BlendingFactor>>(), obj["alphaFSrc"]);
+    tv->alphaFDst = fromJSON(W<std::shared_ptr<::BlendingFactor>>(), obj["alphaFDst"]);
+    tv->color = fromJSON(W<V4F>(), obj["color"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Blending> o(new ::Blending());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<RasterContext>>(std::shared_ptr<RasterContext> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::RasterContext::tag::PointCtx:
+      obj["tag"] = "PointCtx";
+      {
+        std::shared_ptr<data::PointCtx> tv = std::static_pointer_cast<data::PointCtx>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+        obj["arg2"] = toJSON(tv->_2);
+      }
+      break;
+    case ::RasterContext::tag::LineCtx:
+      obj["tag"] = "LineCtx";
+      {
+        std::shared_ptr<data::LineCtx> tv = std::static_pointer_cast<data::LineCtx>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::RasterContext::tag::TriangleCtx:
+      obj["tag"] = "TriangleCtx";
+      {
+        std::shared_ptr<data::TriangleCtx> tv = std::static_pointer_cast<data::TriangleCtx>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+        obj["arg2"] = toJSON(tv->_2);
+        obj["arg3"] = toJSON(tv->_3);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<RasterContext> fromJSON<std::shared_ptr<RasterContext>>(W<std::shared_ptr<RasterContext>> v, json &obj) {
+  enum ::RasterContext::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "PointCtx") {
+    tagType = ::RasterContext::tag::PointCtx;
+    std::shared_ptr<data::PointCtx> tv(new data::PointCtx());
+    tv->_0 = fromJSON(W<std::shared_ptr<::PointSize>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Float>(), obj["arg1"]);
+    tv->_2 = fromJSON(W<std::shared_ptr<::PointSpriteCoordOrigin>>(), obj["arg2"]);
+    return tv;
+  }
+  else if (tag == "LineCtx") {
+    tagType = ::RasterContext::tag::LineCtx;
+    std::shared_ptr<data::LineCtx> tv(new data::LineCtx());
+    tv->_0 = fromJSON(W<Float>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::ProvokingVertex>>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "TriangleCtx") {
+    tagType = ::RasterContext::tag::TriangleCtx;
+    std::shared_ptr<data::TriangleCtx> tv(new data::TriangleCtx());
+    tv->_0 = fromJSON(W<std::shared_ptr<::CullMode>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::PolygonMode>>(), obj["arg1"]);
+    tv->_2 = fromJSON(W<std::shared_ptr<::PolygonOffset>>(), obj["arg2"]);
+    tv->_3 = fromJSON(W<std::shared_ptr<::ProvokingVertex>>(), obj["arg3"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::RasterContext> o(new ::RasterContext());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<FragmentOperation>>(std::shared_ptr<FragmentOperation> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::FragmentOperation::tag::DepthOp:
+      obj["tag"] = "DepthOp";
+      {
+        std::shared_ptr<data::DepthOp> tv = std::static_pointer_cast<data::DepthOp>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::FragmentOperation::tag::StencilOp:
+      obj["tag"] = "StencilOp";
+      {
+        std::shared_ptr<data::StencilOp> tv = std::static_pointer_cast<data::StencilOp>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+        obj["arg2"] = toJSON(tv->_2);
+      }
+      break;
+    case ::FragmentOperation::tag::ColorOp:
+      obj["tag"] = "ColorOp";
+      {
+        std::shared_ptr<data::ColorOp> tv = std::static_pointer_cast<data::ColorOp>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<FragmentOperation> fromJSON<std::shared_ptr<FragmentOperation>>(W<std::shared_ptr<FragmentOperation>> v, json &obj) {
+  enum ::FragmentOperation::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "DepthOp") {
+    tagType = ::FragmentOperation::tag::DepthOp;
+    std::shared_ptr<data::DepthOp> tv(new data::DepthOp());
+    tv->_0 = fromJSON(W<std::shared_ptr<::DepthFunction>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Bool>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "StencilOp") {
+    tagType = ::FragmentOperation::tag::StencilOp;
+    std::shared_ptr<data::StencilOp> tv(new data::StencilOp());
+    tv->_0 = fromJSON(W<std::shared_ptr<::StencilTests>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::StencilOps>>(), obj["arg1"]);
+    tv->_2 = fromJSON(W<std::shared_ptr<::StencilOps>>(), obj["arg2"]);
+    return tv;
+  }
+  else if (tag == "ColorOp") {
+    tagType = ::FragmentOperation::tag::ColorOp;
+    std::shared_ptr<data::ColorOp> tv(new data::ColorOp());
+    tv->_0 = fromJSON(W<std::shared_ptr<::Blending>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::Value>>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::FragmentOperation> o(new ::FragmentOperation());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<AccumulationContext>>(std::shared_ptr<AccumulationContext> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::AccumulationContext::tag::AccumulationContext:
+      obj["tag"] = "AccumulationContext";
+      {
+        std::shared_ptr<data::AccumulationContext> tv = std::static_pointer_cast<data::AccumulationContext>(v);
+        obj["accViewportName"] = toJSON(tv->accViewportName);
+        obj["accOperations"] = toJSON(tv->accOperations);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<AccumulationContext> fromJSON<std::shared_ptr<AccumulationContext>>(W<std::shared_ptr<AccumulationContext>> v, json &obj) {
+  enum ::AccumulationContext::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "AccumulationContext") {
+    tagType = ::AccumulationContext::tag::AccumulationContext;
+    std::shared_ptr<data::AccumulationContext> tv(new data::AccumulationContext());
+    tv->accViewportName = fromJSON(W<Maybe<String>>(), obj["accViewportName"]);
+    tv->accOperations = fromJSON(W<std::vector<std::shared_ptr<::FragmentOperation>>>(), obj["accOperations"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::AccumulationContext> o(new ::AccumulationContext());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<TextureDataType>>(std::shared_ptr<TextureDataType> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::TextureDataType::tag::FloatT:
+      obj["tag"] = "FloatT";
+      {
+        std::shared_ptr<data::FloatT> tv = std::static_pointer_cast<data::FloatT>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureDataType::tag::IntT:
+      obj["tag"] = "IntT";
+      {
+        std::shared_ptr<data::IntT> tv = std::static_pointer_cast<data::IntT>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureDataType::tag::WordT:
+      obj["tag"] = "WordT";
+      {
+        std::shared_ptr<data::WordT> tv = std::static_pointer_cast<data::WordT>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureDataType::tag::ShadowT:
+      obj["tag"] = "ShadowT";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<TextureDataType> fromJSON<std::shared_ptr<TextureDataType>>(W<std::shared_ptr<TextureDataType>> v, json &obj) {
+  enum ::TextureDataType::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "FloatT") {
+    tagType = ::TextureDataType::tag::FloatT;
+    std::shared_ptr<data::FloatT> tv(new data::FloatT());
+    tv->_0 = fromJSON(W<std::shared_ptr<::ColorArity>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "IntT") {
+    tagType = ::TextureDataType::tag::IntT;
+    std::shared_ptr<data::IntT> tv(new data::IntT());
+    tv->_0 = fromJSON(W<std::shared_ptr<::ColorArity>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "WordT") {
+    tagType = ::TextureDataType::tag::WordT;
+    std::shared_ptr<data::WordT> tv(new data::WordT());
+    tv->_0 = fromJSON(W<std::shared_ptr<::ColorArity>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "ShadowT") {
+    tagType = ::TextureDataType::tag::ShadowT;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::TextureDataType> o(new ::TextureDataType());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<TextureType>>(std::shared_ptr<TextureType> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::TextureType::tag::Texture1D:
+      obj["tag"] = "Texture1D";
+      {
+        std::shared_ptr<data::Texture1D> tv = std::static_pointer_cast<data::Texture1D>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::TextureType::tag::Texture2D:
+      obj["tag"] = "Texture2D";
+      {
+        std::shared_ptr<data::Texture2D> tv = std::static_pointer_cast<data::Texture2D>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::TextureType::tag::Texture3D:
+      obj["tag"] = "Texture3D";
+      {
+        std::shared_ptr<data::Texture3D> tv = std::static_pointer_cast<data::Texture3D>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureType::tag::TextureCube:
+      obj["tag"] = "TextureCube";
+      {
+        std::shared_ptr<data::TextureCube> tv = std::static_pointer_cast<data::TextureCube>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureType::tag::TextureRect:
+      obj["tag"] = "TextureRect";
+      {
+        std::shared_ptr<data::TextureRect> tv = std::static_pointer_cast<data::TextureRect>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::TextureType::tag::Texture2DMS:
+      obj["tag"] = "Texture2DMS";
+      {
+        std::shared_ptr<data::Texture2DMS> tv = std::static_pointer_cast<data::Texture2DMS>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+        obj["arg2"] = toJSON(tv->_2);
+        obj["arg3"] = toJSON(tv->_3);
+      }
+      break;
+    case ::TextureType::tag::TextureBuffer:
+      obj["tag"] = "TextureBuffer";
+      {
+        std::shared_ptr<data::TextureBuffer> tv = std::static_pointer_cast<data::TextureBuffer>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<TextureType> fromJSON<std::shared_ptr<TextureType>>(W<std::shared_ptr<TextureType>> v, json &obj) {
+  enum ::TextureType::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Texture1D") {
+    tagType = ::TextureType::tag::Texture1D;
+    std::shared_ptr<data::Texture1D> tv(new data::Texture1D());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "Texture2D") {
+    tagType = ::TextureType::tag::Texture2D;
+    std::shared_ptr<data::Texture2D> tv(new data::Texture2D());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "Texture3D") {
+    tagType = ::TextureType::tag::Texture3D;
+    std::shared_ptr<data::Texture3D> tv(new data::Texture3D());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "TextureCube") {
+    tagType = ::TextureType::tag::TextureCube;
+    std::shared_ptr<data::TextureCube> tv(new data::TextureCube());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "TextureRect") {
+    tagType = ::TextureType::tag::TextureRect;
+    std::shared_ptr<data::TextureRect> tv(new data::TextureRect());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "Texture2DMS") {
+    tagType = ::TextureType::tag::Texture2DMS;
+    std::shared_ptr<data::Texture2DMS> tv(new data::Texture2DMS());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    tv->_2 = fromJSON(W<Int>(), obj["arg2"]);
+    tv->_3 = fromJSON(W<Bool>(), obj["arg3"]);
+    return tv;
+  }
+  else if (tag == "TextureBuffer") {
+    tagType = ::TextureType::tag::TextureBuffer;
+    std::shared_ptr<data::TextureBuffer> tv(new data::TextureBuffer());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TextureDataType>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::TextureType> o(new ::TextureType());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<MipMap>>(std::shared_ptr<MipMap> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::MipMap::tag::Mip:
+      obj["tag"] = "Mip";
+      {
+        std::shared_ptr<data::Mip> tv = std::static_pointer_cast<data::Mip>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::MipMap::tag::NoMip:
+      obj["tag"] = "NoMip";
+      break;
+    case ::MipMap::tag::AutoMip:
+      obj["tag"] = "AutoMip";
+      {
+        std::shared_ptr<data::AutoMip> tv = std::static_pointer_cast<data::AutoMip>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<MipMap> fromJSON<std::shared_ptr<MipMap>>(W<std::shared_ptr<MipMap>> v, json &obj) {
+  enum ::MipMap::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Mip") {
+    tagType = ::MipMap::tag::Mip;
+    std::shared_ptr<data::Mip> tv(new data::Mip());
+    tv->_0 = fromJSON(W<Int>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "NoMip") {
+    tagType = ::MipMap::tag::NoMip;
+  }
+  else if (tag == "AutoMip") {
+    tagType = ::MipMap::tag::AutoMip;
+    std::shared_ptr<data::AutoMip> tv(new data::AutoMip());
+    tv->_0 = fromJSON(W<Int>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::MipMap> o(new ::MipMap());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Filter>>(std::shared_ptr<Filter> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Filter::tag::Nearest:
+      obj["tag"] = "Nearest";
+      break;
+    case ::Filter::tag::Linear:
+      obj["tag"] = "Linear";
+      break;
+    case ::Filter::tag::NearestMipmapNearest:
+      obj["tag"] = "NearestMipmapNearest";
+      break;
+    case ::Filter::tag::NearestMipmapLinear:
+      obj["tag"] = "NearestMipmapLinear";
+      break;
+    case ::Filter::tag::LinearMipmapNearest:
+      obj["tag"] = "LinearMipmapNearest";
+      break;
+    case ::Filter::tag::LinearMipmapLinear:
+      obj["tag"] = "LinearMipmapLinear";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Filter> fromJSON<std::shared_ptr<Filter>>(W<std::shared_ptr<Filter>> v, json &obj) {
+  enum ::Filter::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Nearest") {
+    tagType = ::Filter::tag::Nearest;
+  }
+  else if (tag == "Linear") {
+    tagType = ::Filter::tag::Linear;
+  }
+  else if (tag == "NearestMipmapNearest") {
+    tagType = ::Filter::tag::NearestMipmapNearest;
+  }
+  else if (tag == "NearestMipmapLinear") {
+    tagType = ::Filter::tag::NearestMipmapLinear;
+  }
+  else if (tag == "LinearMipmapNearest") {
+    tagType = ::Filter::tag::LinearMipmapNearest;
+  }
+  else if (tag == "LinearMipmapLinear") {
+    tagType = ::Filter::tag::LinearMipmapLinear;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Filter> o(new ::Filter());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<EdgeMode>>(std::shared_ptr<EdgeMode> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::EdgeMode::tag::Repeat:
+      obj["tag"] = "Repeat";
+      break;
+    case ::EdgeMode::tag::MirroredRepeat:
+      obj["tag"] = "MirroredRepeat";
+      break;
+    case ::EdgeMode::tag::ClampToEdge:
+      obj["tag"] = "ClampToEdge";
+      break;
+    case ::EdgeMode::tag::ClampToBorder:
+      obj["tag"] = "ClampToBorder";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<EdgeMode> fromJSON<std::shared_ptr<EdgeMode>>(W<std::shared_ptr<EdgeMode>> v, json &obj) {
+  enum ::EdgeMode::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Repeat") {
+    tagType = ::EdgeMode::tag::Repeat;
+  }
+  else if (tag == "MirroredRepeat") {
+    tagType = ::EdgeMode::tag::MirroredRepeat;
+  }
+  else if (tag == "ClampToEdge") {
+    tagType = ::EdgeMode::tag::ClampToEdge;
+  }
+  else if (tag == "ClampToBorder") {
+    tagType = ::EdgeMode::tag::ClampToBorder;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::EdgeMode> o(new ::EdgeMode());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ImageSemantic>>(std::shared_ptr<ImageSemantic> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ImageSemantic::tag::Depth:
+      obj["tag"] = "Depth";
+      break;
+    case ::ImageSemantic::tag::Stencil:
+      obj["tag"] = "Stencil";
+      break;
+    case ::ImageSemantic::tag::Color:
+      obj["tag"] = "Color";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ImageSemantic> fromJSON<std::shared_ptr<ImageSemantic>>(W<std::shared_ptr<ImageSemantic>> v, json &obj) {
+  enum ::ImageSemantic::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Depth") {
+    tagType = ::ImageSemantic::tag::Depth;
+  }
+  else if (tag == "Stencil") {
+    tagType = ::ImageSemantic::tag::Stencil;
+  }
+  else if (tag == "Color") {
+    tagType = ::ImageSemantic::tag::Color;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ImageSemantic> o(new ::ImageSemantic());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ImageRef>>(std::shared_ptr<ImageRef> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ImageRef::tag::TextureImage:
+      obj["tag"] = "TextureImage";
+      {
+        std::shared_ptr<data::TextureImage> tv = std::static_pointer_cast<data::TextureImage>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+        obj["arg2"] = toJSON(tv->_2);
+      }
+      break;
+    case ::ImageRef::tag::Framebuffer:
+      obj["tag"] = "Framebuffer";
+      {
+        std::shared_ptr<data::Framebuffer> tv = std::static_pointer_cast<data::Framebuffer>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ImageRef> fromJSON<std::shared_ptr<ImageRef>>(W<std::shared_ptr<ImageRef>> v, json &obj) {
+  enum ::ImageRef::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "TextureImage") {
+    tagType = ::ImageRef::tag::TextureImage;
+    std::shared_ptr<data::TextureImage> tv(new data::TextureImage());
+    tv->_0 = fromJSON(W<::TextureName>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Int>(), obj["arg1"]);
+    tv->_2 = fromJSON(W<Maybe<Int>>(), obj["arg2"]);
+    return tv;
+  }
+  else if (tag == "Framebuffer") {
+    tagType = ::ImageRef::tag::Framebuffer;
+    std::shared_ptr<data::Framebuffer> tv(new data::Framebuffer());
+    tv->_0 = fromJSON(W<std::shared_ptr<::ImageSemantic>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ImageRef> o(new ::ImageRef());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<ClearImage>>(std::shared_ptr<ClearImage> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::ClearImage::tag::ClearImage:
+      obj["tag"] = "ClearImage";
+      {
+        std::shared_ptr<data::ClearImage> tv = std::static_pointer_cast<data::ClearImage>(v);
+        obj["imageSemantic"] = toJSON(tv->imageSemantic);
+        obj["clearValue"] = toJSON(tv->clearValue);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<ClearImage> fromJSON<std::shared_ptr<ClearImage>>(W<std::shared_ptr<ClearImage>> v, json &obj) {
+  enum ::ClearImage::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "ClearImage") {
+    tagType = ::ClearImage::tag::ClearImage;
+    std::shared_ptr<data::ClearImage> tv(new data::ClearImage());
+    tv->imageSemantic = fromJSON(W<std::shared_ptr<::ImageSemantic>>(), obj["imageSemantic"]);
+    tv->clearValue = fromJSON(W<std::shared_ptr<::Value>>(), obj["clearValue"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::ClearImage> o(new ::ClearImage());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Command>>(std::shared_ptr<Command> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Command::tag::SetRasterContext:
+      obj["tag"] = "SetRasterContext";
+      {
+        std::shared_ptr<data::SetRasterContext> tv = std::static_pointer_cast<data::SetRasterContext>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::SetAccumulationContext:
+      obj["tag"] = "SetAccumulationContext";
+      {
+        std::shared_ptr<data::SetAccumulationContext> tv = std::static_pointer_cast<data::SetAccumulationContext>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::SetRenderTarget:
+      obj["tag"] = "SetRenderTarget";
+      {
+        std::shared_ptr<data::SetRenderTarget> tv = std::static_pointer_cast<data::SetRenderTarget>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::SetProgram:
+      obj["tag"] = "SetProgram";
+      {
+        std::shared_ptr<data::SetProgram> tv = std::static_pointer_cast<data::SetProgram>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::SetSamplerUniform:
+      obj["tag"] = "SetSamplerUniform";
+      {
+        std::shared_ptr<data::SetSamplerUniform> tv = std::static_pointer_cast<data::SetSamplerUniform>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::Command::tag::SetTexture:
+      obj["tag"] = "SetTexture";
+      {
+        std::shared_ptr<data::SetTexture> tv = std::static_pointer_cast<data::SetTexture>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::Command::tag::SetSampler:
+      obj["tag"] = "SetSampler";
+      {
+        std::shared_ptr<data::SetSampler> tv = std::static_pointer_cast<data::SetSampler>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::Command::tag::RenderSlot:
+      obj["tag"] = "RenderSlot";
+      {
+        std::shared_ptr<data::RenderSlot> tv = std::static_pointer_cast<data::RenderSlot>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::RenderStream:
+      obj["tag"] = "RenderStream";
+      {
+        std::shared_ptr<data::RenderStream> tv = std::static_pointer_cast<data::RenderStream>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::ClearRenderTarget:
+      obj["tag"] = "ClearRenderTarget";
+      {
+        std::shared_ptr<data::ClearRenderTarget> tv = std::static_pointer_cast<data::ClearRenderTarget>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::GenerateMipMap:
+      obj["tag"] = "GenerateMipMap";
+      {
+        std::shared_ptr<data::GenerateMipMap> tv = std::static_pointer_cast<data::GenerateMipMap>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::Command::tag::SaveImage:
+      obj["tag"] = "SaveImage";
+      {
+        std::shared_ptr<data::SaveImage> tv = std::static_pointer_cast<data::SaveImage>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::Command::tag::LoadImage:
+      obj["tag"] = "LoadImage";
+      {
+        std::shared_ptr<data::LoadImage> tv = std::static_pointer_cast<data::LoadImage>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Command> fromJSON<std::shared_ptr<Command>>(W<std::shared_ptr<Command>> v, json &obj) {
+  enum ::Command::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "SetRasterContext") {
+    tagType = ::Command::tag::SetRasterContext;
+    std::shared_ptr<data::SetRasterContext> tv(new data::SetRasterContext());
+    tv->_0 = fromJSON(W<std::shared_ptr<::RasterContext>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "SetAccumulationContext") {
+    tagType = ::Command::tag::SetAccumulationContext;
+    std::shared_ptr<data::SetAccumulationContext> tv(new data::SetAccumulationContext());
+    tv->_0 = fromJSON(W<std::shared_ptr<::AccumulationContext>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "SetRenderTarget") {
+    tagType = ::Command::tag::SetRenderTarget;
+    std::shared_ptr<data::SetRenderTarget> tv(new data::SetRenderTarget());
+    tv->_0 = fromJSON(W<::RenderTargetName>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "SetProgram") {
+    tagType = ::Command::tag::SetProgram;
+    std::shared_ptr<data::SetProgram> tv(new data::SetProgram());
+    tv->_0 = fromJSON(W<::ProgramName>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "SetSamplerUniform") {
+    tagType = ::Command::tag::SetSamplerUniform;
+    std::shared_ptr<data::SetSamplerUniform> tv(new data::SetSamplerUniform());
+    tv->_0 = fromJSON(W<::UniformName>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<::TextureUnit>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "SetTexture") {
+    tagType = ::Command::tag::SetTexture;
+    std::shared_ptr<data::SetTexture> tv(new data::SetTexture());
+    tv->_0 = fromJSON(W<::TextureUnit>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<::TextureName>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "SetSampler") {
+    tagType = ::Command::tag::SetSampler;
+    std::shared_ptr<data::SetSampler> tv(new data::SetSampler());
+    tv->_0 = fromJSON(W<::TextureUnit>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<Maybe<::SamplerName>>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "RenderSlot") {
+    tagType = ::Command::tag::RenderSlot;
+    std::shared_ptr<data::RenderSlot> tv(new data::RenderSlot());
+    tv->_0 = fromJSON(W<::SlotName>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "RenderStream") {
+    tagType = ::Command::tag::RenderStream;
+    std::shared_ptr<data::RenderStream> tv(new data::RenderStream());
+    tv->_0 = fromJSON(W<::StreamName>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "ClearRenderTarget") {
+    tagType = ::Command::tag::ClearRenderTarget;
+    std::shared_ptr<data::ClearRenderTarget> tv(new data::ClearRenderTarget());
+    tv->_0 = fromJSON(W<std::vector<std::shared_ptr<::ClearImage>>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "GenerateMipMap") {
+    tagType = ::Command::tag::GenerateMipMap;
+    std::shared_ptr<data::GenerateMipMap> tv(new data::GenerateMipMap());
+    tv->_0 = fromJSON(W<::TextureUnit>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "SaveImage") {
+    tagType = ::Command::tag::SaveImage;
+    std::shared_ptr<data::SaveImage> tv(new data::SaveImage());
+    tv->_0 = fromJSON(W<::FrameBufferComponent>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::shared_ptr<::ImageRef>>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "LoadImage") {
+    tagType = ::Command::tag::LoadImage;
+    std::shared_ptr<data::LoadImage> tv(new data::LoadImage());
+    tv->_0 = fromJSON(W<std::shared_ptr<::ImageRef>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<::FrameBufferComponent>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Command> o(new ::Command());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<SamplerDescriptor>>(std::shared_ptr<SamplerDescriptor> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::SamplerDescriptor::tag::SamplerDescriptor:
+      obj["tag"] = "SamplerDescriptor";
+      {
+        std::shared_ptr<data::SamplerDescriptor> tv = std::static_pointer_cast<data::SamplerDescriptor>(v);
+        obj["samplerWrapS"] = toJSON(tv->samplerWrapS);
+        obj["samplerWrapT"] = toJSON(tv->samplerWrapT);
+        obj["samplerWrapR"] = toJSON(tv->samplerWrapR);
+        obj["samplerMinFilter"] = toJSON(tv->samplerMinFilter);
+        obj["samplerMagFilter"] = toJSON(tv->samplerMagFilter);
+        obj["samplerBorderColor"] = toJSON(tv->samplerBorderColor);
+        obj["samplerMinLod"] = toJSON(tv->samplerMinLod);
+        obj["samplerMaxLod"] = toJSON(tv->samplerMaxLod);
+        obj["samplerLodBias"] = toJSON(tv->samplerLodBias);
+        obj["samplerCompareFunc"] = toJSON(tv->samplerCompareFunc);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<SamplerDescriptor> fromJSON<std::shared_ptr<SamplerDescriptor>>(W<std::shared_ptr<SamplerDescriptor>> v, json &obj) {
+  enum ::SamplerDescriptor::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "SamplerDescriptor") {
+    tagType = ::SamplerDescriptor::tag::SamplerDescriptor;
+    std::shared_ptr<data::SamplerDescriptor> tv(new data::SamplerDescriptor());
+    tv->samplerWrapS = fromJSON(W<std::shared_ptr<::EdgeMode>>(), obj["samplerWrapS"]);
+    tv->samplerWrapT = fromJSON(W<Maybe<std::shared_ptr<::EdgeMode>>>(), obj["samplerWrapT"]);
+    tv->samplerWrapR = fromJSON(W<Maybe<std::shared_ptr<::EdgeMode>>>(), obj["samplerWrapR"]);
+    tv->samplerMinFilter = fromJSON(W<std::shared_ptr<::Filter>>(), obj["samplerMinFilter"]);
+    tv->samplerMagFilter = fromJSON(W<std::shared_ptr<::Filter>>(), obj["samplerMagFilter"]);
+    tv->samplerBorderColor = fromJSON(W<std::shared_ptr<::Value>>(), obj["samplerBorderColor"]);
+    tv->samplerMinLod = fromJSON(W<Maybe<Float>>(), obj["samplerMinLod"]);
+    tv->samplerMaxLod = fromJSON(W<Maybe<Float>>(), obj["samplerMaxLod"]);
+    tv->samplerLodBias = fromJSON(W<Float>(), obj["samplerLodBias"]);
+    tv->samplerCompareFunc = fromJSON(W<Maybe<std::shared_ptr<::ComparisonFunction>>>(), obj["samplerCompareFunc"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::SamplerDescriptor> o(new ::SamplerDescriptor());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<TextureDescriptor>>(std::shared_ptr<TextureDescriptor> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::TextureDescriptor::tag::TextureDescriptor:
+      obj["tag"] = "TextureDescriptor";
+      {
+        std::shared_ptr<data::TextureDescriptor> tv = std::static_pointer_cast<data::TextureDescriptor>(v);
+        obj["textureType"] = toJSON(tv->textureType);
+        obj["textureSize"] = toJSON(tv->textureSize);
+        obj["textureSemantic"] = toJSON(tv->textureSemantic);
+        obj["textureSampler"] = toJSON(tv->textureSampler);
+        obj["textureBaseLevel"] = toJSON(tv->textureBaseLevel);
+        obj["textureMaxLevel"] = toJSON(tv->textureMaxLevel);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<TextureDescriptor> fromJSON<std::shared_ptr<TextureDescriptor>>(W<std::shared_ptr<TextureDescriptor>> v, json &obj) {
+  enum ::TextureDescriptor::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "TextureDescriptor") {
+    tagType = ::TextureDescriptor::tag::TextureDescriptor;
+    std::shared_ptr<data::TextureDescriptor> tv(new data::TextureDescriptor());
+    tv->textureType = fromJSON(W<std::shared_ptr<::TextureType>>(), obj["textureType"]);
+    tv->textureSize = fromJSON(W<std::shared_ptr<::Value>>(), obj["textureSize"]);
+    tv->textureSemantic = fromJSON(W<std::shared_ptr<::ImageSemantic>>(), obj["textureSemantic"]);
+    tv->textureSampler = fromJSON(W<std::shared_ptr<::SamplerDescriptor>>(), obj["textureSampler"]);
+    tv->textureBaseLevel = fromJSON(W<Int>(), obj["textureBaseLevel"]);
+    tv->textureMaxLevel = fromJSON(W<Int>(), obj["textureMaxLevel"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::TextureDescriptor> o(new ::TextureDescriptor());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Parameter>>(std::shared_ptr<Parameter> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Parameter::tag::Parameter:
+      obj["tag"] = "Parameter";
+      {
+        std::shared_ptr<data::Parameter> tv = std::static_pointer_cast<data::Parameter>(v);
+        obj["name"] = toJSON(tv->name);
+        obj["ty"] = toJSON(tv->ty);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Parameter> fromJSON<std::shared_ptr<Parameter>>(W<std::shared_ptr<Parameter>> v, json &obj) {
+  enum ::Parameter::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Parameter") {
+    tagType = ::Parameter::tag::Parameter;
+    std::shared_ptr<data::Parameter> tv(new data::Parameter());
+    tv->name = fromJSON(W<String>(), obj["name"]);
+    tv->ty = fromJSON(W<std::shared_ptr<::InputType>>(), obj["ty"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Parameter> o(new ::Parameter());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Program>>(std::shared_ptr<Program> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Program::tag::Program:
+      obj["tag"] = "Program";
+      {
+        std::shared_ptr<data::Program> tv = std::static_pointer_cast<data::Program>(v);
+        obj["programUniforms"] = toJSON(tv->programUniforms);
+        obj["programStreams"] = toJSON(tv->programStreams);
+        obj["programInTextures"] = toJSON(tv->programInTextures);
+        obj["programOutput"] = toJSON(tv->programOutput);
+        obj["vertexShader"] = toJSON(tv->vertexShader);
+        obj["geometryShader"] = toJSON(tv->geometryShader);
+        obj["fragmentShader"] = toJSON(tv->fragmentShader);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Program> fromJSON<std::shared_ptr<Program>>(W<std::shared_ptr<Program>> v, json &obj) {
+  enum ::Program::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Program") {
+    tagType = ::Program::tag::Program;
+    std::shared_ptr<data::Program> tv(new data::Program());
+    tv->programUniforms = fromJSON(W<std::map<::UniformName, std::shared_ptr<::InputType>>>(), obj["programUniforms"]);
+    tv->programStreams = fromJSON(W<std::map<::UniformName, std::shared_ptr<::Parameter>>>(), obj["programStreams"]);
+    tv->programInTextures = fromJSON(W<std::map<::UniformName, std::shared_ptr<::InputType>>>(), obj["programInTextures"]);
+    tv->programOutput = fromJSON(W<std::vector<std::shared_ptr<::Parameter>>>(), obj["programOutput"]);
+    tv->vertexShader = fromJSON(W<String>(), obj["vertexShader"]);
+    tv->geometryShader = fromJSON(W<Maybe<String>>(), obj["geometryShader"]);
+    tv->fragmentShader = fromJSON(W<String>(), obj["fragmentShader"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Program> o(new ::Program());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Slot>>(std::shared_ptr<Slot> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Slot::tag::Slot:
+      obj["tag"] = "Slot";
+      {
+        std::shared_ptr<data::Slot> tv = std::static_pointer_cast<data::Slot>(v);
+        obj["slotName"] = toJSON(tv->slotName);
+        obj["slotStreams"] = toJSON(tv->slotStreams);
+        obj["slotUniforms"] = toJSON(tv->slotUniforms);
+        obj["slotPrimitive"] = toJSON(tv->slotPrimitive);
+        obj["slotPrograms"] = toJSON(tv->slotPrograms);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Slot> fromJSON<std::shared_ptr<Slot>>(W<std::shared_ptr<Slot>> v, json &obj) {
+  enum ::Slot::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Slot") {
+    tagType = ::Slot::tag::Slot;
+    std::shared_ptr<data::Slot> tv(new data::Slot());
+    tv->slotName = fromJSON(W<String>(), obj["slotName"]);
+    tv->slotStreams = fromJSON(W<std::map<String, std::shared_ptr<::InputType>>>(), obj["slotStreams"]);
+    tv->slotUniforms = fromJSON(W<std::map<::UniformName, std::shared_ptr<::InputType>>>(), obj["slotUniforms"]);
+    tv->slotPrimitive = fromJSON(W<std::shared_ptr<::FetchPrimitive>>(), obj["slotPrimitive"]);
+    tv->slotPrograms = fromJSON(W<std::vector<::ProgramName>>(), obj["slotPrograms"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Slot> o(new ::Slot());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<StreamData>>(std::shared_ptr<StreamData> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::StreamData::tag::StreamData:
+      obj["tag"] = "StreamData";
+      {
+        std::shared_ptr<data::StreamData> tv = std::static_pointer_cast<data::StreamData>(v);
+        obj["streamData"] = toJSON(tv->streamData);
+        obj["streamType"] = toJSON(tv->streamType);
+        obj["streamPrimitive"] = toJSON(tv->streamPrimitive);
+        obj["streamPrograms"] = toJSON(tv->streamPrograms);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<StreamData> fromJSON<std::shared_ptr<StreamData>>(W<std::shared_ptr<StreamData>> v, json &obj) {
+  enum ::StreamData::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "StreamData") {
+    tagType = ::StreamData::tag::StreamData;
+    std::shared_ptr<data::StreamData> tv(new data::StreamData());
+    tv->streamData = fromJSON(W<std::map<String, std::shared_ptr<::ArrayValue>>>(), obj["streamData"]);
+    tv->streamType = fromJSON(W<std::map<String, std::shared_ptr<::InputType>>>(), obj["streamType"]);
+    tv->streamPrimitive = fromJSON(W<std::shared_ptr<::FetchPrimitive>>(), obj["streamPrimitive"]);
+    tv->streamPrograms = fromJSON(W<std::vector<::ProgramName>>(), obj["streamPrograms"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::StreamData> o(new ::StreamData());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<TargetItem>>(std::shared_ptr<TargetItem> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::TargetItem::tag::TargetItem:
+      obj["tag"] = "TargetItem";
+      {
+        std::shared_ptr<data::TargetItem> tv = std::static_pointer_cast<data::TargetItem>(v);
+        obj["targetSemantic"] = toJSON(tv->targetSemantic);
+        obj["targetRef"] = toJSON(tv->targetRef);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<TargetItem> fromJSON<std::shared_ptr<TargetItem>>(W<std::shared_ptr<TargetItem>> v, json &obj) {
+  enum ::TargetItem::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "TargetItem") {
+    tagType = ::TargetItem::tag::TargetItem;
+    std::shared_ptr<data::TargetItem> tv(new data::TargetItem());
+    tv->targetSemantic = fromJSON(W<std::shared_ptr<::ImageSemantic>>(), obj["targetSemantic"]);
+    tv->targetRef = fromJSON(W<Maybe<std::shared_ptr<::ImageRef>>>(), obj["targetRef"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::TargetItem> o(new ::TargetItem());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<RenderTarget>>(std::shared_ptr<RenderTarget> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::RenderTarget::tag::RenderTarget:
+      obj["tag"] = "RenderTarget";
+      {
+        std::shared_ptr<data::RenderTarget> tv = std::static_pointer_cast<data::RenderTarget>(v);
+        obj["renderTargets"] = toJSON(tv->renderTargets);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<RenderTarget> fromJSON<std::shared_ptr<RenderTarget>>(W<std::shared_ptr<RenderTarget>> v, json &obj) {
+  enum ::RenderTarget::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "RenderTarget") {
+    tagType = ::RenderTarget::tag::RenderTarget;
+    std::shared_ptr<data::RenderTarget> tv(new data::RenderTarget());
+    tv->renderTargets = fromJSON(W<std::vector<std::shared_ptr<::TargetItem>>>(), obj["renderTargets"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::RenderTarget> o(new ::RenderTarget());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Backend>>(std::shared_ptr<Backend> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Backend::tag::WebGL1:
+      obj["tag"] = "WebGL1";
+      break;
+    case ::Backend::tag::OpenGL33:
+      obj["tag"] = "OpenGL33";
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Backend> fromJSON<std::shared_ptr<Backend>>(W<std::shared_ptr<Backend>> v, json &obj) {
+  enum ::Backend::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "WebGL1") {
+    tagType = ::Backend::tag::WebGL1;
+  }
+  else if (tag == "OpenGL33") {
+    tagType = ::Backend::tag::OpenGL33;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Backend> o(new ::Backend());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Pipeline>>(std::shared_ptr<Pipeline> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Pipeline::tag::Pipeline:
+      obj["tag"] = "Pipeline";
+      {
+        std::shared_ptr<data::Pipeline> tv = std::static_pointer_cast<data::Pipeline>(v);
+        obj["backend"] = toJSON(tv->backend);
+        obj["textures"] = toJSON(tv->textures);
+        obj["samplers"] = toJSON(tv->samplers);
+        obj["targets"] = toJSON(tv->targets);
+        obj["programs"] = toJSON(tv->programs);
+        obj["slots"] = toJSON(tv->slots);
+        obj["streams"] = toJSON(tv->streams);
+        obj["commands"] = toJSON(tv->commands);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Pipeline> fromJSON<std::shared_ptr<Pipeline>>(W<std::shared_ptr<Pipeline>> v, json &obj) {
+  enum ::Pipeline::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Pipeline") {
+    tagType = ::Pipeline::tag::Pipeline;
+    std::shared_ptr<data::Pipeline> tv(new data::Pipeline());
+    tv->backend = fromJSON(W<std::shared_ptr<::Backend>>(), obj["backend"]);
+    tv->textures = fromJSON(W<std::vector<std::shared_ptr<::TextureDescriptor>>>(), obj["textures"]);
+    tv->samplers = fromJSON(W<std::vector<std::shared_ptr<::SamplerDescriptor>>>(), obj["samplers"]);
+    tv->targets = fromJSON(W<std::vector<std::shared_ptr<::RenderTarget>>>(), obj["targets"]);
+    tv->programs = fromJSON(W<std::vector<std::shared_ptr<::Program>>>(), obj["programs"]);
+    tv->slots = fromJSON(W<std::vector<std::shared_ptr<::Slot>>>(), obj["slots"]);
+    tv->streams = fromJSON(W<std::vector<std::shared_ptr<::StreamData>>>(), obj["streams"]);
+    tv->commands = fromJSON(W<std::vector<std::shared_ptr<::Command>>>(), obj["commands"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Pipeline> o(new ::Pipeline());
+  o->tag = tagType;
+  return o;
+}
+
diff --git a/ddl/out/IR.hpp b/ddl/out/IR.hpp
new file mode 100644
index 0000000..3c6055f
--- /dev/null
+++ b/ddl/out/IR.hpp
@@ -0,0 +1,1070 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.420877000000Z
+
+#ifndef HEADER_IR_H
+#define HEADER_IR_H
+
+#include "RT.hpp"
+
+
+typedef Int StreamName;
+
+typedef Int ProgramName;
+
+typedef Int TextureName;
+
+typedef Int SamplerName;
+
+typedef String UniformName;
+
+typedef Int SlotName;
+
+typedef Int FrameBufferComponent;
+
+typedef Int TextureUnit;
+
+typedef Int RenderTargetName;
+
+typedef std::map<::UniformName, ::TextureUnit> TextureUnitMapping;
+
+class ArrayValue {
+  public:
+    enum class tag { 
+      VBoolArray,
+      VIntArray,
+      VWordArray,
+      VFloatArray
+    } tag;
+};
+namespace data { 
+  class VBoolArray : public ::ArrayValue {
+    public:
+      std::vector<Bool> _0;
+      VBoolArray() { tag = tag::VBoolArray; }
+  };
+  class VIntArray : public ::ArrayValue {
+    public:
+      std::vector<Int32> _0;
+      VIntArray() { tag = tag::VIntArray; }
+  };
+  class VWordArray : public ::ArrayValue {
+    public:
+      std::vector<Word32> _0;
+      VWordArray() { tag = tag::VWordArray; }
+  };
+  class VFloatArray : public ::ArrayValue {
+    public:
+      std::vector<Float> _0;
+      VFloatArray() { tag = tag::VFloatArray; }
+  };
+}
+class Value {
+  public:
+    enum class tag { 
+      VBool,
+      VV2B,
+      VV3B,
+      VV4B,
+      VWord,
+      VV2U,
+      VV3U,
+      VV4U,
+      VInt,
+      VV2I,
+      VV3I,
+      VV4I,
+      VFloat,
+      VV2F,
+      VV3F,
+      VV4F,
+      VM22F,
+      VM23F,
+      VM24F,
+      VM32F,
+      VM33F,
+      VM34F,
+      VM42F,
+      VM43F,
+      VM44F
+    } tag;
+};
+namespace data { 
+  class VBool : public ::Value {
+    public:
+      Bool _0;
+      VBool() { tag = tag::VBool; }
+  };
+  class VV2B : public ::Value {
+    public:
+      V2B _0;
+      VV2B() { tag = tag::VV2B; }
+  };
+  class VV3B : public ::Value {
+    public:
+      V3B _0;
+      VV3B() { tag = tag::VV3B; }
+  };
+  class VV4B : public ::Value {
+    public:
+      V4B _0;
+      VV4B() { tag = tag::VV4B; }
+  };
+  class VWord : public ::Value {
+    public:
+      Word32 _0;
+      VWord() { tag = tag::VWord; }
+  };
+  class VV2U : public ::Value {
+    public:
+      V2U _0;
+      VV2U() { tag = tag::VV2U; }
+  };
+  class VV3U : public ::Value {
+    public:
+      V3U _0;
+      VV3U() { tag = tag::VV3U; }
+  };
+  class VV4U : public ::Value {
+    public:
+      V4U _0;
+      VV4U() { tag = tag::VV4U; }
+  };
+  class VInt : public ::Value {
+    public:
+      Int32 _0;
+      VInt() { tag = tag::VInt; }
+  };
+  class VV2I : public ::Value {
+    public:
+      V2I _0;
+      VV2I() { tag = tag::VV2I; }
+  };
+  class VV3I : public ::Value {
+    public:
+      V3I _0;
+      VV3I() { tag = tag::VV3I; }
+  };
+  class VV4I : public ::Value {
+    public:
+      V4I _0;
+      VV4I() { tag = tag::VV4I; }
+  };
+  class VFloat : public ::Value {
+    public:
+      Float _0;
+      VFloat() { tag = tag::VFloat; }
+  };
+  class VV2F : public ::Value {
+    public:
+      V2F _0;
+      VV2F() { tag = tag::VV2F; }
+  };
+  class VV3F : public ::Value {
+    public:
+      V3F _0;
+      VV3F() { tag = tag::VV3F; }
+  };
+  class VV4F : public ::Value {
+    public:
+      V4F _0;
+      VV4F() { tag = tag::VV4F; }
+  };
+  class VM22F : public ::Value {
+    public:
+      M22F _0;
+      VM22F() { tag = tag::VM22F; }
+  };
+  class VM23F : public ::Value {
+    public:
+      M23F _0;
+      VM23F() { tag = tag::VM23F; }
+  };
+  class VM24F : public ::Value {
+    public:
+      M24F _0;
+      VM24F() { tag = tag::VM24F; }
+  };
+  class VM32F : public ::Value {
+    public:
+      M32F _0;
+      VM32F() { tag = tag::VM32F; }
+  };
+  class VM33F : public ::Value {
+    public:
+      M33F _0;
+      VM33F() { tag = tag::VM33F; }
+  };
+  class VM34F : public ::Value {
+    public:
+      M34F _0;
+      VM34F() { tag = tag::VM34F; }
+  };
+  class VM42F : public ::Value {
+    public:
+      M42F _0;
+      VM42F() { tag = tag::VM42F; }
+  };
+  class VM43F : public ::Value {
+    public:
+      M43F _0;
+      VM43F() { tag = tag::VM43F; }
+  };
+  class VM44F : public ::Value {
+    public:
+      M44F _0;
+      VM44F() { tag = tag::VM44F; }
+  };
+}
+class InputType {
+  public:
+    enum class tag { 
+      Bool,
+      V2B,
+      V3B,
+      V4B,
+      Word,
+      V2U,
+      V3U,
+      V4U,
+      Int,
+      V2I,
+      V3I,
+      V4I,
+      Float,
+      V2F,
+      V3F,
+      V4F,
+      M22F,
+      M23F,
+      M24F,
+      M32F,
+      M33F,
+      M34F,
+      M42F,
+      M43F,
+      M44F,
+      STexture1D,
+      STexture2D,
+      STextureCube,
+      STexture1DArray,
+      STexture2DArray,
+      STexture2DRect,
+      FTexture1D,
+      FTexture2D,
+      FTexture3D,
+      FTextureCube,
+      FTexture1DArray,
+      FTexture2DArray,
+      FTexture2DMS,
+      FTexture2DMSArray,
+      FTextureBuffer,
+      FTexture2DRect,
+      ITexture1D,
+      ITexture2D,
+      ITexture3D,
+      ITextureCube,
+      ITexture1DArray,
+      ITexture2DArray,
+      ITexture2DMS,
+      ITexture2DMSArray,
+      ITextureBuffer,
+      ITexture2DRect,
+      UTexture1D,
+      UTexture2D,
+      UTexture3D,
+      UTextureCube,
+      UTexture1DArray,
+      UTexture2DArray,
+      UTexture2DMS,
+      UTexture2DMSArray,
+      UTextureBuffer,
+      UTexture2DRect
+    } tag;
+};
+namespace data { 
+}
+class PointSpriteCoordOrigin {
+  public:
+    enum class tag { 
+      LowerLeft,
+      UpperLeft
+    } tag;
+};
+namespace data { 
+}
+class PointSize {
+  public:
+    enum class tag { 
+      PointSize,
+      ProgramPointSize
+    } tag;
+};
+namespace data { 
+  class PointSize : public ::PointSize {
+    public:
+      Float _0;
+      PointSize() { tag = tag::PointSize; }
+  };
+}
+class PolygonOffset {
+  public:
+    enum class tag { 
+      NoOffset,
+      Offset
+    } tag;
+};
+namespace data { 
+  class Offset : public ::PolygonOffset {
+    public:
+      Float _0;
+      Float _1;
+      Offset() { tag = tag::Offset; }
+  };
+}
+class FrontFace {
+  public:
+    enum class tag { 
+      CCW,
+      CW
+    } tag;
+};
+namespace data { 
+}
+class PolygonMode {
+  public:
+    enum class tag { 
+      PolygonPoint,
+      PolygonLine,
+      PolygonFill
+    } tag;
+};
+namespace data { 
+  class PolygonPoint : public ::PolygonMode {
+    public:
+      std::shared_ptr<::PointSize> _0;
+      PolygonPoint() { tag = tag::PolygonPoint; }
+  };
+  class PolygonLine : public ::PolygonMode {
+    public:
+      Float _0;
+      PolygonLine() { tag = tag::PolygonLine; }
+  };
+}
+class ProvokingVertex {
+  public:
+    enum class tag { 
+      FirstVertex,
+      LastVertex
+    } tag;
+};
+namespace data { 
+}
+class CullMode {
+  public:
+    enum class tag { 
+      CullNone,
+      CullFront,
+      CullBack
+    } tag;
+};
+namespace data { 
+  class CullFront : public ::CullMode {
+    public:
+      std::shared_ptr<::FrontFace> _0;
+      CullFront() { tag = tag::CullFront; }
+  };
+  class CullBack : public ::CullMode {
+    public:
+      std::shared_ptr<::FrontFace> _0;
+      CullBack() { tag = tag::CullBack; }
+  };
+}
+class ComparisonFunction {
+  public:
+    enum class tag { 
+      Never,
+      Less,
+      Equal,
+      Lequal,
+      Greater,
+      Notequal,
+      Gequal,
+      Always
+    } tag;
+};
+namespace data { 
+}
+typedef ComparisonFunction DepthFunction;
+
+class StencilOperation {
+  public:
+    enum class tag { 
+      OpZero,
+      OpKeep,
+      OpReplace,
+      OpIncr,
+      OpIncrWrap,
+      OpDecr,
+      OpDecrWrap,
+      OpInvert
+    } tag;
+};
+namespace data { 
+}
+class BlendEquation {
+  public:
+    enum class tag { 
+      FuncAdd,
+      FuncSubtract,
+      FuncReverseSubtract,
+      Min,
+      Max
+    } tag;
+};
+namespace data { 
+}
+class BlendingFactor {
+  public:
+    enum class tag { 
+      Zero,
+      One,
+      SrcColor,
+      OneMinusSrcColor,
+      DstColor,
+      OneMinusDstColor,
+      SrcAlpha,
+      OneMinusSrcAlpha,
+      DstAlpha,
+      OneMinusDstAlpha,
+      ConstantColor,
+      OneMinusConstantColor,
+      ConstantAlpha,
+      OneMinusConstantAlpha,
+      SrcAlphaSaturate
+    } tag;
+};
+namespace data { 
+}
+class LogicOperation {
+  public:
+    enum class tag { 
+      Clear,
+      And,
+      AndReverse,
+      Copy,
+      AndInverted,
+      Noop,
+      Xor,
+      Or,
+      Nor,
+      Equiv,
+      Invert,
+      OrReverse,
+      CopyInverted,
+      OrInverted,
+      Nand,
+      Set
+    } tag;
+};
+namespace data { 
+}
+class StencilOps {
+  public:
+    enum class tag { 
+      StencilOps
+    } tag;
+};
+namespace data { 
+  class StencilOps : public ::StencilOps {
+    public:
+      std::shared_ptr<::StencilOperation> frontStencilOp;
+      std::shared_ptr<::StencilOperation> backStencilOp;
+      StencilOps() { tag = tag::StencilOps; }
+  };
+}
+class StencilTest {
+  public:
+    enum class tag { 
+      StencilTest
+    } tag;
+};
+namespace data { 
+  class StencilTest : public ::StencilTest {
+    public:
+      std::shared_ptr<::ComparisonFunction> stencilComparision;
+      Int32 stencilReference;
+      Word32 stencilMask;
+      StencilTest() { tag = tag::StencilTest; }
+  };
+}
+class StencilTests {
+  public:
+    enum class tag { 
+      StencilTests
+    } tag;
+};
+namespace data { 
+  class StencilTests : public ::StencilTests {
+    public:
+      std::shared_ptr<::StencilTest> _0;
+      std::shared_ptr<::StencilTest> _1;
+      StencilTests() { tag = tag::StencilTests; }
+  };
+}
+class FetchPrimitive {
+  public:
+    enum class tag { 
+      Points,
+      Lines,
+      Triangles,
+      LinesAdjacency,
+      TrianglesAdjacency
+    } tag;
+};
+namespace data { 
+}
+class OutputPrimitive {
+  public:
+    enum class tag { 
+      TrianglesOutput,
+      LinesOutput,
+      PointsOutput
+    } tag;
+};
+namespace data { 
+}
+class ColorArity {
+  public:
+    enum class tag { 
+      Red,
+      RG,
+      RGB,
+      RGBA
+    } tag;
+};
+namespace data { 
+}
+class Blending {
+  public:
+    enum class tag { 
+      NoBlending,
+      BlendLogicOp,
+      Blend
+    } tag;
+};
+namespace data { 
+  class BlendLogicOp : public ::Blending {
+    public:
+      std::shared_ptr<::LogicOperation> _0;
+      BlendLogicOp() { tag = tag::BlendLogicOp; }
+  };
+  class Blend : public ::Blending {
+    public:
+      std::shared_ptr<::BlendEquation> colorEqSrc;
+      std::shared_ptr<::BlendEquation> alphaEqSrc;
+      std::shared_ptr<::BlendingFactor> colorFSrc;
+      std::shared_ptr<::BlendingFactor> colorFDst;
+      std::shared_ptr<::BlendingFactor> alphaFSrc;
+      std::shared_ptr<::BlendingFactor> alphaFDst;
+      V4F color;
+      Blend() { tag = tag::Blend; }
+  };
+}
+class RasterContext {
+  public:
+    enum class tag { 
+      PointCtx,
+      LineCtx,
+      TriangleCtx
+    } tag;
+};
+namespace data { 
+  class PointCtx : public ::RasterContext {
+    public:
+      std::shared_ptr<::PointSize> _0;
+      Float _1;
+      std::shared_ptr<::PointSpriteCoordOrigin> _2;
+      PointCtx() { tag = tag::PointCtx; }
+  };
+  class LineCtx : public ::RasterContext {
+    public:
+      Float _0;
+      std::shared_ptr<::ProvokingVertex> _1;
+      LineCtx() { tag = tag::LineCtx; }
+  };
+  class TriangleCtx : public ::RasterContext {
+    public:
+      std::shared_ptr<::CullMode> _0;
+      std::shared_ptr<::PolygonMode> _1;
+      std::shared_ptr<::PolygonOffset> _2;
+      std::shared_ptr<::ProvokingVertex> _3;
+      TriangleCtx() { tag = tag::TriangleCtx; }
+  };
+}
+class FragmentOperation {
+  public:
+    enum class tag { 
+      DepthOp,
+      StencilOp,
+      ColorOp
+    } tag;
+};
+namespace data { 
+  class DepthOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::DepthFunction> _0;
+      Bool _1;
+      DepthOp() { tag = tag::DepthOp; }
+  };
+  class StencilOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::StencilTests> _0;
+      std::shared_ptr<::StencilOps> _1;
+      std::shared_ptr<::StencilOps> _2;
+      StencilOp() { tag = tag::StencilOp; }
+  };
+  class ColorOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::Blending> _0;
+      std::shared_ptr<::Value> _1;
+      ColorOp() { tag = tag::ColorOp; }
+  };
+}
+class AccumulationContext {
+  public:
+    enum class tag { 
+      AccumulationContext
+    } tag;
+};
+namespace data { 
+  class AccumulationContext : public ::AccumulationContext {
+    public:
+      Maybe<String> accViewportName;
+      std::vector<std::shared_ptr<::FragmentOperation>> accOperations;
+      AccumulationContext() { tag = tag::AccumulationContext; }
+  };
+}
+class TextureDataType {
+  public:
+    enum class tag { 
+      FloatT,
+      IntT,
+      WordT,
+      ShadowT
+    } tag;
+};
+namespace data { 
+  class FloatT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      FloatT() { tag = tag::FloatT; }
+  };
+  class IntT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      IntT() { tag = tag::IntT; }
+  };
+  class WordT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      WordT() { tag = tag::WordT; }
+  };
+}
+class TextureType {
+  public:
+    enum class tag { 
+      Texture1D,
+      Texture2D,
+      Texture3D,
+      TextureCube,
+      TextureRect,
+      Texture2DMS,
+      TextureBuffer
+    } tag;
+};
+namespace data { 
+  class Texture1D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Texture1D() { tag = tag::Texture1D; }
+  };
+  class Texture2D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Texture2D() { tag = tag::Texture2D; }
+  };
+  class Texture3D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Texture3D() { tag = tag::Texture3D; }
+  };
+  class TextureCube : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureCube() { tag = tag::TextureCube; }
+  };
+  class TextureRect : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureRect() { tag = tag::TextureRect; }
+  };
+  class Texture2DMS : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Int _2;
+      Bool _3;
+      Texture2DMS() { tag = tag::Texture2DMS; }
+  };
+  class TextureBuffer : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureBuffer() { tag = tag::TextureBuffer; }
+  };
+}
+class MipMap {
+  public:
+    enum class tag { 
+      Mip,
+      NoMip,
+      AutoMip
+    } tag;
+};
+namespace data { 
+  class Mip : public ::MipMap {
+    public:
+      Int _0;
+      Int _1;
+      Mip() { tag = tag::Mip; }
+  };
+  class AutoMip : public ::MipMap {
+    public:
+      Int _0;
+      Int _1;
+      AutoMip() { tag = tag::AutoMip; }
+  };
+}
+class Filter {
+  public:
+    enum class tag { 
+      Nearest,
+      Linear,
+      NearestMipmapNearest,
+      NearestMipmapLinear,
+      LinearMipmapNearest,
+      LinearMipmapLinear
+    } tag;
+};
+namespace data { 
+}
+class EdgeMode {
+  public:
+    enum class tag { 
+      Repeat,
+      MirroredRepeat,
+      ClampToEdge,
+      ClampToBorder
+    } tag;
+};
+namespace data { 
+}
+class ImageSemantic {
+  public:
+    enum class tag { 
+      Depth,
+      Stencil,
+      Color
+    } tag;
+};
+namespace data { 
+}
+class ImageRef {
+  public:
+    enum class tag { 
+      TextureImage,
+      Framebuffer
+    } tag;
+};
+namespace data { 
+  class TextureImage : public ::ImageRef {
+    public:
+      ::TextureName _0;
+      Int _1;
+      Maybe<Int> _2;
+      TextureImage() { tag = tag::TextureImage; }
+  };
+  class Framebuffer : public ::ImageRef {
+    public:
+      std::shared_ptr<::ImageSemantic> _0;
+      Framebuffer() { tag = tag::Framebuffer; }
+  };
+}
+class ClearImage {
+  public:
+    enum class tag { 
+      ClearImage
+    } tag;
+};
+namespace data { 
+  class ClearImage : public ::ClearImage {
+    public:
+      std::shared_ptr<::ImageSemantic> imageSemantic;
+      std::shared_ptr<::Value> clearValue;
+      ClearImage() { tag = tag::ClearImage; }
+  };
+}
+class Command {
+  public:
+    enum class tag { 
+      SetRasterContext,
+      SetAccumulationContext,
+      SetRenderTarget,
+      SetProgram,
+      SetSamplerUniform,
+      SetTexture,
+      SetSampler,
+      RenderSlot,
+      RenderStream,
+      ClearRenderTarget,
+      GenerateMipMap,
+      SaveImage,
+      LoadImage
+    } tag;
+};
+namespace data { 
+  class SetRasterContext : public ::Command {
+    public:
+      std::shared_ptr<::RasterContext> _0;
+      SetRasterContext() { tag = tag::SetRasterContext; }
+  };
+  class SetAccumulationContext : public ::Command {
+    public:
+      std::shared_ptr<::AccumulationContext> _0;
+      SetAccumulationContext() { tag = tag::SetAccumulationContext; }
+  };
+  class SetRenderTarget : public ::Command {
+    public:
+      ::RenderTargetName _0;
+      SetRenderTarget() { tag = tag::SetRenderTarget; }
+  };
+  class SetProgram : public ::Command {
+    public:
+      ::ProgramName _0;
+      SetProgram() { tag = tag::SetProgram; }
+  };
+  class SetSamplerUniform : public ::Command {
+    public:
+      ::UniformName _0;
+      ::TextureUnit _1;
+      SetSamplerUniform() { tag = tag::SetSamplerUniform; }
+  };
+  class SetTexture : public ::Command {
+    public:
+      ::TextureUnit _0;
+      ::TextureName _1;
+      SetTexture() { tag = tag::SetTexture; }
+  };
+  class SetSampler : public ::Command {
+    public:
+      ::TextureUnit _0;
+      Maybe<::SamplerName> _1;
+      SetSampler() { tag = tag::SetSampler; }
+  };
+  class RenderSlot : public ::Command {
+    public:
+      ::SlotName _0;
+      RenderSlot() { tag = tag::RenderSlot; }
+  };
+  class RenderStream : public ::Command {
+    public:
+      ::StreamName _0;
+      RenderStream() { tag = tag::RenderStream; }
+  };
+  class ClearRenderTarget : public ::Command {
+    public:
+      std::vector<std::shared_ptr<::ClearImage>> _0;
+      ClearRenderTarget() { tag = tag::ClearRenderTarget; }
+  };
+  class GenerateMipMap : public ::Command {
+    public:
+      ::TextureUnit _0;
+      GenerateMipMap() { tag = tag::GenerateMipMap; }
+  };
+  class SaveImage : public ::Command {
+    public:
+      ::FrameBufferComponent _0;
+      std::shared_ptr<::ImageRef> _1;
+      SaveImage() { tag = tag::SaveImage; }
+  };
+  class LoadImage : public ::Command {
+    public:
+      std::shared_ptr<::ImageRef> _0;
+      ::FrameBufferComponent _1;
+      LoadImage() { tag = tag::LoadImage; }
+  };
+}
+class SamplerDescriptor {
+  public:
+    enum class tag { 
+      SamplerDescriptor
+    } tag;
+};
+namespace data { 
+  class SamplerDescriptor : public ::SamplerDescriptor {
+    public:
+      std::shared_ptr<::EdgeMode> samplerWrapS;
+      Maybe<std::shared_ptr<::EdgeMode>> samplerWrapT;
+      Maybe<std::shared_ptr<::EdgeMode>> samplerWrapR;
+      std::shared_ptr<::Filter> samplerMinFilter;
+      std::shared_ptr<::Filter> samplerMagFilter;
+      std::shared_ptr<::Value> samplerBorderColor;
+      Maybe<Float> samplerMinLod;
+      Maybe<Float> samplerMaxLod;
+      Float samplerLodBias;
+      Maybe<std::shared_ptr<::ComparisonFunction>> samplerCompareFunc;
+      SamplerDescriptor() { tag = tag::SamplerDescriptor; }
+  };
+}
+class TextureDescriptor {
+  public:
+    enum class tag { 
+      TextureDescriptor
+    } tag;
+};
+namespace data { 
+  class TextureDescriptor : public ::TextureDescriptor {
+    public:
+      std::shared_ptr<::TextureType> textureType;
+      std::shared_ptr<::Value> textureSize;
+      std::shared_ptr<::ImageSemantic> textureSemantic;
+      std::shared_ptr<::SamplerDescriptor> textureSampler;
+      Int textureBaseLevel;
+      Int textureMaxLevel;
+      TextureDescriptor() { tag = tag::TextureDescriptor; }
+  };
+}
+class Parameter {
+  public:
+    enum class tag { 
+      Parameter
+    } tag;
+};
+namespace data { 
+  class Parameter : public ::Parameter {
+    public:
+      String name;
+      std::shared_ptr<::InputType> ty;
+      Parameter() { tag = tag::Parameter; }
+  };
+}
+class Program {
+  public:
+    enum class tag { 
+      Program
+    } tag;
+};
+namespace data { 
+  class Program : public ::Program {
+    public:
+      std::map<::UniformName, std::shared_ptr<::InputType>> programUniforms;
+      std::map<::UniformName, std::shared_ptr<::Parameter>> programStreams;
+      std::map<::UniformName, std::shared_ptr<::InputType>> programInTextures;
+      std::vector<std::shared_ptr<::Parameter>> programOutput;
+      String vertexShader;
+      Maybe<String> geometryShader;
+      String fragmentShader;
+      Program() { tag = tag::Program; }
+  };
+}
+class Slot {
+  public:
+    enum class tag { 
+      Slot
+    } tag;
+};
+namespace data { 
+  class Slot : public ::Slot {
+    public:
+      String slotName;
+      std::map<String, std::shared_ptr<::InputType>> slotStreams;
+      std::map<::UniformName, std::shared_ptr<::InputType>> slotUniforms;
+      std::shared_ptr<::FetchPrimitive> slotPrimitive;
+      std::vector<::ProgramName> slotPrograms;
+      Slot() { tag = tag::Slot; }
+  };
+}
+class StreamData {
+  public:
+    enum class tag { 
+      StreamData
+    } tag;
+};
+namespace data { 
+  class StreamData : public ::StreamData {
+    public:
+      std::map<String, std::shared_ptr<::ArrayValue>> streamData;
+      std::map<String, std::shared_ptr<::InputType>> streamType;
+      std::shared_ptr<::FetchPrimitive> streamPrimitive;
+      std::vector<::ProgramName> streamPrograms;
+      StreamData() { tag = tag::StreamData; }
+  };
+}
+class TargetItem {
+  public:
+    enum class tag { 
+      TargetItem
+    } tag;
+};
+namespace data { 
+  class TargetItem : public ::TargetItem {
+    public:
+      std::shared_ptr<::ImageSemantic> targetSemantic;
+      Maybe<std::shared_ptr<::ImageRef>> targetRef;
+      TargetItem() { tag = tag::TargetItem; }
+  };
+}
+class RenderTarget {
+  public:
+    enum class tag { 
+      RenderTarget
+    } tag;
+};
+namespace data { 
+  class RenderTarget : public ::RenderTarget {
+    public:
+      std::vector<std::shared_ptr<::TargetItem>> renderTargets;
+      RenderTarget() { tag = tag::RenderTarget; }
+  };
+}
+class Backend {
+  public:
+    enum class tag { 
+      WebGL1,
+      OpenGL33
+    } tag;
+};
+namespace data { 
+}
+class Pipeline {
+  public:
+    enum class tag { 
+      Pipeline
+    } tag;
+};
+namespace data { 
+  class Pipeline : public ::Pipeline {
+    public:
+      std::shared_ptr<::Backend> backend;
+      std::vector<std::shared_ptr<::TextureDescriptor>> textures;
+      std::vector<std::shared_ptr<::SamplerDescriptor>> samplers;
+      std::vector<std::shared_ptr<::RenderTarget>> targets;
+      std::vector<std::shared_ptr<::Program>> programs;
+      std::vector<std::shared_ptr<::Slot>> slots;
+      std::vector<std::shared_ptr<::StreamData>> streams;
+      std::vector<std::shared_ptr<::Command>> commands;
+      Pipeline() { tag = tag::Pipeline; }
+  };
+}
+#endif
diff --git a/ddl/out/IR.hs b/ddl/out/IR.hs
new file mode 100644
index 0000000..a788161
--- /dev/null
+++ b/ddl/out/IR.hs
@@ -0,0 +1,1608 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.420877000000Z
+
+{-# LANGUAGE OverloadedStrings, RecordWildCards #-}
+module IR where
+
+import Data.Int
+import Data.Word
+import Data.Map
+import Data.Vector (Vector(..))
+import Linear
+
+import Data.Text
+import Data.Aeson hiding (Value,Bool)
+import Data.Aeson.Types hiding (Value,Bool)
+import Control.Monad
+
+
+type StreamName = Int
+
+type ProgramName = Int
+
+type TextureName = Int
+
+type SamplerName = Int
+
+type UniformName = String
+
+type SlotName = Int
+
+type FrameBufferComponent = Int
+
+type TextureUnit = Int
+
+type RenderTargetName = Int
+
+type TextureUnitMapping = Map UniformName TextureUnit
+
+data ArrayValue
+  = VBoolArray (Vector Bool)
+  | VIntArray (Vector Int32)
+  | VWordArray (Vector Word32)
+  | VFloatArray (Vector Float)
+  deriving (Show, Eq, Ord)
+
+data Value
+  = VBool Bool
+  | VV2B V2B
+  | VV3B V3B
+  | VV4B V4B
+  | VWord Word32
+  | VV2U V2U
+  | VV3U V3U
+  | VV4U V4U
+  | VInt Int32
+  | VV2I V2I
+  | VV3I V3I
+  | VV4I V4I
+  | VFloat Float
+  | VV2F V2F
+  | VV3F V3F
+  | VV4F V4F
+  | VM22F M22F
+  | VM23F M23F
+  | VM24F M24F
+  | VM32F M32F
+  | VM33F M33F
+  | VM34F M34F
+  | VM42F M42F
+  | VM43F M43F
+  | VM44F M44F
+  deriving (Show, Eq, Ord)
+
+data InputType
+  = Bool
+  | V2B
+  | V3B
+  | V4B
+  | Word
+  | V2U
+  | V3U
+  | V4U
+  | Int
+  | V2I
+  | V3I
+  | V4I
+  | Float
+  | V2F
+  | V3F
+  | V4F
+  | M22F
+  | M23F
+  | M24F
+  | M32F
+  | M33F
+  | M34F
+  | M42F
+  | M43F
+  | M44F
+  | STexture1D
+  | STexture2D
+  | STextureCube
+  | STexture1DArray
+  | STexture2DArray
+  | STexture2DRect
+  | FTexture1D
+  | FTexture2D
+  | FTexture3D
+  | FTextureCube
+  | FTexture1DArray
+  | FTexture2DArray
+  | FTexture2DMS
+  | FTexture2DMSArray
+  | FTextureBuffer
+  | FTexture2DRect
+  | ITexture1D
+  | ITexture2D
+  | ITexture3D
+  | ITextureCube
+  | ITexture1DArray
+  | ITexture2DArray
+  | ITexture2DMS
+  | ITexture2DMSArray
+  | ITextureBuffer
+  | ITexture2DRect
+  | UTexture1D
+  | UTexture2D
+  | UTexture3D
+  | UTextureCube
+  | UTexture1DArray
+  | UTexture2DArray
+  | UTexture2DMS
+  | UTexture2DMSArray
+  | UTextureBuffer
+  | UTexture2DRect
+  deriving (Show, Eq, Ord)
+
+data PointSpriteCoordOrigin
+  = LowerLeft
+  | UpperLeft
+  deriving (Show, Eq, Ord)
+
+data PointSize
+  = PointSize Float
+  | ProgramPointSize
+  deriving (Show, Eq, Ord)
+
+data PolygonOffset
+  = NoOffset
+  | Offset Float Float
+  deriving (Show, Eq, Ord)
+
+data FrontFace
+  = CCW
+  | CW
+  deriving (Show, Eq, Ord)
+
+data PolygonMode
+  = PolygonPoint PointSize
+  | PolygonLine Float
+  | PolygonFill
+  deriving (Show, Eq, Ord)
+
+data ProvokingVertex
+  = FirstVertex
+  | LastVertex
+  deriving (Show, Eq, Ord)
+
+data CullMode
+  = CullNone
+  | CullFront FrontFace
+  | CullBack FrontFace
+  deriving (Show, Eq, Ord)
+
+data ComparisonFunction
+  = Never
+  | Less
+  | Equal
+  | Lequal
+  | Greater
+  | Notequal
+  | Gequal
+  | Always
+  deriving (Show, Eq, Ord)
+
+type DepthFunction = ComparisonFunction
+
+data StencilOperation
+  = OpZero
+  | OpKeep
+  | OpReplace
+  | OpIncr
+  | OpIncrWrap
+  | OpDecr
+  | OpDecrWrap
+  | OpInvert
+  deriving (Show, Eq, Ord)
+
+data BlendEquation
+  = FuncAdd
+  | FuncSubtract
+  | FuncReverseSubtract
+  | Min
+  | Max
+  deriving (Show, Eq, Ord)
+
+data BlendingFactor
+  = Zero
+  | One
+  | SrcColor
+  | OneMinusSrcColor
+  | DstColor
+  | OneMinusDstColor
+  | SrcAlpha
+  | OneMinusSrcAlpha
+  | DstAlpha
+  | OneMinusDstAlpha
+  | ConstantColor
+  | OneMinusConstantColor
+  | ConstantAlpha
+  | OneMinusConstantAlpha
+  | SrcAlphaSaturate
+  deriving (Show, Eq, Ord)
+
+data LogicOperation
+  = Clear
+  | And
+  | AndReverse
+  | Copy
+  | AndInverted
+  | Noop
+  | Xor
+  | Or
+  | Nor
+  | Equiv
+  | Invert
+  | OrReverse
+  | CopyInverted
+  | OrInverted
+  | Nand
+  | Set
+  deriving (Show, Eq, Ord)
+
+data StencilOps
+  = StencilOps
+  { frontStencilOp :: StencilOperation
+  , backStencilOp :: StencilOperation
+  }
+
+  deriving (Show, Eq, Ord)
+
+data StencilTest
+  = StencilTest
+  { stencilComparision :: ComparisonFunction
+  , stencilReference :: Int32
+  , stencilMask :: Word32
+  }
+
+  deriving (Show, Eq, Ord)
+
+data StencilTests
+  = StencilTests StencilTest StencilTest
+  deriving (Show, Eq, Ord)
+
+data FetchPrimitive
+  = Points
+  | Lines
+  | Triangles
+  | LinesAdjacency
+  | TrianglesAdjacency
+  deriving (Show, Eq, Ord)
+
+data OutputPrimitive
+  = TrianglesOutput
+  | LinesOutput
+  | PointsOutput
+  deriving (Show, Eq, Ord)
+
+data ColorArity
+  = Red
+  | RG
+  | RGB
+  | RGBA
+  deriving (Show, Eq, Ord)
+
+data Blending
+  = NoBlending
+  | BlendLogicOp LogicOperation
+  | Blend
+  { colorEqSrc :: BlendEquation
+  , alphaEqSrc :: BlendEquation
+  , colorFSrc :: BlendingFactor
+  , colorFDst :: BlendingFactor
+  , alphaFSrc :: BlendingFactor
+  , alphaFDst :: BlendingFactor
+  , color :: V4F
+  }
+
+  deriving (Show, Eq, Ord)
+
+data RasterContext
+  = PointCtx PointSize Float PointSpriteCoordOrigin
+  | LineCtx Float ProvokingVertex
+  | TriangleCtx CullMode PolygonMode PolygonOffset ProvokingVertex
+  deriving (Show, Eq, Ord)
+
+data FragmentOperation
+  = DepthOp DepthFunction Bool
+  | StencilOp StencilTests StencilOps StencilOps
+  | ColorOp Blending Value
+  deriving (Show, Eq, Ord)
+
+data AccumulationContext
+  = AccumulationContext
+  { accViewportName :: Maybe String
+  , accOperations :: [FragmentOperation]
+  }
+
+  deriving (Show, Eq, Ord)
+
+data TextureDataType
+  = FloatT ColorArity
+  | IntT ColorArity
+  | WordT ColorArity
+  | ShadowT
+  deriving (Show, Eq, Ord)
+
+data TextureType
+  = Texture1D TextureDataType Int
+  | Texture2D TextureDataType Int
+  | Texture3D TextureDataType
+  | TextureCube TextureDataType
+  | TextureRect TextureDataType
+  | Texture2DMS TextureDataType Int Int Bool
+  | TextureBuffer TextureDataType
+  deriving (Show, Eq, Ord)
+
+data MipMap
+  = Mip Int Int
+  | NoMip
+  | AutoMip Int Int
+  deriving (Show, Eq, Ord)
+
+data Filter
+  = Nearest
+  | Linear
+  | NearestMipmapNearest
+  | NearestMipmapLinear
+  | LinearMipmapNearest
+  | LinearMipmapLinear
+  deriving (Show, Eq, Ord)
+
+data EdgeMode
+  = Repeat
+  | MirroredRepeat
+  | ClampToEdge
+  | ClampToBorder
+  deriving (Show, Eq, Ord)
+
+data ImageSemantic
+  = Depth
+  | Stencil
+  | Color
+  deriving (Show, Eq, Ord)
+
+data ImageRef
+  = TextureImage TextureName Int (Maybe Int)
+  | Framebuffer ImageSemantic
+  deriving (Show, Eq, Ord)
+
+data ClearImage
+  = ClearImage
+  { imageSemantic :: ImageSemantic
+  , clearValue :: Value
+  }
+
+  deriving (Show, Eq, Ord)
+
+data Command
+  = SetRasterContext RasterContext
+  | SetAccumulationContext AccumulationContext
+  | SetRenderTarget RenderTargetName
+  | SetProgram ProgramName
+  | SetSamplerUniform UniformName TextureUnit
+  | SetTexture TextureUnit TextureName
+  | SetSampler TextureUnit (Maybe SamplerName)
+  | RenderSlot SlotName
+  | RenderStream StreamName
+  | ClearRenderTarget (Vector ClearImage)
+  | GenerateMipMap TextureUnit
+  | SaveImage FrameBufferComponent ImageRef
+  | LoadImage ImageRef FrameBufferComponent
+  deriving (Show, Eq, Ord)
+
+data SamplerDescriptor
+  = SamplerDescriptor
+  { samplerWrapS :: EdgeMode
+  , samplerWrapT :: Maybe EdgeMode
+  , samplerWrapR :: Maybe EdgeMode
+  , samplerMinFilter :: Filter
+  , samplerMagFilter :: Filter
+  , samplerBorderColor :: Value
+  , samplerMinLod :: Maybe Float
+  , samplerMaxLod :: Maybe Float
+  , samplerLodBias :: Float
+  , samplerCompareFunc :: Maybe ComparisonFunction
+  }
+
+  deriving (Show, Eq, Ord)
+
+data TextureDescriptor
+  = TextureDescriptor
+  { textureType :: TextureType
+  , textureSize :: Value
+  , textureSemantic :: ImageSemantic
+  , textureSampler :: SamplerDescriptor
+  , textureBaseLevel :: Int
+  , textureMaxLevel :: Int
+  }
+
+  deriving (Show, Eq, Ord)
+
+data Parameter
+  = Parameter
+  { name :: String
+  , ty :: InputType
+  }
+
+  deriving (Show, Eq, Ord)
+
+data Program
+  = Program
+  { programUniforms :: Map UniformName InputType
+  , programStreams :: Map UniformName Parameter
+  , programInTextures :: Map UniformName InputType
+  , programOutput :: Vector Parameter
+  , vertexShader :: String
+  , geometryShader :: Maybe String
+  , fragmentShader :: String
+  }
+
+  deriving (Show, Eq, Ord)
+
+data Slot
+  = Slot
+  { slotName :: String
+  , slotStreams :: Map String InputType
+  , slotUniforms :: Map UniformName InputType
+  , slotPrimitive :: FetchPrimitive
+  , slotPrograms :: Vector ProgramName
+  }
+
+  deriving (Show, Eq, Ord)
+
+data StreamData
+  = StreamData
+  { streamData :: Map String ArrayValue
+  , streamType :: Map String InputType
+  , streamPrimitive :: FetchPrimitive
+  , streamPrograms :: Vector ProgramName
+  }
+
+  deriving (Show, Eq, Ord)
+
+data TargetItem
+  = TargetItem
+  { targetSemantic :: ImageSemantic
+  , targetRef :: Maybe ImageRef
+  }
+
+  deriving (Show, Eq, Ord)
+
+data RenderTarget
+  = RenderTarget
+  { renderTargets :: Vector TargetItem
+  }
+
+  deriving (Show, Eq, Ord)
+
+data Backend
+  = WebGL1
+  | OpenGL33
+  deriving (Show, Eq, Ord)
+
+data Pipeline
+  = Pipeline
+  { backend :: Backend
+  , textures :: Vector TextureDescriptor
+  , samplers :: Vector SamplerDescriptor
+  , targets :: Vector RenderTarget
+  , programs :: Vector Program
+  , slots :: Vector Slot
+  , streams :: Vector StreamData
+  , commands :: Vector Command
+  }
+
+  deriving (Show, Eq, Ord)
+
+
+instance ToJSON ArrayValue where
+  toJSON v = case v of
+    VBoolArray arg0 -> object [ "tag" .= ("VBoolArray" :: Text), "arg0" .= arg0]
+    VIntArray arg0 -> object [ "tag" .= ("VIntArray" :: Text), "arg0" .= arg0]
+    VWordArray arg0 -> object [ "tag" .= ("VWordArray" :: Text), "arg0" .= arg0]
+    VFloatArray arg0 -> object [ "tag" .= ("VFloatArray" :: Text), "arg0" .= arg0]
+
+instance FromJSON ArrayValue where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "VBoolArray" -> VBoolArray <$> obj .: "arg0"
+      "VIntArray" -> VIntArray <$> obj .: "arg0"
+      "VWordArray" -> VWordArray <$> obj .: "arg0"
+      "VFloatArray" -> VFloatArray <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON Value where
+  toJSON v = case v of
+    VBool arg0 -> object [ "tag" .= ("VBool" :: Text), "arg0" .= arg0]
+    VV2B arg0 -> object [ "tag" .= ("VV2B" :: Text), "arg0" .= arg0]
+    VV3B arg0 -> object [ "tag" .= ("VV3B" :: Text), "arg0" .= arg0]
+    VV4B arg0 -> object [ "tag" .= ("VV4B" :: Text), "arg0" .= arg0]
+    VWord arg0 -> object [ "tag" .= ("VWord" :: Text), "arg0" .= arg0]
+    VV2U arg0 -> object [ "tag" .= ("VV2U" :: Text), "arg0" .= arg0]
+    VV3U arg0 -> object [ "tag" .= ("VV3U" :: Text), "arg0" .= arg0]
+    VV4U arg0 -> object [ "tag" .= ("VV4U" :: Text), "arg0" .= arg0]
+    VInt arg0 -> object [ "tag" .= ("VInt" :: Text), "arg0" .= arg0]
+    VV2I arg0 -> object [ "tag" .= ("VV2I" :: Text), "arg0" .= arg0]
+    VV3I arg0 -> object [ "tag" .= ("VV3I" :: Text), "arg0" .= arg0]
+    VV4I arg0 -> object [ "tag" .= ("VV4I" :: Text), "arg0" .= arg0]
+    VFloat arg0 -> object [ "tag" .= ("VFloat" :: Text), "arg0" .= arg0]
+    VV2F arg0 -> object [ "tag" .= ("VV2F" :: Text), "arg0" .= arg0]
+    VV3F arg0 -> object [ "tag" .= ("VV3F" :: Text), "arg0" .= arg0]
+    VV4F arg0 -> object [ "tag" .= ("VV4F" :: Text), "arg0" .= arg0]
+    VM22F arg0 -> object [ "tag" .= ("VM22F" :: Text), "arg0" .= arg0]
+    VM23F arg0 -> object [ "tag" .= ("VM23F" :: Text), "arg0" .= arg0]
+    VM24F arg0 -> object [ "tag" .= ("VM24F" :: Text), "arg0" .= arg0]
+    VM32F arg0 -> object [ "tag" .= ("VM32F" :: Text), "arg0" .= arg0]
+    VM33F arg0 -> object [ "tag" .= ("VM33F" :: Text), "arg0" .= arg0]
+    VM34F arg0 -> object [ "tag" .= ("VM34F" :: Text), "arg0" .= arg0]
+    VM42F arg0 -> object [ "tag" .= ("VM42F" :: Text), "arg0" .= arg0]
+    VM43F arg0 -> object [ "tag" .= ("VM43F" :: Text), "arg0" .= arg0]
+    VM44F arg0 -> object [ "tag" .= ("VM44F" :: Text), "arg0" .= arg0]
+
+instance FromJSON Value where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "VBool" -> VBool <$> obj .: "arg0"
+      "VV2B" -> VV2B <$> obj .: "arg0"
+      "VV3B" -> VV3B <$> obj .: "arg0"
+      "VV4B" -> VV4B <$> obj .: "arg0"
+      "VWord" -> VWord <$> obj .: "arg0"
+      "VV2U" -> VV2U <$> obj .: "arg0"
+      "VV3U" -> VV3U <$> obj .: "arg0"
+      "VV4U" -> VV4U <$> obj .: "arg0"
+      "VInt" -> VInt <$> obj .: "arg0"
+      "VV2I" -> VV2I <$> obj .: "arg0"
+      "VV3I" -> VV3I <$> obj .: "arg0"
+      "VV4I" -> VV4I <$> obj .: "arg0"
+      "VFloat" -> VFloat <$> obj .: "arg0"
+      "VV2F" -> VV2F <$> obj .: "arg0"
+      "VV3F" -> VV3F <$> obj .: "arg0"
+      "VV4F" -> VV4F <$> obj .: "arg0"
+      "VM22F" -> VM22F <$> obj .: "arg0"
+      "VM23F" -> VM23F <$> obj .: "arg0"
+      "VM24F" -> VM24F <$> obj .: "arg0"
+      "VM32F" -> VM32F <$> obj .: "arg0"
+      "VM33F" -> VM33F <$> obj .: "arg0"
+      "VM34F" -> VM34F <$> obj .: "arg0"
+      "VM42F" -> VM42F <$> obj .: "arg0"
+      "VM43F" -> VM43F <$> obj .: "arg0"
+      "VM44F" -> VM44F <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON InputType where
+  toJSON v = case v of
+    Bool -> object [ "tag" .= ("Bool" :: Text)]
+    V2B -> object [ "tag" .= ("V2B" :: Text)]
+    V3B -> object [ "tag" .= ("V3B" :: Text)]
+    V4B -> object [ "tag" .= ("V4B" :: Text)]
+    Word -> object [ "tag" .= ("Word" :: Text)]
+    V2U -> object [ "tag" .= ("V2U" :: Text)]
+    V3U -> object [ "tag" .= ("V3U" :: Text)]
+    V4U -> object [ "tag" .= ("V4U" :: Text)]
+    Int -> object [ "tag" .= ("Int" :: Text)]
+    V2I -> object [ "tag" .= ("V2I" :: Text)]
+    V3I -> object [ "tag" .= ("V3I" :: Text)]
+    V4I -> object [ "tag" .= ("V4I" :: Text)]
+    Float -> object [ "tag" .= ("Float" :: Text)]
+    V2F -> object [ "tag" .= ("V2F" :: Text)]
+    V3F -> object [ "tag" .= ("V3F" :: Text)]
+    V4F -> object [ "tag" .= ("V4F" :: Text)]
+    M22F -> object [ "tag" .= ("M22F" :: Text)]
+    M23F -> object [ "tag" .= ("M23F" :: Text)]
+    M24F -> object [ "tag" .= ("M24F" :: Text)]
+    M32F -> object [ "tag" .= ("M32F" :: Text)]
+    M33F -> object [ "tag" .= ("M33F" :: Text)]
+    M34F -> object [ "tag" .= ("M34F" :: Text)]
+    M42F -> object [ "tag" .= ("M42F" :: Text)]
+    M43F -> object [ "tag" .= ("M43F" :: Text)]
+    M44F -> object [ "tag" .= ("M44F" :: Text)]
+    STexture1D -> object [ "tag" .= ("STexture1D" :: Text)]
+    STexture2D -> object [ "tag" .= ("STexture2D" :: Text)]
+    STextureCube -> object [ "tag" .= ("STextureCube" :: Text)]
+    STexture1DArray -> object [ "tag" .= ("STexture1DArray" :: Text)]
+    STexture2DArray -> object [ "tag" .= ("STexture2DArray" :: Text)]
+    STexture2DRect -> object [ "tag" .= ("STexture2DRect" :: Text)]
+    FTexture1D -> object [ "tag" .= ("FTexture1D" :: Text)]
+    FTexture2D -> object [ "tag" .= ("FTexture2D" :: Text)]
+    FTexture3D -> object [ "tag" .= ("FTexture3D" :: Text)]
+    FTextureCube -> object [ "tag" .= ("FTextureCube" :: Text)]
+    FTexture1DArray -> object [ "tag" .= ("FTexture1DArray" :: Text)]
+    FTexture2DArray -> object [ "tag" .= ("FTexture2DArray" :: Text)]
+    FTexture2DMS -> object [ "tag" .= ("FTexture2DMS" :: Text)]
+    FTexture2DMSArray -> object [ "tag" .= ("FTexture2DMSArray" :: Text)]
+    FTextureBuffer -> object [ "tag" .= ("FTextureBuffer" :: Text)]
+    FTexture2DRect -> object [ "tag" .= ("FTexture2DRect" :: Text)]
+    ITexture1D -> object [ "tag" .= ("ITexture1D" :: Text)]
+    ITexture2D -> object [ "tag" .= ("ITexture2D" :: Text)]
+    ITexture3D -> object [ "tag" .= ("ITexture3D" :: Text)]
+    ITextureCube -> object [ "tag" .= ("ITextureCube" :: Text)]
+    ITexture1DArray -> object [ "tag" .= ("ITexture1DArray" :: Text)]
+    ITexture2DArray -> object [ "tag" .= ("ITexture2DArray" :: Text)]
+    ITexture2DMS -> object [ "tag" .= ("ITexture2DMS" :: Text)]
+    ITexture2DMSArray -> object [ "tag" .= ("ITexture2DMSArray" :: Text)]
+    ITextureBuffer -> object [ "tag" .= ("ITextureBuffer" :: Text)]
+    ITexture2DRect -> object [ "tag" .= ("ITexture2DRect" :: Text)]
+    UTexture1D -> object [ "tag" .= ("UTexture1D" :: Text)]
+    UTexture2D -> object [ "tag" .= ("UTexture2D" :: Text)]
+    UTexture3D -> object [ "tag" .= ("UTexture3D" :: Text)]
+    UTextureCube -> object [ "tag" .= ("UTextureCube" :: Text)]
+    UTexture1DArray -> object [ "tag" .= ("UTexture1DArray" :: Text)]
+    UTexture2DArray -> object [ "tag" .= ("UTexture2DArray" :: Text)]
+    UTexture2DMS -> object [ "tag" .= ("UTexture2DMS" :: Text)]
+    UTexture2DMSArray -> object [ "tag" .= ("UTexture2DMSArray" :: Text)]
+    UTextureBuffer -> object [ "tag" .= ("UTextureBuffer" :: Text)]
+    UTexture2DRect -> object [ "tag" .= ("UTexture2DRect" :: Text)]
+
+instance FromJSON InputType where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Bool" -> pure Bool
+      "V2B" -> pure V2B
+      "V3B" -> pure V3B
+      "V4B" -> pure V4B
+      "Word" -> pure Word
+      "V2U" -> pure V2U
+      "V3U" -> pure V3U
+      "V4U" -> pure V4U
+      "Int" -> pure Int
+      "V2I" -> pure V2I
+      "V3I" -> pure V3I
+      "V4I" -> pure V4I
+      "Float" -> pure Float
+      "V2F" -> pure V2F
+      "V3F" -> pure V3F
+      "V4F" -> pure V4F
+      "M22F" -> pure M22F
+      "M23F" -> pure M23F
+      "M24F" -> pure M24F
+      "M32F" -> pure M32F
+      "M33F" -> pure M33F
+      "M34F" -> pure M34F
+      "M42F" -> pure M42F
+      "M43F" -> pure M43F
+      "M44F" -> pure M44F
+      "STexture1D" -> pure STexture1D
+      "STexture2D" -> pure STexture2D
+      "STextureCube" -> pure STextureCube
+      "STexture1DArray" -> pure STexture1DArray
+      "STexture2DArray" -> pure STexture2DArray
+      "STexture2DRect" -> pure STexture2DRect
+      "FTexture1D" -> pure FTexture1D
+      "FTexture2D" -> pure FTexture2D
+      "FTexture3D" -> pure FTexture3D
+      "FTextureCube" -> pure FTextureCube
+      "FTexture1DArray" -> pure FTexture1DArray
+      "FTexture2DArray" -> pure FTexture2DArray
+      "FTexture2DMS" -> pure FTexture2DMS
+      "FTexture2DMSArray" -> pure FTexture2DMSArray
+      "FTextureBuffer" -> pure FTextureBuffer
+      "FTexture2DRect" -> pure FTexture2DRect
+      "ITexture1D" -> pure ITexture1D
+      "ITexture2D" -> pure ITexture2D
+      "ITexture3D" -> pure ITexture3D
+      "ITextureCube" -> pure ITextureCube
+      "ITexture1DArray" -> pure ITexture1DArray
+      "ITexture2DArray" -> pure ITexture2DArray
+      "ITexture2DMS" -> pure ITexture2DMS
+      "ITexture2DMSArray" -> pure ITexture2DMSArray
+      "ITextureBuffer" -> pure ITextureBuffer
+      "ITexture2DRect" -> pure ITexture2DRect
+      "UTexture1D" -> pure UTexture1D
+      "UTexture2D" -> pure UTexture2D
+      "UTexture3D" -> pure UTexture3D
+      "UTextureCube" -> pure UTextureCube
+      "UTexture1DArray" -> pure UTexture1DArray
+      "UTexture2DArray" -> pure UTexture2DArray
+      "UTexture2DMS" -> pure UTexture2DMS
+      "UTexture2DMSArray" -> pure UTexture2DMSArray
+      "UTextureBuffer" -> pure UTextureBuffer
+      "UTexture2DRect" -> pure UTexture2DRect
+  parseJSON _ = mzero
+
+instance ToJSON PointSpriteCoordOrigin where
+  toJSON v = case v of
+    LowerLeft -> object [ "tag" .= ("LowerLeft" :: Text)]
+    UpperLeft -> object [ "tag" .= ("UpperLeft" :: Text)]
+
+instance FromJSON PointSpriteCoordOrigin where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "LowerLeft" -> pure LowerLeft
+      "UpperLeft" -> pure UpperLeft
+  parseJSON _ = mzero
+
+instance ToJSON PointSize where
+  toJSON v = case v of
+    PointSize arg0 -> object [ "tag" .= ("PointSize" :: Text), "arg0" .= arg0]
+    ProgramPointSize -> object [ "tag" .= ("ProgramPointSize" :: Text)]
+
+instance FromJSON PointSize where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "PointSize" -> PointSize <$> obj .: "arg0"
+      "ProgramPointSize" -> pure ProgramPointSize
+  parseJSON _ = mzero
+
+instance ToJSON PolygonOffset where
+  toJSON v = case v of
+    NoOffset -> object [ "tag" .= ("NoOffset" :: Text)]
+    Offset arg0 arg1 -> object [ "tag" .= ("Offset" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON PolygonOffset where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "NoOffset" -> pure NoOffset
+      "Offset" -> Offset <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
+instance ToJSON FrontFace where
+  toJSON v = case v of
+    CCW -> object [ "tag" .= ("CCW" :: Text)]
+    CW -> object [ "tag" .= ("CW" :: Text)]
+
+instance FromJSON FrontFace where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "CCW" -> pure CCW
+      "CW" -> pure CW
+  parseJSON _ = mzero
+
+instance ToJSON PolygonMode where
+  toJSON v = case v of
+    PolygonPoint arg0 -> object [ "tag" .= ("PolygonPoint" :: Text), "arg0" .= arg0]
+    PolygonLine arg0 -> object [ "tag" .= ("PolygonLine" :: Text), "arg0" .= arg0]
+    PolygonFill -> object [ "tag" .= ("PolygonFill" :: Text)]
+
+instance FromJSON PolygonMode where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "PolygonPoint" -> PolygonPoint <$> obj .: "arg0"
+      "PolygonLine" -> PolygonLine <$> obj .: "arg0"
+      "PolygonFill" -> pure PolygonFill
+  parseJSON _ = mzero
+
+instance ToJSON ProvokingVertex where
+  toJSON v = case v of
+    FirstVertex -> object [ "tag" .= ("FirstVertex" :: Text)]
+    LastVertex -> object [ "tag" .= ("LastVertex" :: Text)]
+
+instance FromJSON ProvokingVertex where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "FirstVertex" -> pure FirstVertex
+      "LastVertex" -> pure LastVertex
+  parseJSON _ = mzero
+
+instance ToJSON CullMode where
+  toJSON v = case v of
+    CullNone -> object [ "tag" .= ("CullNone" :: Text)]
+    CullFront arg0 -> object [ "tag" .= ("CullFront" :: Text), "arg0" .= arg0]
+    CullBack arg0 -> object [ "tag" .= ("CullBack" :: Text), "arg0" .= arg0]
+
+instance FromJSON CullMode where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "CullNone" -> pure CullNone
+      "CullFront" -> CullFront <$> obj .: "arg0"
+      "CullBack" -> CullBack <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON ComparisonFunction where
+  toJSON v = case v of
+    Never -> object [ "tag" .= ("Never" :: Text)]
+    Less -> object [ "tag" .= ("Less" :: Text)]
+    Equal -> object [ "tag" .= ("Equal" :: Text)]
+    Lequal -> object [ "tag" .= ("Lequal" :: Text)]
+    Greater -> object [ "tag" .= ("Greater" :: Text)]
+    Notequal -> object [ "tag" .= ("Notequal" :: Text)]
+    Gequal -> object [ "tag" .= ("Gequal" :: Text)]
+    Always -> object [ "tag" .= ("Always" :: Text)]
+
+instance FromJSON ComparisonFunction where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Never" -> pure Never
+      "Less" -> pure Less
+      "Equal" -> pure Equal
+      "Lequal" -> pure Lequal
+      "Greater" -> pure Greater
+      "Notequal" -> pure Notequal
+      "Gequal" -> pure Gequal
+      "Always" -> pure Always
+  parseJSON _ = mzero
+
+instance ToJSON StencilOperation where
+  toJSON v = case v of
+    OpZero -> object [ "tag" .= ("OpZero" :: Text)]
+    OpKeep -> object [ "tag" .= ("OpKeep" :: Text)]
+    OpReplace -> object [ "tag" .= ("OpReplace" :: Text)]
+    OpIncr -> object [ "tag" .= ("OpIncr" :: Text)]
+    OpIncrWrap -> object [ "tag" .= ("OpIncrWrap" :: Text)]
+    OpDecr -> object [ "tag" .= ("OpDecr" :: Text)]
+    OpDecrWrap -> object [ "tag" .= ("OpDecrWrap" :: Text)]
+    OpInvert -> object [ "tag" .= ("OpInvert" :: Text)]
+
+instance FromJSON StencilOperation where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "OpZero" -> pure OpZero
+      "OpKeep" -> pure OpKeep
+      "OpReplace" -> pure OpReplace
+      "OpIncr" -> pure OpIncr
+      "OpIncrWrap" -> pure OpIncrWrap
+      "OpDecr" -> pure OpDecr
+      "OpDecrWrap" -> pure OpDecrWrap
+      "OpInvert" -> pure OpInvert
+  parseJSON _ = mzero
+
+instance ToJSON BlendEquation where
+  toJSON v = case v of
+    FuncAdd -> object [ "tag" .= ("FuncAdd" :: Text)]
+    FuncSubtract -> object [ "tag" .= ("FuncSubtract" :: Text)]
+    FuncReverseSubtract -> object [ "tag" .= ("FuncReverseSubtract" :: Text)]
+    Min -> object [ "tag" .= ("Min" :: Text)]
+    Max -> object [ "tag" .= ("Max" :: Text)]
+
+instance FromJSON BlendEquation where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "FuncAdd" -> pure FuncAdd
+      "FuncSubtract" -> pure FuncSubtract
+      "FuncReverseSubtract" -> pure FuncReverseSubtract
+      "Min" -> pure Min
+      "Max" -> pure Max
+  parseJSON _ = mzero
+
+instance ToJSON BlendingFactor where
+  toJSON v = case v of
+    Zero -> object [ "tag" .= ("Zero" :: Text)]
+    One -> object [ "tag" .= ("One" :: Text)]
+    SrcColor -> object [ "tag" .= ("SrcColor" :: Text)]
+    OneMinusSrcColor -> object [ "tag" .= ("OneMinusSrcColor" :: Text)]
+    DstColor -> object [ "tag" .= ("DstColor" :: Text)]
+    OneMinusDstColor -> object [ "tag" .= ("OneMinusDstColor" :: Text)]
+    SrcAlpha -> object [ "tag" .= ("SrcAlpha" :: Text)]
+    OneMinusSrcAlpha -> object [ "tag" .= ("OneMinusSrcAlpha" :: Text)]
+    DstAlpha -> object [ "tag" .= ("DstAlpha" :: Text)]
+    OneMinusDstAlpha -> object [ "tag" .= ("OneMinusDstAlpha" :: Text)]
+    ConstantColor -> object [ "tag" .= ("ConstantColor" :: Text)]
+    OneMinusConstantColor -> object [ "tag" .= ("OneMinusConstantColor" :: Text)]
+    ConstantAlpha -> object [ "tag" .= ("ConstantAlpha" :: Text)]
+    OneMinusConstantAlpha -> object [ "tag" .= ("OneMinusConstantAlpha" :: Text)]
+    SrcAlphaSaturate -> object [ "tag" .= ("SrcAlphaSaturate" :: Text)]
+
+instance FromJSON BlendingFactor where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Zero" -> pure Zero
+      "One" -> pure One
+      "SrcColor" -> pure SrcColor
+      "OneMinusSrcColor" -> pure OneMinusSrcColor
+      "DstColor" -> pure DstColor
+      "OneMinusDstColor" -> pure OneMinusDstColor
+      "SrcAlpha" -> pure SrcAlpha
+      "OneMinusSrcAlpha" -> pure OneMinusSrcAlpha
+      "DstAlpha" -> pure DstAlpha
+      "OneMinusDstAlpha" -> pure OneMinusDstAlpha
+      "ConstantColor" -> pure ConstantColor
+      "OneMinusConstantColor" -> pure OneMinusConstantColor
+      "ConstantAlpha" -> pure ConstantAlpha
+      "OneMinusConstantAlpha" -> pure OneMinusConstantAlpha
+      "SrcAlphaSaturate" -> pure SrcAlphaSaturate
+  parseJSON _ = mzero
+
+instance ToJSON LogicOperation where
+  toJSON v = case v of
+    Clear -> object [ "tag" .= ("Clear" :: Text)]
+    And -> object [ "tag" .= ("And" :: Text)]
+    AndReverse -> object [ "tag" .= ("AndReverse" :: Text)]
+    Copy -> object [ "tag" .= ("Copy" :: Text)]
+    AndInverted -> object [ "tag" .= ("AndInverted" :: Text)]
+    Noop -> object [ "tag" .= ("Noop" :: Text)]
+    Xor -> object [ "tag" .= ("Xor" :: Text)]
+    Or -> object [ "tag" .= ("Or" :: Text)]
+    Nor -> object [ "tag" .= ("Nor" :: Text)]
+    Equiv -> object [ "tag" .= ("Equiv" :: Text)]
+    Invert -> object [ "tag" .= ("Invert" :: Text)]
+    OrReverse -> object [ "tag" .= ("OrReverse" :: Text)]
+    CopyInverted -> object [ "tag" .= ("CopyInverted" :: Text)]
+    OrInverted -> object [ "tag" .= ("OrInverted" :: Text)]
+    Nand -> object [ "tag" .= ("Nand" :: Text)]
+    Set -> object [ "tag" .= ("Set" :: Text)]
+
+instance FromJSON LogicOperation where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Clear" -> pure Clear
+      "And" -> pure And
+      "AndReverse" -> pure AndReverse
+      "Copy" -> pure Copy
+      "AndInverted" -> pure AndInverted
+      "Noop" -> pure Noop
+      "Xor" -> pure Xor
+      "Or" -> pure Or
+      "Nor" -> pure Nor
+      "Equiv" -> pure Equiv
+      "Invert" -> pure Invert
+      "OrReverse" -> pure OrReverse
+      "CopyInverted" -> pure CopyInverted
+      "OrInverted" -> pure OrInverted
+      "Nand" -> pure Nand
+      "Set" -> pure Set
+  parseJSON _ = mzero
+
+instance ToJSON StencilOps where
+  toJSON v = case v of
+    StencilOps{..} -> object
+      [ "tag" .= ("StencilOps" :: Text)
+      , "frontStencilOp" .= frontStencilOp
+      , "backStencilOp" .= backStencilOp
+      ]
+
+instance FromJSON StencilOps where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "StencilOps" -> do
+        frontStencilOp <- obj .: "frontStencilOp"
+        backStencilOp <- obj .: "backStencilOp"
+        pure $ StencilOps
+          { frontStencilOp = frontStencilOp
+          , backStencilOp = backStencilOp
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON StencilTest where
+  toJSON v = case v of
+    StencilTest{..} -> object
+      [ "tag" .= ("StencilTest" :: Text)
+      , "stencilComparision" .= stencilComparision
+      , "stencilReference" .= stencilReference
+      , "stencilMask" .= stencilMask
+      ]
+
+instance FromJSON StencilTest where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "StencilTest" -> do
+        stencilComparision <- obj .: "stencilComparision"
+        stencilReference <- obj .: "stencilReference"
+        stencilMask <- obj .: "stencilMask"
+        pure $ StencilTest
+          { stencilComparision = stencilComparision
+          , stencilReference = stencilReference
+          , stencilMask = stencilMask
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON StencilTests where
+  toJSON v = case v of
+    StencilTests arg0 arg1 -> object [ "tag" .= ("StencilTests" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON StencilTests where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "StencilTests" -> StencilTests <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
+instance ToJSON FetchPrimitive where
+  toJSON v = case v of
+    Points -> object [ "tag" .= ("Points" :: Text)]
+    Lines -> object [ "tag" .= ("Lines" :: Text)]
+    Triangles -> object [ "tag" .= ("Triangles" :: Text)]
+    LinesAdjacency -> object [ "tag" .= ("LinesAdjacency" :: Text)]
+    TrianglesAdjacency -> object [ "tag" .= ("TrianglesAdjacency" :: Text)]
+
+instance FromJSON FetchPrimitive where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Points" -> pure Points
+      "Lines" -> pure Lines
+      "Triangles" -> pure Triangles
+      "LinesAdjacency" -> pure LinesAdjacency
+      "TrianglesAdjacency" -> pure TrianglesAdjacency
+  parseJSON _ = mzero
+
+instance ToJSON OutputPrimitive where
+  toJSON v = case v of
+    TrianglesOutput -> object [ "tag" .= ("TrianglesOutput" :: Text)]
+    LinesOutput -> object [ "tag" .= ("LinesOutput" :: Text)]
+    PointsOutput -> object [ "tag" .= ("PointsOutput" :: Text)]
+
+instance FromJSON OutputPrimitive where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "TrianglesOutput" -> pure TrianglesOutput
+      "LinesOutput" -> pure LinesOutput
+      "PointsOutput" -> pure PointsOutput
+  parseJSON _ = mzero
+
+instance ToJSON ColorArity where
+  toJSON v = case v of
+    Red -> object [ "tag" .= ("Red" :: Text)]
+    RG -> object [ "tag" .= ("RG" :: Text)]
+    RGB -> object [ "tag" .= ("RGB" :: Text)]
+    RGBA -> object [ "tag" .= ("RGBA" :: Text)]
+
+instance FromJSON ColorArity where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Red" -> pure Red
+      "RG" -> pure RG
+      "RGB" -> pure RGB
+      "RGBA" -> pure RGBA
+  parseJSON _ = mzero
+
+instance ToJSON Blending where
+  toJSON v = case v of
+    NoBlending -> object [ "tag" .= ("NoBlending" :: Text)]
+    BlendLogicOp arg0 -> object [ "tag" .= ("BlendLogicOp" :: Text), "arg0" .= arg0]
+    Blend{..} -> object
+      [ "tag" .= ("Blend" :: Text)
+      , "colorEqSrc" .= colorEqSrc
+      , "alphaEqSrc" .= alphaEqSrc
+      , "colorFSrc" .= colorFSrc
+      , "colorFDst" .= colorFDst
+      , "alphaFSrc" .= alphaFSrc
+      , "alphaFDst" .= alphaFDst
+      , "color" .= color
+      ]
+
+instance FromJSON Blending where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "NoBlending" -> pure NoBlending
+      "BlendLogicOp" -> BlendLogicOp <$> obj .: "arg0"
+      "Blend" -> do
+        colorEqSrc <- obj .: "colorEqSrc"
+        alphaEqSrc <- obj .: "alphaEqSrc"
+        colorFSrc <- obj .: "colorFSrc"
+        colorFDst <- obj .: "colorFDst"
+        alphaFSrc <- obj .: "alphaFSrc"
+        alphaFDst <- obj .: "alphaFDst"
+        color <- obj .: "color"
+        pure $ Blend
+          { colorEqSrc = colorEqSrc
+          , alphaEqSrc = alphaEqSrc
+          , colorFSrc = colorFSrc
+          , colorFDst = colorFDst
+          , alphaFSrc = alphaFSrc
+          , alphaFDst = alphaFDst
+          , color = color
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON RasterContext where
+  toJSON v = case v of
+    PointCtx arg0 arg1 arg2 -> object [ "tag" .= ("PointCtx" :: Text), "arg0" .= arg0, "arg1" .= arg1, "arg2" .= arg2]
+    LineCtx arg0 arg1 -> object [ "tag" .= ("LineCtx" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    TriangleCtx arg0 arg1 arg2 arg3 -> object [ "tag" .= ("TriangleCtx" :: Text), "arg0" .= arg0, "arg1" .= arg1, "arg2" .= arg2, "arg3" .= arg3]
+
+instance FromJSON RasterContext where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "PointCtx" -> PointCtx <$> obj .: "arg0" <*> obj .: "arg1" <*> obj .: "arg2"
+      "LineCtx" -> LineCtx <$> obj .: "arg0" <*> obj .: "arg1"
+      "TriangleCtx" -> TriangleCtx <$> obj .: "arg0" <*> obj .: "arg1" <*> obj .: "arg2" <*> obj .: "arg3"
+  parseJSON _ = mzero
+
+instance ToJSON FragmentOperation where
+  toJSON v = case v of
+    DepthOp arg0 arg1 -> object [ "tag" .= ("DepthOp" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    StencilOp arg0 arg1 arg2 -> object [ "tag" .= ("StencilOp" :: Text), "arg0" .= arg0, "arg1" .= arg1, "arg2" .= arg2]
+    ColorOp arg0 arg1 -> object [ "tag" .= ("ColorOp" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON FragmentOperation where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "DepthOp" -> DepthOp <$> obj .: "arg0" <*> obj .: "arg1"
+      "StencilOp" -> StencilOp <$> obj .: "arg0" <*> obj .: "arg1" <*> obj .: "arg2"
+      "ColorOp" -> ColorOp <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
+instance ToJSON AccumulationContext where
+  toJSON v = case v of
+    AccumulationContext{..} -> object
+      [ "tag" .= ("AccumulationContext" :: Text)
+      , "accViewportName" .= accViewportName
+      , "accOperations" .= accOperations
+      ]
+
+instance FromJSON AccumulationContext where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "AccumulationContext" -> do
+        accViewportName <- obj .: "accViewportName"
+        accOperations <- obj .: "accOperations"
+        pure $ AccumulationContext
+          { accViewportName = accViewportName
+          , accOperations = accOperations
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON TextureDataType where
+  toJSON v = case v of
+    FloatT arg0 -> object [ "tag" .= ("FloatT" :: Text), "arg0" .= arg0]
+    IntT arg0 -> object [ "tag" .= ("IntT" :: Text), "arg0" .= arg0]
+    WordT arg0 -> object [ "tag" .= ("WordT" :: Text), "arg0" .= arg0]
+    ShadowT -> object [ "tag" .= ("ShadowT" :: Text)]
+
+instance FromJSON TextureDataType where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "FloatT" -> FloatT <$> obj .: "arg0"
+      "IntT" -> IntT <$> obj .: "arg0"
+      "WordT" -> WordT <$> obj .: "arg0"
+      "ShadowT" -> pure ShadowT
+  parseJSON _ = mzero
+
+instance ToJSON TextureType where
+  toJSON v = case v of
+    Texture1D arg0 arg1 -> object [ "tag" .= ("Texture1D" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    Texture2D arg0 arg1 -> object [ "tag" .= ("Texture2D" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    Texture3D arg0 -> object [ "tag" .= ("Texture3D" :: Text), "arg0" .= arg0]
+    TextureCube arg0 -> object [ "tag" .= ("TextureCube" :: Text), "arg0" .= arg0]
+    TextureRect arg0 -> object [ "tag" .= ("TextureRect" :: Text), "arg0" .= arg0]
+    Texture2DMS arg0 arg1 arg2 arg3 -> object [ "tag" .= ("Texture2DMS" :: Text), "arg0" .= arg0, "arg1" .= arg1, "arg2" .= arg2, "arg3" .= arg3]
+    TextureBuffer arg0 -> object [ "tag" .= ("TextureBuffer" :: Text), "arg0" .= arg0]
+
+instance FromJSON TextureType where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Texture1D" -> Texture1D <$> obj .: "arg0" <*> obj .: "arg1"
+      "Texture2D" -> Texture2D <$> obj .: "arg0" <*> obj .: "arg1"
+      "Texture3D" -> Texture3D <$> obj .: "arg0"
+      "TextureCube" -> TextureCube <$> obj .: "arg0"
+      "TextureRect" -> TextureRect <$> obj .: "arg0"
+      "Texture2DMS" -> Texture2DMS <$> obj .: "arg0" <*> obj .: "arg1" <*> obj .: "arg2" <*> obj .: "arg3"
+      "TextureBuffer" -> TextureBuffer <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON MipMap where
+  toJSON v = case v of
+    Mip arg0 arg1 -> object [ "tag" .= ("Mip" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    NoMip -> object [ "tag" .= ("NoMip" :: Text)]
+    AutoMip arg0 arg1 -> object [ "tag" .= ("AutoMip" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON MipMap where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Mip" -> Mip <$> obj .: "arg0" <*> obj .: "arg1"
+      "NoMip" -> pure NoMip
+      "AutoMip" -> AutoMip <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
+instance ToJSON Filter where
+  toJSON v = case v of
+    Nearest -> object [ "tag" .= ("Nearest" :: Text)]
+    Linear -> object [ "tag" .= ("Linear" :: Text)]
+    NearestMipmapNearest -> object [ "tag" .= ("NearestMipmapNearest" :: Text)]
+    NearestMipmapLinear -> object [ "tag" .= ("NearestMipmapLinear" :: Text)]
+    LinearMipmapNearest -> object [ "tag" .= ("LinearMipmapNearest" :: Text)]
+    LinearMipmapLinear -> object [ "tag" .= ("LinearMipmapLinear" :: Text)]
+
+instance FromJSON Filter where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Nearest" -> pure Nearest
+      "Linear" -> pure Linear
+      "NearestMipmapNearest" -> pure NearestMipmapNearest
+      "NearestMipmapLinear" -> pure NearestMipmapLinear
+      "LinearMipmapNearest" -> pure LinearMipmapNearest
+      "LinearMipmapLinear" -> pure LinearMipmapLinear
+  parseJSON _ = mzero
+
+instance ToJSON EdgeMode where
+  toJSON v = case v of
+    Repeat -> object [ "tag" .= ("Repeat" :: Text)]
+    MirroredRepeat -> object [ "tag" .= ("MirroredRepeat" :: Text)]
+    ClampToEdge -> object [ "tag" .= ("ClampToEdge" :: Text)]
+    ClampToBorder -> object [ "tag" .= ("ClampToBorder" :: Text)]
+
+instance FromJSON EdgeMode where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Repeat" -> pure Repeat
+      "MirroredRepeat" -> pure MirroredRepeat
+      "ClampToEdge" -> pure ClampToEdge
+      "ClampToBorder" -> pure ClampToBorder
+  parseJSON _ = mzero
+
+instance ToJSON ImageSemantic where
+  toJSON v = case v of
+    Depth -> object [ "tag" .= ("Depth" :: Text)]
+    Stencil -> object [ "tag" .= ("Stencil" :: Text)]
+    Color -> object [ "tag" .= ("Color" :: Text)]
+
+instance FromJSON ImageSemantic where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Depth" -> pure Depth
+      "Stencil" -> pure Stencil
+      "Color" -> pure Color
+  parseJSON _ = mzero
+
+instance ToJSON ImageRef where
+  toJSON v = case v of
+    TextureImage arg0 arg1 arg2 -> object [ "tag" .= ("TextureImage" :: Text), "arg0" .= arg0, "arg1" .= arg1, "arg2" .= arg2]
+    Framebuffer arg0 -> object [ "tag" .= ("Framebuffer" :: Text), "arg0" .= arg0]
+
+instance FromJSON ImageRef where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "TextureImage" -> TextureImage <$> obj .: "arg0" <*> obj .: "arg1" <*> obj .: "arg2"
+      "Framebuffer" -> Framebuffer <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON ClearImage where
+  toJSON v = case v of
+    ClearImage{..} -> object
+      [ "tag" .= ("ClearImage" :: Text)
+      , "imageSemantic" .= imageSemantic
+      , "clearValue" .= clearValue
+      ]
+
+instance FromJSON ClearImage where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "ClearImage" -> do
+        imageSemantic <- obj .: "imageSemantic"
+        clearValue <- obj .: "clearValue"
+        pure $ ClearImage
+          { imageSemantic = imageSemantic
+          , clearValue = clearValue
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON Command where
+  toJSON v = case v of
+    SetRasterContext arg0 -> object [ "tag" .= ("SetRasterContext" :: Text), "arg0" .= arg0]
+    SetAccumulationContext arg0 -> object [ "tag" .= ("SetAccumulationContext" :: Text), "arg0" .= arg0]
+    SetRenderTarget arg0 -> object [ "tag" .= ("SetRenderTarget" :: Text), "arg0" .= arg0]
+    SetProgram arg0 -> object [ "tag" .= ("SetProgram" :: Text), "arg0" .= arg0]
+    SetSamplerUniform arg0 arg1 -> object [ "tag" .= ("SetSamplerUniform" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    SetTexture arg0 arg1 -> object [ "tag" .= ("SetTexture" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    SetSampler arg0 arg1 -> object [ "tag" .= ("SetSampler" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    RenderSlot arg0 -> object [ "tag" .= ("RenderSlot" :: Text), "arg0" .= arg0]
+    RenderStream arg0 -> object [ "tag" .= ("RenderStream" :: Text), "arg0" .= arg0]
+    ClearRenderTarget arg0 -> object [ "tag" .= ("ClearRenderTarget" :: Text), "arg0" .= arg0]
+    GenerateMipMap arg0 -> object [ "tag" .= ("GenerateMipMap" :: Text), "arg0" .= arg0]
+    SaveImage arg0 arg1 -> object [ "tag" .= ("SaveImage" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    LoadImage arg0 arg1 -> object [ "tag" .= ("LoadImage" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON Command where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "SetRasterContext" -> SetRasterContext <$> obj .: "arg0"
+      "SetAccumulationContext" -> SetAccumulationContext <$> obj .: "arg0"
+      "SetRenderTarget" -> SetRenderTarget <$> obj .: "arg0"
+      "SetProgram" -> SetProgram <$> obj .: "arg0"
+      "SetSamplerUniform" -> SetSamplerUniform <$> obj .: "arg0" <*> obj .: "arg1"
+      "SetTexture" -> SetTexture <$> obj .: "arg0" <*> obj .: "arg1"
+      "SetSampler" -> SetSampler <$> obj .: "arg0" <*> obj .: "arg1"
+      "RenderSlot" -> RenderSlot <$> obj .: "arg0"
+      "RenderStream" -> RenderStream <$> obj .: "arg0"
+      "ClearRenderTarget" -> ClearRenderTarget <$> obj .: "arg0"
+      "GenerateMipMap" -> GenerateMipMap <$> obj .: "arg0"
+      "SaveImage" -> SaveImage <$> obj .: "arg0" <*> obj .: "arg1"
+      "LoadImage" -> LoadImage <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
+instance ToJSON SamplerDescriptor where
+  toJSON v = case v of
+    SamplerDescriptor{..} -> object
+      [ "tag" .= ("SamplerDescriptor" :: Text)
+      , "samplerWrapS" .= samplerWrapS
+      , "samplerWrapT" .= samplerWrapT
+      , "samplerWrapR" .= samplerWrapR
+      , "samplerMinFilter" .= samplerMinFilter
+      , "samplerMagFilter" .= samplerMagFilter
+      , "samplerBorderColor" .= samplerBorderColor
+      , "samplerMinLod" .= samplerMinLod
+      , "samplerMaxLod" .= samplerMaxLod
+      , "samplerLodBias" .= samplerLodBias
+      , "samplerCompareFunc" .= samplerCompareFunc
+      ]
+
+instance FromJSON SamplerDescriptor where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "SamplerDescriptor" -> do
+        samplerWrapS <- obj .: "samplerWrapS"
+        samplerWrapT <- obj .: "samplerWrapT"
+        samplerWrapR <- obj .: "samplerWrapR"
+        samplerMinFilter <- obj .: "samplerMinFilter"
+        samplerMagFilter <- obj .: "samplerMagFilter"
+        samplerBorderColor <- obj .: "samplerBorderColor"
+        samplerMinLod <- obj .: "samplerMinLod"
+        samplerMaxLod <- obj .: "samplerMaxLod"
+        samplerLodBias <- obj .: "samplerLodBias"
+        samplerCompareFunc <- obj .: "samplerCompareFunc"
+        pure $ SamplerDescriptor
+          { samplerWrapS = samplerWrapS
+          , samplerWrapT = samplerWrapT
+          , samplerWrapR = samplerWrapR
+          , samplerMinFilter = samplerMinFilter
+          , samplerMagFilter = samplerMagFilter
+          , samplerBorderColor = samplerBorderColor
+          , samplerMinLod = samplerMinLod
+          , samplerMaxLod = samplerMaxLod
+          , samplerLodBias = samplerLodBias
+          , samplerCompareFunc = samplerCompareFunc
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON TextureDescriptor where
+  toJSON v = case v of
+    TextureDescriptor{..} -> object
+      [ "tag" .= ("TextureDescriptor" :: Text)
+      , "textureType" .= textureType
+      , "textureSize" .= textureSize
+      , "textureSemantic" .= textureSemantic
+      , "textureSampler" .= textureSampler
+      , "textureBaseLevel" .= textureBaseLevel
+      , "textureMaxLevel" .= textureMaxLevel
+      ]
+
+instance FromJSON TextureDescriptor where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "TextureDescriptor" -> do
+        textureType <- obj .: "textureType"
+        textureSize <- obj .: "textureSize"
+        textureSemantic <- obj .: "textureSemantic"
+        textureSampler <- obj .: "textureSampler"
+        textureBaseLevel <- obj .: "textureBaseLevel"
+        textureMaxLevel <- obj .: "textureMaxLevel"
+        pure $ TextureDescriptor
+          { textureType = textureType
+          , textureSize = textureSize
+          , textureSemantic = textureSemantic
+          , textureSampler = textureSampler
+          , textureBaseLevel = textureBaseLevel
+          , textureMaxLevel = textureMaxLevel
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON Parameter where
+  toJSON v = case v of
+    Parameter{..} -> object
+      [ "tag" .= ("Parameter" :: Text)
+      , "name" .= name
+      , "ty" .= ty
+      ]
+
+instance FromJSON Parameter where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Parameter" -> do
+        name <- obj .: "name"
+        ty <- obj .: "ty"
+        pure $ Parameter
+          { name = name
+          , ty = ty
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON Program where
+  toJSON v = case v of
+    Program{..} -> object
+      [ "tag" .= ("Program" :: Text)
+      , "programUniforms" .= programUniforms
+      , "programStreams" .= programStreams
+      , "programInTextures" .= programInTextures
+      , "programOutput" .= programOutput
+      , "vertexShader" .= vertexShader
+      , "geometryShader" .= geometryShader
+      , "fragmentShader" .= fragmentShader
+      ]
+
+instance FromJSON Program where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Program" -> do
+        programUniforms <- obj .: "programUniforms"
+        programStreams <- obj .: "programStreams"
+        programInTextures <- obj .: "programInTextures"
+        programOutput <- obj .: "programOutput"
+        vertexShader <- obj .: "vertexShader"
+        geometryShader <- obj .: "geometryShader"
+        fragmentShader <- obj .: "fragmentShader"
+        pure $ Program
+          { programUniforms = programUniforms
+          , programStreams = programStreams
+          , programInTextures = programInTextures
+          , programOutput = programOutput
+          , vertexShader = vertexShader
+          , geometryShader = geometryShader
+          , fragmentShader = fragmentShader
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON Slot where
+  toJSON v = case v of
+    Slot{..} -> object
+      [ "tag" .= ("Slot" :: Text)
+      , "slotName" .= slotName
+      , "slotStreams" .= slotStreams
+      , "slotUniforms" .= slotUniforms
+      , "slotPrimitive" .= slotPrimitive
+      , "slotPrograms" .= slotPrograms
+      ]
+
+instance FromJSON Slot where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Slot" -> do
+        slotName <- obj .: "slotName"
+        slotStreams <- obj .: "slotStreams"
+        slotUniforms <- obj .: "slotUniforms"
+        slotPrimitive <- obj .: "slotPrimitive"
+        slotPrograms <- obj .: "slotPrograms"
+        pure $ Slot
+          { slotName = slotName
+          , slotStreams = slotStreams
+          , slotUniforms = slotUniforms
+          , slotPrimitive = slotPrimitive
+          , slotPrograms = slotPrograms
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON StreamData where
+  toJSON v = case v of
+    StreamData{..} -> object
+      [ "tag" .= ("StreamData" :: Text)
+      , "streamData" .= streamData
+      , "streamType" .= streamType
+      , "streamPrimitive" .= streamPrimitive
+      , "streamPrograms" .= streamPrograms
+      ]
+
+instance FromJSON StreamData where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "StreamData" -> do
+        streamData <- obj .: "streamData"
+        streamType <- obj .: "streamType"
+        streamPrimitive <- obj .: "streamPrimitive"
+        streamPrograms <- obj .: "streamPrograms"
+        pure $ StreamData
+          { streamData = streamData
+          , streamType = streamType
+          , streamPrimitive = streamPrimitive
+          , streamPrograms = streamPrograms
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON TargetItem where
+  toJSON v = case v of
+    TargetItem{..} -> object
+      [ "tag" .= ("TargetItem" :: Text)
+      , "targetSemantic" .= targetSemantic
+      , "targetRef" .= targetRef
+      ]
+
+instance FromJSON TargetItem where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "TargetItem" -> do
+        targetSemantic <- obj .: "targetSemantic"
+        targetRef <- obj .: "targetRef"
+        pure $ TargetItem
+          { targetSemantic = targetSemantic
+          , targetRef = targetRef
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON RenderTarget where
+  toJSON v = case v of
+    RenderTarget{..} -> object
+      [ "tag" .= ("RenderTarget" :: Text)
+      , "renderTargets" .= renderTargets
+      ]
+
+instance FromJSON RenderTarget where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "RenderTarget" -> do
+        renderTargets <- obj .: "renderTargets"
+        pure $ RenderTarget
+          { renderTargets = renderTargets
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON Backend where
+  toJSON v = case v of
+    WebGL1 -> object [ "tag" .= ("WebGL1" :: Text)]
+    OpenGL33 -> object [ "tag" .= ("OpenGL33" :: Text)]
+
+instance FromJSON Backend where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "WebGL1" -> pure WebGL1
+      "OpenGL33" -> pure OpenGL33
+  parseJSON _ = mzero
+
+instance ToJSON Pipeline where
+  toJSON v = case v of
+    Pipeline{..} -> object
+      [ "tag" .= ("Pipeline" :: Text)
+      , "backend" .= backend
+      , "textures" .= textures
+      , "samplers" .= samplers
+      , "targets" .= targets
+      , "programs" .= programs
+      , "slots" .= slots
+      , "streams" .= streams
+      , "commands" .= commands
+      ]
+
+instance FromJSON Pipeline where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Pipeline" -> do
+        backend <- obj .: "backend"
+        textures <- obj .: "textures"
+        samplers <- obj .: "samplers"
+        targets <- obj .: "targets"
+        programs <- obj .: "programs"
+        slots <- obj .: "slots"
+        streams <- obj .: "streams"
+        commands <- obj .: "commands"
+        pure $ Pipeline
+          { backend = backend
+          , textures = textures
+          , samplers = samplers
+          , targets = targets
+          , programs = programs
+          , slots = slots
+          , streams = streams
+          , commands = commands
+          } 
+  parseJSON _ = mzero
+
diff --git a/ddl/out/IR.purs b/ddl/out/IR.purs
new file mode 100644
index 0000000..801e3f9
--- /dev/null
+++ b/ddl/out/IR.purs
@@ -0,0 +1,1590 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.420877000000Z
+
+module IR where
+import Prelude
+import Data.Generic
+import Data.Maybe (Maybe(..))
+import Data.StrMap (StrMap(..))
+import Data.Map (Map(..))
+import Data.List (List(..))
+import Linear
+
+import Data.Argonaut.Combinators ((~>), (:=), (.?))
+import Data.Argonaut.Core (jsonEmptyObject)
+import Data.Argonaut.Printer (printJson)
+import Data.Argonaut.Encode (EncodeJson, encodeJson)
+import Data.Argonaut.Decode (DecodeJson, decodeJson)
+
+
+type StreamName = Int
+
+type ProgramName = Int
+
+type TextureName = Int
+
+type SamplerName = Int
+
+type UniformName = String
+
+type SlotName = Int
+
+type FrameBufferComponent = Int
+
+type TextureUnit = Int
+
+type RenderTargetName = Int
+
+type TextureUnitMapping = StrMap TextureUnit
+
+data ArrayValue
+  = VBoolArray (Array Bool)
+  | VIntArray (Array Int32)
+  | VWordArray (Array Word32)
+  | VFloatArray (Array Float)
+
+data Value
+  = VBool Bool
+  | VV2B V2B
+  | VV3B V3B
+  | VV4B V4B
+  | VWord Word32
+  | VV2U V2U
+  | VV3U V3U
+  | VV4U V4U
+  | VInt Int32
+  | VV2I V2I
+  | VV3I V3I
+  | VV4I V4I
+  | VFloat Float
+  | VV2F V2F
+  | VV3F V3F
+  | VV4F V4F
+  | VM22F M22F
+  | VM23F M23F
+  | VM24F M24F
+  | VM32F M32F
+  | VM33F M33F
+  | VM34F M34F
+  | VM42F M42F
+  | VM43F M43F
+  | VM44F M44F
+
+data InputType
+  = Bool
+  | V2B
+  | V3B
+  | V4B
+  | Word
+  | V2U
+  | V3U
+  | V4U
+  | Int
+  | V2I
+  | V3I
+  | V4I
+  | Float
+  | V2F
+  | V3F
+  | V4F
+  | M22F
+  | M23F
+  | M24F
+  | M32F
+  | M33F
+  | M34F
+  | M42F
+  | M43F
+  | M44F
+  | STexture1D
+  | STexture2D
+  | STextureCube
+  | STexture1DArray
+  | STexture2DArray
+  | STexture2DRect
+  | FTexture1D
+  | FTexture2D
+  | FTexture3D
+  | FTextureCube
+  | FTexture1DArray
+  | FTexture2DArray
+  | FTexture2DMS
+  | FTexture2DMSArray
+  | FTextureBuffer
+  | FTexture2DRect
+  | ITexture1D
+  | ITexture2D
+  | ITexture3D
+  | ITextureCube
+  | ITexture1DArray
+  | ITexture2DArray
+  | ITexture2DMS
+  | ITexture2DMSArray
+  | ITextureBuffer
+  | ITexture2DRect
+  | UTexture1D
+  | UTexture2D
+  | UTexture3D
+  | UTextureCube
+  | UTexture1DArray
+  | UTexture2DArray
+  | UTexture2DMS
+  | UTexture2DMSArray
+  | UTextureBuffer
+  | UTexture2DRect
+
+data PointSpriteCoordOrigin
+  = LowerLeft
+  | UpperLeft
+
+data PointSize
+  = PointSize Float
+  | ProgramPointSize
+
+data PolygonOffset
+  = NoOffset
+  | Offset Float Float
+
+data FrontFace
+  = CCW
+  | CW
+
+data PolygonMode
+  = PolygonPoint PointSize
+  | PolygonLine Float
+  | PolygonFill
+
+data ProvokingVertex
+  = FirstVertex
+  | LastVertex
+
+data CullMode
+  = CullNone
+  | CullFront FrontFace
+  | CullBack FrontFace
+
+data ComparisonFunction
+  = Never
+  | Less
+  | Equal
+  | Lequal
+  | Greater
+  | Notequal
+  | Gequal
+  | Always
+
+type DepthFunction = ComparisonFunction
+
+data StencilOperation
+  = OpZero
+  | OpKeep
+  | OpReplace
+  | OpIncr
+  | OpIncrWrap
+  | OpDecr
+  | OpDecrWrap
+  | OpInvert
+
+data BlendEquation
+  = FuncAdd
+  | FuncSubtract
+  | FuncReverseSubtract
+  | Min
+  | Max
+
+data BlendingFactor
+  = Zero
+  | One
+  | SrcColor
+  | OneMinusSrcColor
+  | DstColor
+  | OneMinusDstColor
+  | SrcAlpha
+  | OneMinusSrcAlpha
+  | DstAlpha
+  | OneMinusDstAlpha
+  | ConstantColor
+  | OneMinusConstantColor
+  | ConstantAlpha
+  | OneMinusConstantAlpha
+  | SrcAlphaSaturate
+
+data LogicOperation
+  = Clear
+  | And
+  | AndReverse
+  | Copy
+  | AndInverted
+  | Noop
+  | Xor
+  | Or
+  | Nor
+  | Equiv
+  | Invert
+  | OrReverse
+  | CopyInverted
+  | OrInverted
+  | Nand
+  | Set
+
+data StencilOps
+  = StencilOps
+  { frontStencilOp :: StencilOperation
+  , backStencilOp :: StencilOperation
+  }
+
+
+data StencilTest
+  = StencilTest
+  { stencilComparision :: ComparisonFunction
+  , stencilReference :: Int32
+  , stencilMask :: Word32
+  }
+
+
+data StencilTests
+  = StencilTests StencilTest StencilTest
+
+data FetchPrimitive
+  = Points
+  | Lines
+  | Triangles
+  | LinesAdjacency
+  | TrianglesAdjacency
+
+data OutputPrimitive
+  = TrianglesOutput
+  | LinesOutput
+  | PointsOutput
+
+data ColorArity
+  = Red
+  | RG
+  | RGB
+  | RGBA
+
+data Blending
+  = NoBlending
+  | BlendLogicOp LogicOperation
+  | Blend
+  { colorEqSrc :: BlendEquation
+  , alphaEqSrc :: BlendEquation
+  , colorFSrc :: BlendingFactor
+  , colorFDst :: BlendingFactor
+  , alphaFSrc :: BlendingFactor
+  , alphaFDst :: BlendingFactor
+  , color :: V4F
+  }
+
+
+data RasterContext
+  = PointCtx PointSize Float PointSpriteCoordOrigin
+  | LineCtx Float ProvokingVertex
+  | TriangleCtx CullMode PolygonMode PolygonOffset ProvokingVertex
+
+data FragmentOperation
+  = DepthOp DepthFunction Bool
+  | StencilOp StencilTests StencilOps StencilOps
+  | ColorOp Blending Value
+
+data AccumulationContext
+  = AccumulationContext
+  { accViewportName :: Maybe String
+  , accOperations :: List FragmentOperation
+  }
+
+
+data TextureDataType
+  = FloatT ColorArity
+  | IntT ColorArity
+  | WordT ColorArity
+  | ShadowT
+
+data TextureType
+  = Texture1D TextureDataType Int
+  | Texture2D TextureDataType Int
+  | Texture3D TextureDataType
+  | TextureCube TextureDataType
+  | TextureRect TextureDataType
+  | Texture2DMS TextureDataType Int Int Bool
+  | TextureBuffer TextureDataType
+
+data MipMap
+  = Mip Int Int
+  | NoMip
+  | AutoMip Int Int
+
+data Filter
+  = Nearest
+  | Linear
+  | NearestMipmapNearest
+  | NearestMipmapLinear
+  | LinearMipmapNearest
+  | LinearMipmapLinear
+
+data EdgeMode
+  = Repeat
+  | MirroredRepeat
+  | ClampToEdge
+  | ClampToBorder
+
+data ImageSemantic
+  = Depth
+  | Stencil
+  | Color
+
+data ImageRef
+  = TextureImage TextureName Int (Maybe Int)
+  | Framebuffer ImageSemantic
+
+data ClearImage
+  = ClearImage
+  { imageSemantic :: ImageSemantic
+  , clearValue :: Value
+  }
+
+
+data Command
+  = SetRasterContext RasterContext
+  | SetAccumulationContext AccumulationContext
+  | SetRenderTarget RenderTargetName
+  | SetProgram ProgramName
+  | SetSamplerUniform UniformName TextureUnit
+  | SetTexture TextureUnit TextureName
+  | SetSampler TextureUnit (Maybe SamplerName)
+  | RenderSlot SlotName
+  | RenderStream StreamName
+  | ClearRenderTarget (Array ClearImage)
+  | GenerateMipMap TextureUnit
+  | SaveImage FrameBufferComponent ImageRef
+  | LoadImage ImageRef FrameBufferComponent
+
+data SamplerDescriptor
+  = SamplerDescriptor
+  { samplerWrapS :: EdgeMode
+  , samplerWrapT :: Maybe EdgeMode
+  , samplerWrapR :: Maybe EdgeMode
+  , samplerMinFilter :: Filter
+  , samplerMagFilter :: Filter
+  , samplerBorderColor :: Value
+  , samplerMinLod :: Maybe Float
+  , samplerMaxLod :: Maybe Float
+  , samplerLodBias :: Float
+  , samplerCompareFunc :: Maybe ComparisonFunction
+  }
+
+
+data TextureDescriptor
+  = TextureDescriptor
+  { textureType :: TextureType
+  , textureSize :: Value
+  , textureSemantic :: ImageSemantic
+  , textureSampler :: SamplerDescriptor
+  , textureBaseLevel :: Int
+  , textureMaxLevel :: Int
+  }
+
+
+data Parameter
+  = Parameter
+  { name :: String
+  , ty :: InputType
+  }
+
+
+data Program
+  = Program
+  { programUniforms :: StrMap InputType
+  , programStreams :: StrMap Parameter
+  , programInTextures :: StrMap InputType
+  , programOutput :: Array Parameter
+  , vertexShader :: String
+  , geometryShader :: Maybe String
+  , fragmentShader :: String
+  }
+
+
+data Slot
+  = Slot
+  { slotName :: String
+  , slotStreams :: StrMap InputType
+  , slotUniforms :: StrMap InputType
+  , slotPrimitive :: FetchPrimitive
+  , slotPrograms :: Array ProgramName
+  }
+
+
+data StreamData
+  = StreamData
+  { streamData :: StrMap ArrayValue
+  , streamType :: StrMap InputType
+  , streamPrimitive :: FetchPrimitive
+  , streamPrograms :: Array ProgramName
+  }
+
+
+data TargetItem
+  = TargetItem
+  { targetSemantic :: ImageSemantic
+  , targetRef :: Maybe ImageRef
+  }
+
+
+data RenderTarget
+  = RenderTarget
+  { renderTargets :: Array TargetItem
+  }
+
+
+data Backend
+  = WebGL1
+  | OpenGL33
+
+data Pipeline
+  = Pipeline
+  { backend :: Backend
+  , textures :: Array TextureDescriptor
+  , samplers :: Array SamplerDescriptor
+  , targets :: Array RenderTarget
+  , programs :: Array Program
+  , slots :: Array Slot
+  , streams :: Array StreamData
+  , commands :: Array Command
+  }
+
+
+
+derive instance genericInputType :: Generic InputType
+instance showInputType :: Show InputType where show = gShow
+instance eqInputType   :: Eq InputType   where eq = gEq
+
+derive instance genericFetchPrimitive :: Generic FetchPrimitive
+instance showFetchPrimitive :: Show FetchPrimitive where show = gShow
+instance eqFetchPrimitive   :: Eq FetchPrimitive   where eq = gEq
+
+derive instance genericColorArity :: Generic ColorArity
+instance showColorArity :: Show ColorArity where show = gShow
+instance eqColorArity   :: Eq ColorArity   where eq = gEq
+
+derive instance genericTextureDataType :: Generic TextureDataType
+instance showTextureDataType :: Show TextureDataType where show = gShow
+instance eqTextureDataType   :: Eq TextureDataType   where eq = gEq
+
+derive instance genericImageSemantic :: Generic ImageSemantic
+instance showImageSemantic :: Show ImageSemantic where show = gShow
+instance eqImageSemantic   :: Eq ImageSemantic   where eq = gEq
+
+derive instance genericPipeline :: Generic Pipeline
+instance showPipeline :: Show Pipeline where show = gShow
+instance eqPipeline   :: Eq Pipeline   where eq = gEq
+
+
+instance encodeJsonArrayValue :: EncodeJson ArrayValue where
+  encodeJson v = case v of
+    VBoolArray arg0 -> "tag" := "VBoolArray" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VIntArray arg0 -> "tag" := "VIntArray" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VWordArray arg0 -> "tag" := "VWordArray" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VFloatArray arg0 -> "tag" := "VFloatArray" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonArrayValue :: DecodeJson ArrayValue where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "VBoolArray" -> VBoolArray <$> obj .? "arg0"
+      "VIntArray" -> VIntArray <$> obj .? "arg0"
+      "VWordArray" -> VWordArray <$> obj .? "arg0"
+      "VFloatArray" -> VFloatArray <$> obj .? "arg0"
+
+instance encodeJsonValue :: EncodeJson Value where
+  encodeJson v = case v of
+    VBool arg0 -> "tag" := "VBool" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV2B arg0 -> "tag" := "VV2B" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV3B arg0 -> "tag" := "VV3B" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV4B arg0 -> "tag" := "VV4B" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VWord arg0 -> "tag" := "VWord" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV2U arg0 -> "tag" := "VV2U" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV3U arg0 -> "tag" := "VV3U" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV4U arg0 -> "tag" := "VV4U" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VInt arg0 -> "tag" := "VInt" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV2I arg0 -> "tag" := "VV2I" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV3I arg0 -> "tag" := "VV3I" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV4I arg0 -> "tag" := "VV4I" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VFloat arg0 -> "tag" := "VFloat" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV2F arg0 -> "tag" := "VV2F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV3F arg0 -> "tag" := "VV3F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VV4F arg0 -> "tag" := "VV4F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM22F arg0 -> "tag" := "VM22F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM23F arg0 -> "tag" := "VM23F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM24F arg0 -> "tag" := "VM24F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM32F arg0 -> "tag" := "VM32F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM33F arg0 -> "tag" := "VM33F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM34F arg0 -> "tag" := "VM34F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM42F arg0 -> "tag" := "VM42F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM43F arg0 -> "tag" := "VM43F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    VM44F arg0 -> "tag" := "VM44F" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonValue :: DecodeJson Value where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "VBool" -> VBool <$> obj .? "arg0"
+      "VV2B" -> VV2B <$> obj .? "arg0"
+      "VV3B" -> VV3B <$> obj .? "arg0"
+      "VV4B" -> VV4B <$> obj .? "arg0"
+      "VWord" -> VWord <$> obj .? "arg0"
+      "VV2U" -> VV2U <$> obj .? "arg0"
+      "VV3U" -> VV3U <$> obj .? "arg0"
+      "VV4U" -> VV4U <$> obj .? "arg0"
+      "VInt" -> VInt <$> obj .? "arg0"
+      "VV2I" -> VV2I <$> obj .? "arg0"
+      "VV3I" -> VV3I <$> obj .? "arg0"
+      "VV4I" -> VV4I <$> obj .? "arg0"
+      "VFloat" -> VFloat <$> obj .? "arg0"
+      "VV2F" -> VV2F <$> obj .? "arg0"
+      "VV3F" -> VV3F <$> obj .? "arg0"
+      "VV4F" -> VV4F <$> obj .? "arg0"
+      "VM22F" -> VM22F <$> obj .? "arg0"
+      "VM23F" -> VM23F <$> obj .? "arg0"
+      "VM24F" -> VM24F <$> obj .? "arg0"
+      "VM32F" -> VM32F <$> obj .? "arg0"
+      "VM33F" -> VM33F <$> obj .? "arg0"
+      "VM34F" -> VM34F <$> obj .? "arg0"
+      "VM42F" -> VM42F <$> obj .? "arg0"
+      "VM43F" -> VM43F <$> obj .? "arg0"
+      "VM44F" -> VM44F <$> obj .? "arg0"
+
+instance encodeJsonInputType :: EncodeJson InputType where
+  encodeJson v = case v of
+    Bool -> "tag" := "Bool" ~> jsonEmptyObject
+    V2B -> "tag" := "V2B" ~> jsonEmptyObject
+    V3B -> "tag" := "V3B" ~> jsonEmptyObject
+    V4B -> "tag" := "V4B" ~> jsonEmptyObject
+    Word -> "tag" := "Word" ~> jsonEmptyObject
+    V2U -> "tag" := "V2U" ~> jsonEmptyObject
+    V3U -> "tag" := "V3U" ~> jsonEmptyObject
+    V4U -> "tag" := "V4U" ~> jsonEmptyObject
+    Int -> "tag" := "Int" ~> jsonEmptyObject
+    V2I -> "tag" := "V2I" ~> jsonEmptyObject
+    V3I -> "tag" := "V3I" ~> jsonEmptyObject
+    V4I -> "tag" := "V4I" ~> jsonEmptyObject
+    Float -> "tag" := "Float" ~> jsonEmptyObject
+    V2F -> "tag" := "V2F" ~> jsonEmptyObject
+    V3F -> "tag" := "V3F" ~> jsonEmptyObject
+    V4F -> "tag" := "V4F" ~> jsonEmptyObject
+    M22F -> "tag" := "M22F" ~> jsonEmptyObject
+    M23F -> "tag" := "M23F" ~> jsonEmptyObject
+    M24F -> "tag" := "M24F" ~> jsonEmptyObject
+    M32F -> "tag" := "M32F" ~> jsonEmptyObject
+    M33F -> "tag" := "M33F" ~> jsonEmptyObject
+    M34F -> "tag" := "M34F" ~> jsonEmptyObject
+    M42F -> "tag" := "M42F" ~> jsonEmptyObject
+    M43F -> "tag" := "M43F" ~> jsonEmptyObject
+    M44F -> "tag" := "M44F" ~> jsonEmptyObject
+    STexture1D -> "tag" := "STexture1D" ~> jsonEmptyObject
+    STexture2D -> "tag" := "STexture2D" ~> jsonEmptyObject
+    STextureCube -> "tag" := "STextureCube" ~> jsonEmptyObject
+    STexture1DArray -> "tag" := "STexture1DArray" ~> jsonEmptyObject
+    STexture2DArray -> "tag" := "STexture2DArray" ~> jsonEmptyObject
+    STexture2DRect -> "tag" := "STexture2DRect" ~> jsonEmptyObject
+    FTexture1D -> "tag" := "FTexture1D" ~> jsonEmptyObject
+    FTexture2D -> "tag" := "FTexture2D" ~> jsonEmptyObject
+    FTexture3D -> "tag" := "FTexture3D" ~> jsonEmptyObject
+    FTextureCube -> "tag" := "FTextureCube" ~> jsonEmptyObject
+    FTexture1DArray -> "tag" := "FTexture1DArray" ~> jsonEmptyObject
+    FTexture2DArray -> "tag" := "FTexture2DArray" ~> jsonEmptyObject
+    FTexture2DMS -> "tag" := "FTexture2DMS" ~> jsonEmptyObject
+    FTexture2DMSArray -> "tag" := "FTexture2DMSArray" ~> jsonEmptyObject
+    FTextureBuffer -> "tag" := "FTextureBuffer" ~> jsonEmptyObject
+    FTexture2DRect -> "tag" := "FTexture2DRect" ~> jsonEmptyObject
+    ITexture1D -> "tag" := "ITexture1D" ~> jsonEmptyObject
+    ITexture2D -> "tag" := "ITexture2D" ~> jsonEmptyObject
+    ITexture3D -> "tag" := "ITexture3D" ~> jsonEmptyObject
+    ITextureCube -> "tag" := "ITextureCube" ~> jsonEmptyObject
+    ITexture1DArray -> "tag" := "ITexture1DArray" ~> jsonEmptyObject
+    ITexture2DArray -> "tag" := "ITexture2DArray" ~> jsonEmptyObject
+    ITexture2DMS -> "tag" := "ITexture2DMS" ~> jsonEmptyObject
+    ITexture2DMSArray -> "tag" := "ITexture2DMSArray" ~> jsonEmptyObject
+    ITextureBuffer -> "tag" := "ITextureBuffer" ~> jsonEmptyObject
+    ITexture2DRect -> "tag" := "ITexture2DRect" ~> jsonEmptyObject
+    UTexture1D -> "tag" := "UTexture1D" ~> jsonEmptyObject
+    UTexture2D -> "tag" := "UTexture2D" ~> jsonEmptyObject
+    UTexture3D -> "tag" := "UTexture3D" ~> jsonEmptyObject
+    UTextureCube -> "tag" := "UTextureCube" ~> jsonEmptyObject
+    UTexture1DArray -> "tag" := "UTexture1DArray" ~> jsonEmptyObject
+    UTexture2DArray -> "tag" := "UTexture2DArray" ~> jsonEmptyObject
+    UTexture2DMS -> "tag" := "UTexture2DMS" ~> jsonEmptyObject
+    UTexture2DMSArray -> "tag" := "UTexture2DMSArray" ~> jsonEmptyObject
+    UTextureBuffer -> "tag" := "UTextureBuffer" ~> jsonEmptyObject
+    UTexture2DRect -> "tag" := "UTexture2DRect" ~> jsonEmptyObject
+
+instance decodeJsonInputType :: DecodeJson InputType where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Bool" -> pure Bool
+      "V2B" -> pure V2B
+      "V3B" -> pure V3B
+      "V4B" -> pure V4B
+      "Word" -> pure Word
+      "V2U" -> pure V2U
+      "V3U" -> pure V3U
+      "V4U" -> pure V4U
+      "Int" -> pure Int
+      "V2I" -> pure V2I
+      "V3I" -> pure V3I
+      "V4I" -> pure V4I
+      "Float" -> pure Float
+      "V2F" -> pure V2F
+      "V3F" -> pure V3F
+      "V4F" -> pure V4F
+      "M22F" -> pure M22F
+      "M23F" -> pure M23F
+      "M24F" -> pure M24F
+      "M32F" -> pure M32F
+      "M33F" -> pure M33F
+      "M34F" -> pure M34F
+      "M42F" -> pure M42F
+      "M43F" -> pure M43F
+      "M44F" -> pure M44F
+      "STexture1D" -> pure STexture1D
+      "STexture2D" -> pure STexture2D
+      "STextureCube" -> pure STextureCube
+      "STexture1DArray" -> pure STexture1DArray
+      "STexture2DArray" -> pure STexture2DArray
+      "STexture2DRect" -> pure STexture2DRect
+      "FTexture1D" -> pure FTexture1D
+      "FTexture2D" -> pure FTexture2D
+      "FTexture3D" -> pure FTexture3D
+      "FTextureCube" -> pure FTextureCube
+      "FTexture1DArray" -> pure FTexture1DArray
+      "FTexture2DArray" -> pure FTexture2DArray
+      "FTexture2DMS" -> pure FTexture2DMS
+      "FTexture2DMSArray" -> pure FTexture2DMSArray
+      "FTextureBuffer" -> pure FTextureBuffer
+      "FTexture2DRect" -> pure FTexture2DRect
+      "ITexture1D" -> pure ITexture1D
+      "ITexture2D" -> pure ITexture2D
+      "ITexture3D" -> pure ITexture3D
+      "ITextureCube" -> pure ITextureCube
+      "ITexture1DArray" -> pure ITexture1DArray
+      "ITexture2DArray" -> pure ITexture2DArray
+      "ITexture2DMS" -> pure ITexture2DMS
+      "ITexture2DMSArray" -> pure ITexture2DMSArray
+      "ITextureBuffer" -> pure ITextureBuffer
+      "ITexture2DRect" -> pure ITexture2DRect
+      "UTexture1D" -> pure UTexture1D
+      "UTexture2D" -> pure UTexture2D
+      "UTexture3D" -> pure UTexture3D
+      "UTextureCube" -> pure UTextureCube
+      "UTexture1DArray" -> pure UTexture1DArray
+      "UTexture2DArray" -> pure UTexture2DArray
+      "UTexture2DMS" -> pure UTexture2DMS
+      "UTexture2DMSArray" -> pure UTexture2DMSArray
+      "UTextureBuffer" -> pure UTextureBuffer
+      "UTexture2DRect" -> pure UTexture2DRect
+
+instance encodeJsonPointSpriteCoordOrigin :: EncodeJson PointSpriteCoordOrigin where
+  encodeJson v = case v of
+    LowerLeft -> "tag" := "LowerLeft" ~> jsonEmptyObject
+    UpperLeft -> "tag" := "UpperLeft" ~> jsonEmptyObject
+
+instance decodeJsonPointSpriteCoordOrigin :: DecodeJson PointSpriteCoordOrigin where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "LowerLeft" -> pure LowerLeft
+      "UpperLeft" -> pure UpperLeft
+
+instance encodeJsonPointSize :: EncodeJson PointSize where
+  encodeJson v = case v of
+    PointSize arg0 -> "tag" := "PointSize" ~> "arg0" := arg0 ~> jsonEmptyObject
+    ProgramPointSize -> "tag" := "ProgramPointSize" ~> jsonEmptyObject
+
+instance decodeJsonPointSize :: DecodeJson PointSize where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "PointSize" -> PointSize <$> obj .? "arg0"
+      "ProgramPointSize" -> pure ProgramPointSize
+
+instance encodeJsonPolygonOffset :: EncodeJson PolygonOffset where
+  encodeJson v = case v of
+    NoOffset -> "tag" := "NoOffset" ~> jsonEmptyObject
+    Offset arg0 arg1 -> "tag" := "Offset" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonPolygonOffset :: DecodeJson PolygonOffset where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "NoOffset" -> pure NoOffset
+      "Offset" -> Offset <$> obj .? "arg0" <*> obj .? "arg1"
+
+instance encodeJsonFrontFace :: EncodeJson FrontFace where
+  encodeJson v = case v of
+    CCW -> "tag" := "CCW" ~> jsonEmptyObject
+    CW -> "tag" := "CW" ~> jsonEmptyObject
+
+instance decodeJsonFrontFace :: DecodeJson FrontFace where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "CCW" -> pure CCW
+      "CW" -> pure CW
+
+instance encodeJsonPolygonMode :: EncodeJson PolygonMode where
+  encodeJson v = case v of
+    PolygonPoint arg0 -> "tag" := "PolygonPoint" ~> "arg0" := arg0 ~> jsonEmptyObject
+    PolygonLine arg0 -> "tag" := "PolygonLine" ~> "arg0" := arg0 ~> jsonEmptyObject
+    PolygonFill -> "tag" := "PolygonFill" ~> jsonEmptyObject
+
+instance decodeJsonPolygonMode :: DecodeJson PolygonMode where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "PolygonPoint" -> PolygonPoint <$> obj .? "arg0"
+      "PolygonLine" -> PolygonLine <$> obj .? "arg0"
+      "PolygonFill" -> pure PolygonFill
+
+instance encodeJsonProvokingVertex :: EncodeJson ProvokingVertex where
+  encodeJson v = case v of
+    FirstVertex -> "tag" := "FirstVertex" ~> jsonEmptyObject
+    LastVertex -> "tag" := "LastVertex" ~> jsonEmptyObject
+
+instance decodeJsonProvokingVertex :: DecodeJson ProvokingVertex where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "FirstVertex" -> pure FirstVertex
+      "LastVertex" -> pure LastVertex
+
+instance encodeJsonCullMode :: EncodeJson CullMode where
+  encodeJson v = case v of
+    CullNone -> "tag" := "CullNone" ~> jsonEmptyObject
+    CullFront arg0 -> "tag" := "CullFront" ~> "arg0" := arg0 ~> jsonEmptyObject
+    CullBack arg0 -> "tag" := "CullBack" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonCullMode :: DecodeJson CullMode where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "CullNone" -> pure CullNone
+      "CullFront" -> CullFront <$> obj .? "arg0"
+      "CullBack" -> CullBack <$> obj .? "arg0"
+
+instance encodeJsonComparisonFunction :: EncodeJson ComparisonFunction where
+  encodeJson v = case v of
+    Never -> "tag" := "Never" ~> jsonEmptyObject
+    Less -> "tag" := "Less" ~> jsonEmptyObject
+    Equal -> "tag" := "Equal" ~> jsonEmptyObject
+    Lequal -> "tag" := "Lequal" ~> jsonEmptyObject
+    Greater -> "tag" := "Greater" ~> jsonEmptyObject
+    Notequal -> "tag" := "Notequal" ~> jsonEmptyObject
+    Gequal -> "tag" := "Gequal" ~> jsonEmptyObject
+    Always -> "tag" := "Always" ~> jsonEmptyObject
+
+instance decodeJsonComparisonFunction :: DecodeJson ComparisonFunction where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Never" -> pure Never
+      "Less" -> pure Less
+      "Equal" -> pure Equal
+      "Lequal" -> pure Lequal
+      "Greater" -> pure Greater
+      "Notequal" -> pure Notequal
+      "Gequal" -> pure Gequal
+      "Always" -> pure Always
+
+instance encodeJsonStencilOperation :: EncodeJson StencilOperation where
+  encodeJson v = case v of
+    OpZero -> "tag" := "OpZero" ~> jsonEmptyObject
+    OpKeep -> "tag" := "OpKeep" ~> jsonEmptyObject
+    OpReplace -> "tag" := "OpReplace" ~> jsonEmptyObject
+    OpIncr -> "tag" := "OpIncr" ~> jsonEmptyObject
+    OpIncrWrap -> "tag" := "OpIncrWrap" ~> jsonEmptyObject
+    OpDecr -> "tag" := "OpDecr" ~> jsonEmptyObject
+    OpDecrWrap -> "tag" := "OpDecrWrap" ~> jsonEmptyObject
+    OpInvert -> "tag" := "OpInvert" ~> jsonEmptyObject
+
+instance decodeJsonStencilOperation :: DecodeJson StencilOperation where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "OpZero" -> pure OpZero
+      "OpKeep" -> pure OpKeep
+      "OpReplace" -> pure OpReplace
+      "OpIncr" -> pure OpIncr
+      "OpIncrWrap" -> pure OpIncrWrap
+      "OpDecr" -> pure OpDecr
+      "OpDecrWrap" -> pure OpDecrWrap
+      "OpInvert" -> pure OpInvert
+
+instance encodeJsonBlendEquation :: EncodeJson BlendEquation where
+  encodeJson v = case v of
+    FuncAdd -> "tag" := "FuncAdd" ~> jsonEmptyObject
+    FuncSubtract -> "tag" := "FuncSubtract" ~> jsonEmptyObject
+    FuncReverseSubtract -> "tag" := "FuncReverseSubtract" ~> jsonEmptyObject
+    Min -> "tag" := "Min" ~> jsonEmptyObject
+    Max -> "tag" := "Max" ~> jsonEmptyObject
+
+instance decodeJsonBlendEquation :: DecodeJson BlendEquation where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "FuncAdd" -> pure FuncAdd
+      "FuncSubtract" -> pure FuncSubtract
+      "FuncReverseSubtract" -> pure FuncReverseSubtract
+      "Min" -> pure Min
+      "Max" -> pure Max
+
+instance encodeJsonBlendingFactor :: EncodeJson BlendingFactor where
+  encodeJson v = case v of
+    Zero -> "tag" := "Zero" ~> jsonEmptyObject
+    One -> "tag" := "One" ~> jsonEmptyObject
+    SrcColor -> "tag" := "SrcColor" ~> jsonEmptyObject
+    OneMinusSrcColor -> "tag" := "OneMinusSrcColor" ~> jsonEmptyObject
+    DstColor -> "tag" := "DstColor" ~> jsonEmptyObject
+    OneMinusDstColor -> "tag" := "OneMinusDstColor" ~> jsonEmptyObject
+    SrcAlpha -> "tag" := "SrcAlpha" ~> jsonEmptyObject
+    OneMinusSrcAlpha -> "tag" := "OneMinusSrcAlpha" ~> jsonEmptyObject
+    DstAlpha -> "tag" := "DstAlpha" ~> jsonEmptyObject
+    OneMinusDstAlpha -> "tag" := "OneMinusDstAlpha" ~> jsonEmptyObject
+    ConstantColor -> "tag" := "ConstantColor" ~> jsonEmptyObject
+    OneMinusConstantColor -> "tag" := "OneMinusConstantColor" ~> jsonEmptyObject
+    ConstantAlpha -> "tag" := "ConstantAlpha" ~> jsonEmptyObject
+    OneMinusConstantAlpha -> "tag" := "OneMinusConstantAlpha" ~> jsonEmptyObject
+    SrcAlphaSaturate -> "tag" := "SrcAlphaSaturate" ~> jsonEmptyObject
+
+instance decodeJsonBlendingFactor :: DecodeJson BlendingFactor where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Zero" -> pure Zero
+      "One" -> pure One
+      "SrcColor" -> pure SrcColor
+      "OneMinusSrcColor" -> pure OneMinusSrcColor
+      "DstColor" -> pure DstColor
+      "OneMinusDstColor" -> pure OneMinusDstColor
+      "SrcAlpha" -> pure SrcAlpha
+      "OneMinusSrcAlpha" -> pure OneMinusSrcAlpha
+      "DstAlpha" -> pure DstAlpha
+      "OneMinusDstAlpha" -> pure OneMinusDstAlpha
+      "ConstantColor" -> pure ConstantColor
+      "OneMinusConstantColor" -> pure OneMinusConstantColor
+      "ConstantAlpha" -> pure ConstantAlpha
+      "OneMinusConstantAlpha" -> pure OneMinusConstantAlpha
+      "SrcAlphaSaturate" -> pure SrcAlphaSaturate
+
+instance encodeJsonLogicOperation :: EncodeJson LogicOperation where
+  encodeJson v = case v of
+    Clear -> "tag" := "Clear" ~> jsonEmptyObject
+    And -> "tag" := "And" ~> jsonEmptyObject
+    AndReverse -> "tag" := "AndReverse" ~> jsonEmptyObject
+    Copy -> "tag" := "Copy" ~> jsonEmptyObject
+    AndInverted -> "tag" := "AndInverted" ~> jsonEmptyObject
+    Noop -> "tag" := "Noop" ~> jsonEmptyObject
+    Xor -> "tag" := "Xor" ~> jsonEmptyObject
+    Or -> "tag" := "Or" ~> jsonEmptyObject
+    Nor -> "tag" := "Nor" ~> jsonEmptyObject
+    Equiv -> "tag" := "Equiv" ~> jsonEmptyObject
+    Invert -> "tag" := "Invert" ~> jsonEmptyObject
+    OrReverse -> "tag" := "OrReverse" ~> jsonEmptyObject
+    CopyInverted -> "tag" := "CopyInverted" ~> jsonEmptyObject
+    OrInverted -> "tag" := "OrInverted" ~> jsonEmptyObject
+    Nand -> "tag" := "Nand" ~> jsonEmptyObject
+    Set -> "tag" := "Set" ~> jsonEmptyObject
+
+instance decodeJsonLogicOperation :: DecodeJson LogicOperation where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Clear" -> pure Clear
+      "And" -> pure And
+      "AndReverse" -> pure AndReverse
+      "Copy" -> pure Copy
+      "AndInverted" -> pure AndInverted
+      "Noop" -> pure Noop
+      "Xor" -> pure Xor
+      "Or" -> pure Or
+      "Nor" -> pure Nor
+      "Equiv" -> pure Equiv
+      "Invert" -> pure Invert
+      "OrReverse" -> pure OrReverse
+      "CopyInverted" -> pure CopyInverted
+      "OrInverted" -> pure OrInverted
+      "Nand" -> pure Nand
+      "Set" -> pure Set
+
+instance encodeJsonStencilOps :: EncodeJson StencilOps where
+  encodeJson v = case v of
+    StencilOps r ->
+      "tag" := "StencilOps" ~>
+      "frontStencilOp" := r.frontStencilOp ~>
+      "backStencilOp" := r.backStencilOp ~>
+      jsonEmptyObject
+
+instance decodeJsonStencilOps :: DecodeJson StencilOps where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "StencilOps" -> do
+        frontStencilOp <- obj .? "frontStencilOp"
+        backStencilOp <- obj .? "backStencilOp"
+        pure $ StencilOps
+          { frontStencilOp:frontStencilOp
+          , backStencilOp:backStencilOp
+          } 
+
+instance encodeJsonStencilTest :: EncodeJson StencilTest where
+  encodeJson v = case v of
+    StencilTest r ->
+      "tag" := "StencilTest" ~>
+      "stencilComparision" := r.stencilComparision ~>
+      "stencilReference" := r.stencilReference ~>
+      "stencilMask" := r.stencilMask ~>
+      jsonEmptyObject
+
+instance decodeJsonStencilTest :: DecodeJson StencilTest where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "StencilTest" -> do
+        stencilComparision <- obj .? "stencilComparision"
+        stencilReference <- obj .? "stencilReference"
+        stencilMask <- obj .? "stencilMask"
+        pure $ StencilTest
+          { stencilComparision:stencilComparision
+          , stencilReference:stencilReference
+          , stencilMask:stencilMask
+          } 
+
+instance encodeJsonStencilTests :: EncodeJson StencilTests where
+  encodeJson v = case v of
+    StencilTests arg0 arg1 -> "tag" := "StencilTests" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonStencilTests :: DecodeJson StencilTests where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "StencilTests" -> StencilTests <$> obj .? "arg0" <*> obj .? "arg1"
+
+instance encodeJsonFetchPrimitive :: EncodeJson FetchPrimitive where
+  encodeJson v = case v of
+    Points -> "tag" := "Points" ~> jsonEmptyObject
+    Lines -> "tag" := "Lines" ~> jsonEmptyObject
+    Triangles -> "tag" := "Triangles" ~> jsonEmptyObject
+    LinesAdjacency -> "tag" := "LinesAdjacency" ~> jsonEmptyObject
+    TrianglesAdjacency -> "tag" := "TrianglesAdjacency" ~> jsonEmptyObject
+
+instance decodeJsonFetchPrimitive :: DecodeJson FetchPrimitive where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Points" -> pure Points
+      "Lines" -> pure Lines
+      "Triangles" -> pure Triangles
+      "LinesAdjacency" -> pure LinesAdjacency
+      "TrianglesAdjacency" -> pure TrianglesAdjacency
+
+instance encodeJsonOutputPrimitive :: EncodeJson OutputPrimitive where
+  encodeJson v = case v of
+    TrianglesOutput -> "tag" := "TrianglesOutput" ~> jsonEmptyObject
+    LinesOutput -> "tag" := "LinesOutput" ~> jsonEmptyObject
+    PointsOutput -> "tag" := "PointsOutput" ~> jsonEmptyObject
+
+instance decodeJsonOutputPrimitive :: DecodeJson OutputPrimitive where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "TrianglesOutput" -> pure TrianglesOutput
+      "LinesOutput" -> pure LinesOutput
+      "PointsOutput" -> pure PointsOutput
+
+instance encodeJsonColorArity :: EncodeJson ColorArity where
+  encodeJson v = case v of
+    Red -> "tag" := "Red" ~> jsonEmptyObject
+    RG -> "tag" := "RG" ~> jsonEmptyObject
+    RGB -> "tag" := "RGB" ~> jsonEmptyObject
+    RGBA -> "tag" := "RGBA" ~> jsonEmptyObject
+
+instance decodeJsonColorArity :: DecodeJson ColorArity where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Red" -> pure Red
+      "RG" -> pure RG
+      "RGB" -> pure RGB
+      "RGBA" -> pure RGBA
+
+instance encodeJsonBlending :: EncodeJson Blending where
+  encodeJson v = case v of
+    NoBlending -> "tag" := "NoBlending" ~> jsonEmptyObject
+    BlendLogicOp arg0 -> "tag" := "BlendLogicOp" ~> "arg0" := arg0 ~> jsonEmptyObject
+    Blend r ->
+      "tag" := "Blend" ~>
+      "colorEqSrc" := r.colorEqSrc ~>
+      "alphaEqSrc" := r.alphaEqSrc ~>
+      "colorFSrc" := r.colorFSrc ~>
+      "colorFDst" := r.colorFDst ~>
+      "alphaFSrc" := r.alphaFSrc ~>
+      "alphaFDst" := r.alphaFDst ~>
+      "color" := r.color ~>
+      jsonEmptyObject
+
+instance decodeJsonBlending :: DecodeJson Blending where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "NoBlending" -> pure NoBlending
+      "BlendLogicOp" -> BlendLogicOp <$> obj .? "arg0"
+      "Blend" -> do
+        colorEqSrc <- obj .? "colorEqSrc"
+        alphaEqSrc <- obj .? "alphaEqSrc"
+        colorFSrc <- obj .? "colorFSrc"
+        colorFDst <- obj .? "colorFDst"
+        alphaFSrc <- obj .? "alphaFSrc"
+        alphaFDst <- obj .? "alphaFDst"
+        color <- obj .? "color"
+        pure $ Blend
+          { colorEqSrc:colorEqSrc
+          , alphaEqSrc:alphaEqSrc
+          , colorFSrc:colorFSrc
+          , colorFDst:colorFDst
+          , alphaFSrc:alphaFSrc
+          , alphaFDst:alphaFDst
+          , color:color
+          } 
+
+instance encodeJsonRasterContext :: EncodeJson RasterContext where
+  encodeJson v = case v of
+    PointCtx arg0 arg1 arg2 -> "tag" := "PointCtx" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> "arg2" := arg2 ~> jsonEmptyObject
+    LineCtx arg0 arg1 -> "tag" := "LineCtx" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    TriangleCtx arg0 arg1 arg2 arg3 -> "tag" := "TriangleCtx" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> "arg2" := arg2 ~> "arg3" := arg3 ~> jsonEmptyObject
+
+instance decodeJsonRasterContext :: DecodeJson RasterContext where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "PointCtx" -> PointCtx <$> obj .? "arg0" <*> obj .? "arg1" <*> obj .? "arg2"
+      "LineCtx" -> LineCtx <$> obj .? "arg0" <*> obj .? "arg1"
+      "TriangleCtx" -> TriangleCtx <$> obj .? "arg0" <*> obj .? "arg1" <*> obj .? "arg2" <*> obj .? "arg3"
+
+instance encodeJsonFragmentOperation :: EncodeJson FragmentOperation where
+  encodeJson v = case v of
+    DepthOp arg0 arg1 -> "tag" := "DepthOp" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    StencilOp arg0 arg1 arg2 -> "tag" := "StencilOp" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> "arg2" := arg2 ~> jsonEmptyObject
+    ColorOp arg0 arg1 -> "tag" := "ColorOp" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonFragmentOperation :: DecodeJson FragmentOperation where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "DepthOp" -> DepthOp <$> obj .? "arg0" <*> obj .? "arg1"
+      "StencilOp" -> StencilOp <$> obj .? "arg0" <*> obj .? "arg1" <*> obj .? "arg2"
+      "ColorOp" -> ColorOp <$> obj .? "arg0" <*> obj .? "arg1"
+
+instance encodeJsonAccumulationContext :: EncodeJson AccumulationContext where
+  encodeJson v = case v of
+    AccumulationContext r ->
+      "tag" := "AccumulationContext" ~>
+      "accViewportName" := r.accViewportName ~>
+      "accOperations" := r.accOperations ~>
+      jsonEmptyObject
+
+instance decodeJsonAccumulationContext :: DecodeJson AccumulationContext where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "AccumulationContext" -> do
+        accViewportName <- obj .? "accViewportName"
+        accOperations <- obj .? "accOperations"
+        pure $ AccumulationContext
+          { accViewportName:accViewportName
+          , accOperations:accOperations
+          } 
+
+instance encodeJsonTextureDataType :: EncodeJson TextureDataType where
+  encodeJson v = case v of
+    FloatT arg0 -> "tag" := "FloatT" ~> "arg0" := arg0 ~> jsonEmptyObject
+    IntT arg0 -> "tag" := "IntT" ~> "arg0" := arg0 ~> jsonEmptyObject
+    WordT arg0 -> "tag" := "WordT" ~> "arg0" := arg0 ~> jsonEmptyObject
+    ShadowT -> "tag" := "ShadowT" ~> jsonEmptyObject
+
+instance decodeJsonTextureDataType :: DecodeJson TextureDataType where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "FloatT" -> FloatT <$> obj .? "arg0"
+      "IntT" -> IntT <$> obj .? "arg0"
+      "WordT" -> WordT <$> obj .? "arg0"
+      "ShadowT" -> pure ShadowT
+
+instance encodeJsonTextureType :: EncodeJson TextureType where
+  encodeJson v = case v of
+    Texture1D arg0 arg1 -> "tag" := "Texture1D" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    Texture2D arg0 arg1 -> "tag" := "Texture2D" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    Texture3D arg0 -> "tag" := "Texture3D" ~> "arg0" := arg0 ~> jsonEmptyObject
+    TextureCube arg0 -> "tag" := "TextureCube" ~> "arg0" := arg0 ~> jsonEmptyObject
+    TextureRect arg0 -> "tag" := "TextureRect" ~> "arg0" := arg0 ~> jsonEmptyObject
+    Texture2DMS arg0 arg1 arg2 arg3 -> "tag" := "Texture2DMS" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> "arg2" := arg2 ~> "arg3" := arg3 ~> jsonEmptyObject
+    TextureBuffer arg0 -> "tag" := "TextureBuffer" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonTextureType :: DecodeJson TextureType where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Texture1D" -> Texture1D <$> obj .? "arg0" <*> obj .? "arg1"
+      "Texture2D" -> Texture2D <$> obj .? "arg0" <*> obj .? "arg1"
+      "Texture3D" -> Texture3D <$> obj .? "arg0"
+      "TextureCube" -> TextureCube <$> obj .? "arg0"
+      "TextureRect" -> TextureRect <$> obj .? "arg0"
+      "Texture2DMS" -> Texture2DMS <$> obj .? "arg0" <*> obj .? "arg1" <*> obj .? "arg2" <*> obj .? "arg3"
+      "TextureBuffer" -> TextureBuffer <$> obj .? "arg0"
+
+instance encodeJsonMipMap :: EncodeJson MipMap where
+  encodeJson v = case v of
+    Mip arg0 arg1 -> "tag" := "Mip" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    NoMip -> "tag" := "NoMip" ~> jsonEmptyObject
+    AutoMip arg0 arg1 -> "tag" := "AutoMip" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonMipMap :: DecodeJson MipMap where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Mip" -> Mip <$> obj .? "arg0" <*> obj .? "arg1"
+      "NoMip" -> pure NoMip
+      "AutoMip" -> AutoMip <$> obj .? "arg0" <*> obj .? "arg1"
+
+instance encodeJsonFilter :: EncodeJson Filter where
+  encodeJson v = case v of
+    Nearest -> "tag" := "Nearest" ~> jsonEmptyObject
+    Linear -> "tag" := "Linear" ~> jsonEmptyObject
+    NearestMipmapNearest -> "tag" := "NearestMipmapNearest" ~> jsonEmptyObject
+    NearestMipmapLinear -> "tag" := "NearestMipmapLinear" ~> jsonEmptyObject
+    LinearMipmapNearest -> "tag" := "LinearMipmapNearest" ~> jsonEmptyObject
+    LinearMipmapLinear -> "tag" := "LinearMipmapLinear" ~> jsonEmptyObject
+
+instance decodeJsonFilter :: DecodeJson Filter where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Nearest" -> pure Nearest
+      "Linear" -> pure Linear
+      "NearestMipmapNearest" -> pure NearestMipmapNearest
+      "NearestMipmapLinear" -> pure NearestMipmapLinear
+      "LinearMipmapNearest" -> pure LinearMipmapNearest
+      "LinearMipmapLinear" -> pure LinearMipmapLinear
+
+instance encodeJsonEdgeMode :: EncodeJson EdgeMode where
+  encodeJson v = case v of
+    Repeat -> "tag" := "Repeat" ~> jsonEmptyObject
+    MirroredRepeat -> "tag" := "MirroredRepeat" ~> jsonEmptyObject
+    ClampToEdge -> "tag" := "ClampToEdge" ~> jsonEmptyObject
+    ClampToBorder -> "tag" := "ClampToBorder" ~> jsonEmptyObject
+
+instance decodeJsonEdgeMode :: DecodeJson EdgeMode where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Repeat" -> pure Repeat
+      "MirroredRepeat" -> pure MirroredRepeat
+      "ClampToEdge" -> pure ClampToEdge
+      "ClampToBorder" -> pure ClampToBorder
+
+instance encodeJsonImageSemantic :: EncodeJson ImageSemantic where
+  encodeJson v = case v of
+    Depth -> "tag" := "Depth" ~> jsonEmptyObject
+    Stencil -> "tag" := "Stencil" ~> jsonEmptyObject
+    Color -> "tag" := "Color" ~> jsonEmptyObject
+
+instance decodeJsonImageSemantic :: DecodeJson ImageSemantic where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Depth" -> pure Depth
+      "Stencil" -> pure Stencil
+      "Color" -> pure Color
+
+instance encodeJsonImageRef :: EncodeJson ImageRef where
+  encodeJson v = case v of
+    TextureImage arg0 arg1 arg2 -> "tag" := "TextureImage" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> "arg2" := arg2 ~> jsonEmptyObject
+    Framebuffer arg0 -> "tag" := "Framebuffer" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonImageRef :: DecodeJson ImageRef where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "TextureImage" -> TextureImage <$> obj .? "arg0" <*> obj .? "arg1" <*> obj .? "arg2"
+      "Framebuffer" -> Framebuffer <$> obj .? "arg0"
+
+instance encodeJsonClearImage :: EncodeJson ClearImage where
+  encodeJson v = case v of
+    ClearImage r ->
+      "tag" := "ClearImage" ~>
+      "imageSemantic" := r.imageSemantic ~>
+      "clearValue" := r.clearValue ~>
+      jsonEmptyObject
+
+instance decodeJsonClearImage :: DecodeJson ClearImage where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "ClearImage" -> do
+        imageSemantic <- obj .? "imageSemantic"
+        clearValue <- obj .? "clearValue"
+        pure $ ClearImage
+          { imageSemantic:imageSemantic
+          , clearValue:clearValue
+          } 
+
+instance encodeJsonCommand :: EncodeJson Command where
+  encodeJson v = case v of
+    SetRasterContext arg0 -> "tag" := "SetRasterContext" ~> "arg0" := arg0 ~> jsonEmptyObject
+    SetAccumulationContext arg0 -> "tag" := "SetAccumulationContext" ~> "arg0" := arg0 ~> jsonEmptyObject
+    SetRenderTarget arg0 -> "tag" := "SetRenderTarget" ~> "arg0" := arg0 ~> jsonEmptyObject
+    SetProgram arg0 -> "tag" := "SetProgram" ~> "arg0" := arg0 ~> jsonEmptyObject
+    SetSamplerUniform arg0 arg1 -> "tag" := "SetSamplerUniform" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    SetTexture arg0 arg1 -> "tag" := "SetTexture" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    SetSampler arg0 arg1 -> "tag" := "SetSampler" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    RenderSlot arg0 -> "tag" := "RenderSlot" ~> "arg0" := arg0 ~> jsonEmptyObject
+    RenderStream arg0 -> "tag" := "RenderStream" ~> "arg0" := arg0 ~> jsonEmptyObject
+    ClearRenderTarget arg0 -> "tag" := "ClearRenderTarget" ~> "arg0" := arg0 ~> jsonEmptyObject
+    GenerateMipMap arg0 -> "tag" := "GenerateMipMap" ~> "arg0" := arg0 ~> jsonEmptyObject
+    SaveImage arg0 arg1 -> "tag" := "SaveImage" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    LoadImage arg0 arg1 -> "tag" := "LoadImage" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonCommand :: DecodeJson Command where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "SetRasterContext" -> SetRasterContext <$> obj .? "arg0"
+      "SetAccumulationContext" -> SetAccumulationContext <$> obj .? "arg0"
+      "SetRenderTarget" -> SetRenderTarget <$> obj .? "arg0"
+      "SetProgram" -> SetProgram <$> obj .? "arg0"
+      "SetSamplerUniform" -> SetSamplerUniform <$> obj .? "arg0" <*> obj .? "arg1"
+      "SetTexture" -> SetTexture <$> obj .? "arg0" <*> obj .? "arg1"
+      "SetSampler" -> SetSampler <$> obj .? "arg0" <*> obj .? "arg1"
+      "RenderSlot" -> RenderSlot <$> obj .? "arg0"
+      "RenderStream" -> RenderStream <$> obj .? "arg0"
+      "ClearRenderTarget" -> ClearRenderTarget <$> obj .? "arg0"
+      "GenerateMipMap" -> GenerateMipMap <$> obj .? "arg0"
+      "SaveImage" -> SaveImage <$> obj .? "arg0" <*> obj .? "arg1"
+      "LoadImage" -> LoadImage <$> obj .? "arg0" <*> obj .? "arg1"
+
+instance encodeJsonSamplerDescriptor :: EncodeJson SamplerDescriptor where
+  encodeJson v = case v of
+    SamplerDescriptor r ->
+      "tag" := "SamplerDescriptor" ~>
+      "samplerWrapS" := r.samplerWrapS ~>
+      "samplerWrapT" := r.samplerWrapT ~>
+      "samplerWrapR" := r.samplerWrapR ~>
+      "samplerMinFilter" := r.samplerMinFilter ~>
+      "samplerMagFilter" := r.samplerMagFilter ~>
+      "samplerBorderColor" := r.samplerBorderColor ~>
+      "samplerMinLod" := r.samplerMinLod ~>
+      "samplerMaxLod" := r.samplerMaxLod ~>
+      "samplerLodBias" := r.samplerLodBias ~>
+      "samplerCompareFunc" := r.samplerCompareFunc ~>
+      jsonEmptyObject
+
+instance decodeJsonSamplerDescriptor :: DecodeJson SamplerDescriptor where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "SamplerDescriptor" -> do
+        samplerWrapS <- obj .? "samplerWrapS"
+        samplerWrapT <- obj .? "samplerWrapT"
+        samplerWrapR <- obj .? "samplerWrapR"
+        samplerMinFilter <- obj .? "samplerMinFilter"
+        samplerMagFilter <- obj .? "samplerMagFilter"
+        samplerBorderColor <- obj .? "samplerBorderColor"
+        samplerMinLod <- obj .? "samplerMinLod"
+        samplerMaxLod <- obj .? "samplerMaxLod"
+        samplerLodBias <- obj .? "samplerLodBias"
+        samplerCompareFunc <- obj .? "samplerCompareFunc"
+        pure $ SamplerDescriptor
+          { samplerWrapS:samplerWrapS
+          , samplerWrapT:samplerWrapT
+          , samplerWrapR:samplerWrapR
+          , samplerMinFilter:samplerMinFilter
+          , samplerMagFilter:samplerMagFilter
+          , samplerBorderColor:samplerBorderColor
+          , samplerMinLod:samplerMinLod
+          , samplerMaxLod:samplerMaxLod
+          , samplerLodBias:samplerLodBias
+          , samplerCompareFunc:samplerCompareFunc
+          } 
+
+instance encodeJsonTextureDescriptor :: EncodeJson TextureDescriptor where
+  encodeJson v = case v of
+    TextureDescriptor r ->
+      "tag" := "TextureDescriptor" ~>
+      "textureType" := r.textureType ~>
+      "textureSize" := r.textureSize ~>
+      "textureSemantic" := r.textureSemantic ~>
+      "textureSampler" := r.textureSampler ~>
+      "textureBaseLevel" := r.textureBaseLevel ~>
+      "textureMaxLevel" := r.textureMaxLevel ~>
+      jsonEmptyObject
+
+instance decodeJsonTextureDescriptor :: DecodeJson TextureDescriptor where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "TextureDescriptor" -> do
+        textureType <- obj .? "textureType"
+        textureSize <- obj .? "textureSize"
+        textureSemantic <- obj .? "textureSemantic"
+        textureSampler <- obj .? "textureSampler"
+        textureBaseLevel <- obj .? "textureBaseLevel"
+        textureMaxLevel <- obj .? "textureMaxLevel"
+        pure $ TextureDescriptor
+          { textureType:textureType
+          , textureSize:textureSize
+          , textureSemantic:textureSemantic
+          , textureSampler:textureSampler
+          , textureBaseLevel:textureBaseLevel
+          , textureMaxLevel:textureMaxLevel
+          } 
+
+instance encodeJsonParameter :: EncodeJson Parameter where
+  encodeJson v = case v of
+    Parameter r ->
+      "tag" := "Parameter" ~>
+      "name" := r.name ~>
+      "ty" := r.ty ~>
+      jsonEmptyObject
+
+instance decodeJsonParameter :: DecodeJson Parameter where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Parameter" -> do
+        name <- obj .? "name"
+        ty <- obj .? "ty"
+        pure $ Parameter
+          { name:name
+          , ty:ty
+          } 
+
+instance encodeJsonProgram :: EncodeJson Program where
+  encodeJson v = case v of
+    Program r ->
+      "tag" := "Program" ~>
+      "programUniforms" := r.programUniforms ~>
+      "programStreams" := r.programStreams ~>
+      "programInTextures" := r.programInTextures ~>
+      "programOutput" := r.programOutput ~>
+      "vertexShader" := r.vertexShader ~>
+      "geometryShader" := r.geometryShader ~>
+      "fragmentShader" := r.fragmentShader ~>
+      jsonEmptyObject
+
+instance decodeJsonProgram :: DecodeJson Program where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Program" -> do
+        programUniforms <- obj .? "programUniforms"
+        programStreams <- obj .? "programStreams"
+        programInTextures <- obj .? "programInTextures"
+        programOutput <- obj .? "programOutput"
+        vertexShader <- obj .? "vertexShader"
+        geometryShader <- obj .? "geometryShader"
+        fragmentShader <- obj .? "fragmentShader"
+        pure $ Program
+          { programUniforms:programUniforms
+          , programStreams:programStreams
+          , programInTextures:programInTextures
+          , programOutput:programOutput
+          , vertexShader:vertexShader
+          , geometryShader:geometryShader
+          , fragmentShader:fragmentShader
+          } 
+
+instance encodeJsonSlot :: EncodeJson Slot where
+  encodeJson v = case v of
+    Slot r ->
+      "tag" := "Slot" ~>
+      "slotName" := r.slotName ~>
+      "slotStreams" := r.slotStreams ~>
+      "slotUniforms" := r.slotUniforms ~>
+      "slotPrimitive" := r.slotPrimitive ~>
+      "slotPrograms" := r.slotPrograms ~>
+      jsonEmptyObject
+
+instance decodeJsonSlot :: DecodeJson Slot where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Slot" -> do
+        slotName <- obj .? "slotName"
+        slotStreams <- obj .? "slotStreams"
+        slotUniforms <- obj .? "slotUniforms"
+        slotPrimitive <- obj .? "slotPrimitive"
+        slotPrograms <- obj .? "slotPrograms"
+        pure $ Slot
+          { slotName:slotName
+          , slotStreams:slotStreams
+          , slotUniforms:slotUniforms
+          , slotPrimitive:slotPrimitive
+          , slotPrograms:slotPrograms
+          } 
+
+instance encodeJsonStreamData :: EncodeJson StreamData where
+  encodeJson v = case v of
+    StreamData r ->
+      "tag" := "StreamData" ~>
+      "streamData" := r.streamData ~>
+      "streamType" := r.streamType ~>
+      "streamPrimitive" := r.streamPrimitive ~>
+      "streamPrograms" := r.streamPrograms ~>
+      jsonEmptyObject
+
+instance decodeJsonStreamData :: DecodeJson StreamData where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "StreamData" -> do
+        streamData <- obj .? "streamData"
+        streamType <- obj .? "streamType"
+        streamPrimitive <- obj .? "streamPrimitive"
+        streamPrograms <- obj .? "streamPrograms"
+        pure $ StreamData
+          { streamData:streamData
+          , streamType:streamType
+          , streamPrimitive:streamPrimitive
+          , streamPrograms:streamPrograms
+          } 
+
+instance encodeJsonTargetItem :: EncodeJson TargetItem where
+  encodeJson v = case v of
+    TargetItem r ->
+      "tag" := "TargetItem" ~>
+      "targetSemantic" := r.targetSemantic ~>
+      "targetRef" := r.targetRef ~>
+      jsonEmptyObject
+
+instance decodeJsonTargetItem :: DecodeJson TargetItem where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "TargetItem" -> do
+        targetSemantic <- obj .? "targetSemantic"
+        targetRef <- obj .? "targetRef"
+        pure $ TargetItem
+          { targetSemantic:targetSemantic
+          , targetRef:targetRef
+          } 
+
+instance encodeJsonRenderTarget :: EncodeJson RenderTarget where
+  encodeJson v = case v of
+    RenderTarget r ->
+      "tag" := "RenderTarget" ~>
+      "renderTargets" := r.renderTargets ~>
+      jsonEmptyObject
+
+instance decodeJsonRenderTarget :: DecodeJson RenderTarget where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "RenderTarget" -> do
+        renderTargets <- obj .? "renderTargets"
+        pure $ RenderTarget
+          { renderTargets:renderTargets
+          } 
+
+instance encodeJsonBackend :: EncodeJson Backend where
+  encodeJson v = case v of
+    WebGL1 -> "tag" := "WebGL1" ~> jsonEmptyObject
+    OpenGL33 -> "tag" := "OpenGL33" ~> jsonEmptyObject
+
+instance decodeJsonBackend :: DecodeJson Backend where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "WebGL1" -> pure WebGL1
+      "OpenGL33" -> pure OpenGL33
+
+instance encodeJsonPipeline :: EncodeJson Pipeline where
+  encodeJson v = case v of
+    Pipeline r ->
+      "tag" := "Pipeline" ~>
+      "backend" := r.backend ~>
+      "textures" := r.textures ~>
+      "samplers" := r.samplers ~>
+      "targets" := r.targets ~>
+      "programs" := r.programs ~>
+      "slots" := r.slots ~>
+      "streams" := r.streams ~>
+      "commands" := r.commands ~>
+      jsonEmptyObject
+
+instance decodeJsonPipeline :: DecodeJson Pipeline where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Pipeline" -> do
+        backend <- obj .? "backend"
+        textures <- obj .? "textures"
+        samplers <- obj .? "samplers"
+        targets <- obj .? "targets"
+        programs <- obj .? "programs"
+        slots <- obj .? "slots"
+        streams <- obj .? "streams"
+        commands <- obj .? "commands"
+        pure $ Pipeline
+          { backend:backend
+          , textures:textures
+          , samplers:samplers
+          , targets:targets
+          , programs:programs
+          , slots:slots
+          , streams:streams
+          , commands:commands
+          } 
+
diff --git a/ddl/out/IR.swift b/ddl/out/IR.swift
new file mode 100644
index 0000000..c30e6d7
--- /dev/null
+++ b/ddl/out/IR.swift
@@ -0,0 +1,1429 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.420877000000Z
+
+typealias StreamName = Int
+
+typealias ProgramName = Int
+
+typealias TextureName = Int
+
+typealias SamplerName = Int
+
+typealias UniformName = String
+
+typealias SlotName = Int
+
+typealias FrameBufferComponent = Int
+
+typealias TextureUnit = Int
+
+typealias RenderTargetName = Int
+
+typealias TextureUnitMapping = Dictionary<UniformName, TextureUnit>
+
+enum ArrayValue {
+  case VBoolArray(Array<Bool>)
+  case VIntArray(Array<Int32>)
+  case VWordArray(Array<UInt32>)
+  case VFloatArray(Array<Float>)
+}
+
+enum Value {
+  case VBool(Bool)
+  case VV2B(Int)
+  case VV3B(Int)
+  case VV4B(Int)
+  case VWord(UInt32)
+  case VV2U(Int)
+  case VV3U(Int)
+  case VV4U(Int)
+  case VInt(Int32)
+  case VV2I(Int)
+  case VV3I(Int)
+  case VV4I(Int)
+  case VFloat(Float)
+  case VV2F(Int)
+  case VV3F(Int)
+  case VV4F(Int)
+  case VM22F(Int)
+  case VM23F(Int)
+  case VM24F(Int)
+  case VM32F(Int)
+  case VM33F(Int)
+  case VM34F(Int)
+  case VM42F(Int)
+  case VM43F(Int)
+  case VM44F(Int)
+}
+
+enum InputType {
+  case Bool
+  case V2B
+  case V3B
+  case V4B
+  case Word
+  case V2U
+  case V3U
+  case V4U
+  case Int
+  case V2I
+  case V3I
+  case V4I
+  case Float
+  case V2F
+  case V3F
+  case V4F
+  case M22F
+  case M23F
+  case M24F
+  case M32F
+  case M33F
+  case M34F
+  case M42F
+  case M43F
+  case M44F
+  case STexture1D
+  case STexture2D
+  case STextureCube
+  case STexture1DArray
+  case STexture2DArray
+  case STexture2DRect
+  case FTexture1D
+  case FTexture2D
+  case FTexture3D
+  case FTextureCube
+  case FTexture1DArray
+  case FTexture2DArray
+  case FTexture2DMS
+  case FTexture2DMSArray
+  case FTextureBuffer
+  case FTexture2DRect
+  case ITexture1D
+  case ITexture2D
+  case ITexture3D
+  case ITextureCube
+  case ITexture1DArray
+  case ITexture2DArray
+  case ITexture2DMS
+  case ITexture2DMSArray
+  case ITextureBuffer
+  case ITexture2DRect
+  case UTexture1D
+  case UTexture2D
+  case UTexture3D
+  case UTextureCube
+  case UTexture1DArray
+  case UTexture2DArray
+  case UTexture2DMS
+  case UTexture2DMSArray
+  case UTextureBuffer
+  case UTexture2DRect
+}
+
+enum PointSpriteCoordOrigin {
+  case LowerLeft
+  case UpperLeft
+}
+
+enum PointSize {
+  case PointSize(Float)
+  case ProgramPointSize
+}
+
+enum PolygonOffset {
+  case NoOffset
+  case Offset(Float,Float)
+}
+
+enum FrontFace {
+  case CCW
+  case CW
+}
+
+enum PolygonMode {
+  case PolygonPoint(PointSize)
+  case PolygonLine(Float)
+  case PolygonFill
+}
+
+enum ProvokingVertex {
+  case FirstVertex
+  case LastVertex
+}
+
+enum CullMode {
+  case CullNone
+  case CullFront(FrontFace)
+  case CullBack(FrontFace)
+}
+
+enum ComparisonFunction {
+  case Never
+  case Less
+  case Equal
+  case Lequal
+  case Greater
+  case Notequal
+  case Gequal
+  case Always
+}
+
+typealias DepthFunction = ComparisonFunction
+
+enum StencilOperation {
+  case OpZero
+  case OpKeep
+  case OpReplace
+  case OpIncr
+  case OpIncrWrap
+  case OpDecr
+  case OpDecrWrap
+  case OpInvert
+}
+
+enum BlendEquation {
+  case FuncAdd
+  case FuncSubtract
+  case FuncReverseSubtract
+  case Min
+  case Max
+}
+
+enum BlendingFactor {
+  case Zero
+  case One
+  case SrcColor
+  case OneMinusSrcColor
+  case DstColor
+  case OneMinusDstColor
+  case SrcAlpha
+  case OneMinusSrcAlpha
+  case DstAlpha
+  case OneMinusDstAlpha
+  case ConstantColor
+  case OneMinusConstantColor
+  case ConstantAlpha
+  case OneMinusConstantAlpha
+  case SrcAlphaSaturate
+}
+
+enum LogicOperation {
+  case Clear
+  case And
+  case AndReverse
+  case Copy
+  case AndInverted
+  case Noop
+  case Xor
+  case Or
+  case Nor
+  case Equiv
+  case Invert
+  case OrReverse
+  case CopyInverted
+  case OrInverted
+  case Nand
+  case Set
+}
+
+enum StencilOps {
+  case StencilOps(StencilOps_Data)
+    struct StencilOps_Data {
+      var frontStencilOp : StencilOperation
+      var backStencilOp : StencilOperation
+    }
+}
+
+enum StencilTest {
+  case StencilTest(StencilTest_Data)
+    struct StencilTest_Data {
+      var stencilComparision : ComparisonFunction
+      var stencilReference : Int32
+      var stencilMask : UInt32
+    }
+}
+
+enum StencilTests {
+  case StencilTests(StencilTest,StencilTest)
+}
+
+enum FetchPrimitive {
+  case Points
+  case Lines
+  case Triangles
+  case LinesAdjacency
+  case TrianglesAdjacency
+}
+
+enum OutputPrimitive {
+  case TrianglesOutput
+  case LinesOutput
+  case PointsOutput
+}
+
+enum ColorArity {
+  case Red
+  case RG
+  case RGB
+  case RGBA
+}
+
+enum Blending {
+  case NoBlending
+  case BlendLogicOp(LogicOperation)
+  case Blend(Blend_Data)
+    struct Blend_Data {
+      var colorEqSrc : BlendEquation
+      var alphaEqSrc : BlendEquation
+      var colorFSrc : BlendingFactor
+      var colorFDst : BlendingFactor
+      var alphaFSrc : BlendingFactor
+      var alphaFDst : BlendingFactor
+      var color : Int
+    }
+}
+
+enum RasterContext {
+  case PointCtx(PointSize,Float,PointSpriteCoordOrigin)
+  case LineCtx(Float,ProvokingVertex)
+  case TriangleCtx(CullMode,PolygonMode,PolygonOffset,ProvokingVertex)
+}
+
+enum FragmentOperation {
+  case DepthOp(DepthFunction,Bool)
+  case StencilOp(StencilTests,StencilOps,StencilOps)
+  case ColorOp(Blending,Value)
+}
+
+enum AccumulationContext {
+  case AccumulationContext(AccumulationContext_Data)
+    struct AccumulationContext_Data {
+      var accViewportName : Maybe<String>
+      var accOperations : Array<FragmentOperation>
+    }
+}
+
+enum TextureDataType {
+  case FloatT(ColorArity)
+  case IntT(ColorArity)
+  case WordT(ColorArity)
+  case ShadowT
+}
+
+enum TextureType {
+  case Texture1D(TextureDataType,Int)
+  case Texture2D(TextureDataType,Int)
+  case Texture3D(TextureDataType)
+  case TextureCube(TextureDataType)
+  case TextureRect(TextureDataType)
+  case Texture2DMS(TextureDataType,Int,Int,Bool)
+  case TextureBuffer(TextureDataType)
+}
+
+enum MipMap {
+  case Mip(Int,Int)
+  case NoMip
+  case AutoMip(Int,Int)
+}
+
+enum Filter {
+  case Nearest
+  case Linear
+  case NearestMipmapNearest
+  case NearestMipmapLinear
+  case LinearMipmapNearest
+  case LinearMipmapLinear
+}
+
+enum EdgeMode {
+  case Repeat
+  case MirroredRepeat
+  case ClampToEdge
+  case ClampToBorder
+}
+
+enum ImageSemantic {
+  case Depth
+  case Stencil
+  case Color
+}
+
+enum ImageRef {
+  case TextureImage(TextureName,Int,Maybe<Int>)
+  case Framebuffer(ImageSemantic)
+}
+
+enum ClearImage {
+  case ClearImage(ClearImage_Data)
+    struct ClearImage_Data {
+      var imageSemantic : ImageSemantic
+      var clearValue : Value
+    }
+}
+
+enum Command {
+  case SetRasterContext(RasterContext)
+  case SetAccumulationContext(AccumulationContext)
+  case SetRenderTarget(RenderTargetName)
+  case SetProgram(ProgramName)
+  case SetSamplerUniform(UniformName,TextureUnit)
+  case SetTexture(TextureUnit,TextureName)
+  case SetSampler(TextureUnit,Maybe<SamplerName>)
+  case RenderSlot(SlotName)
+  case RenderStream(StreamName)
+  case ClearRenderTarget(Array<ClearImage>)
+  case GenerateMipMap(TextureUnit)
+  case SaveImage(FrameBufferComponent,ImageRef)
+  case LoadImage(ImageRef,FrameBufferComponent)
+}
+
+enum SamplerDescriptor {
+  case SamplerDescriptor(SamplerDescriptor_Data)
+    struct SamplerDescriptor_Data {
+      var samplerWrapS : EdgeMode
+      var samplerWrapT : Maybe<EdgeMode>
+      var samplerWrapR : Maybe<EdgeMode>
+      var samplerMinFilter : Filter
+      var samplerMagFilter : Filter
+      var samplerBorderColor : Value
+      var samplerMinLod : Maybe<Float>
+      var samplerMaxLod : Maybe<Float>
+      var samplerLodBias : Float
+      var samplerCompareFunc : Maybe<ComparisonFunction>
+    }
+}
+
+enum TextureDescriptor {
+  case TextureDescriptor(TextureDescriptor_Data)
+    struct TextureDescriptor_Data {
+      var textureType : TextureType
+      var textureSize : Value
+      var textureSemantic : ImageSemantic
+      var textureSampler : SamplerDescriptor
+      var textureBaseLevel : Int
+      var textureMaxLevel : Int
+    }
+}
+
+enum Parameter {
+  case Parameter(Parameter_Data)
+    struct Parameter_Data {
+      var name : String
+      var ty : InputType
+    }
+}
+
+enum Program {
+  case Program(Program_Data)
+    struct Program_Data {
+      var programUniforms : Dictionary<UniformName, InputType>
+      var programStreams : Dictionary<UniformName, Parameter>
+      var programInTextures : Dictionary<UniformName, InputType>
+      var programOutput : Array<Parameter>
+      var vertexShader : String
+      var geometryShader : Maybe<String>
+      var fragmentShader : String
+    }
+}
+
+enum Slot {
+  case Slot(Slot_Data)
+    struct Slot_Data {
+      var slotName : String
+      var slotStreams : Dictionary<String, InputType>
+      var slotUniforms : Dictionary<UniformName, InputType>
+      var slotPrimitive : FetchPrimitive
+      var slotPrograms : Array<ProgramName>
+    }
+}
+
+enum StreamData {
+  case StreamData(StreamData_Data)
+    struct StreamData_Data {
+      var streamData : Dictionary<String, ArrayValue>
+      var streamType : Dictionary<String, InputType>
+      var streamPrimitive : FetchPrimitive
+      var streamPrograms : Array<ProgramName>
+    }
+}
+
+enum TargetItem {
+  case TargetItem(TargetItem_Data)
+    struct TargetItem_Data {
+      var targetSemantic : ImageSemantic
+      var targetRef : Maybe<ImageRef>
+    }
+}
+
+enum RenderTarget {
+  case RenderTarget(RenderTarget_Data)
+    struct RenderTarget_Data {
+      var renderTargets : Array<TargetItem>
+    }
+}
+
+enum Backend {
+  case WebGL1
+  case OpenGL33
+}
+
+enum Pipeline {
+  case Pipeline(Pipeline_Data)
+    struct Pipeline_Data {
+      var backend : Backend
+      var textures : Array<TextureDescriptor>
+      var samplers : Array<SamplerDescriptor>
+      var targets : Array<RenderTarget>
+      var programs : Array<Program>
+      var slots : Array<Slot>
+      var streams : Array<StreamData>
+      var commands : Array<Command>
+    }
+}
+
+
+extension Int {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Int32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Float {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Bool {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension String {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Array {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Dictionary {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Maybe {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+
+
+
+extension ArrayValue {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .VBoolArray(let arg0):
+        return [ "tag" : "VBoolArray", "arg0" : arg0.toJSON]
+      case .VIntArray(let arg0):
+        return [ "tag" : "VIntArray", "arg0" : arg0.toJSON]
+      case .VWordArray(let arg0):
+        return [ "tag" : "VWordArray", "arg0" : arg0.toJSON]
+      case .VFloatArray(let arg0):
+        return [ "tag" : "VFloatArray", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension Value {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .VBool(let arg0):
+        return [ "tag" : "VBool", "arg0" : arg0.toJSON]
+      case .VV2B(let arg0):
+        return [ "tag" : "VV2B", "arg0" : arg0.toJSON]
+      case .VV3B(let arg0):
+        return [ "tag" : "VV3B", "arg0" : arg0.toJSON]
+      case .VV4B(let arg0):
+        return [ "tag" : "VV4B", "arg0" : arg0.toJSON]
+      case .VWord(let arg0):
+        return [ "tag" : "VWord", "arg0" : arg0.toJSON]
+      case .VV2U(let arg0):
+        return [ "tag" : "VV2U", "arg0" : arg0.toJSON]
+      case .VV3U(let arg0):
+        return [ "tag" : "VV3U", "arg0" : arg0.toJSON]
+      case .VV4U(let arg0):
+        return [ "tag" : "VV4U", "arg0" : arg0.toJSON]
+      case .VInt(let arg0):
+        return [ "tag" : "VInt", "arg0" : arg0.toJSON]
+      case .VV2I(let arg0):
+        return [ "tag" : "VV2I", "arg0" : arg0.toJSON]
+      case .VV3I(let arg0):
+        return [ "tag" : "VV3I", "arg0" : arg0.toJSON]
+      case .VV4I(let arg0):
+        return [ "tag" : "VV4I", "arg0" : arg0.toJSON]
+      case .VFloat(let arg0):
+        return [ "tag" : "VFloat", "arg0" : arg0.toJSON]
+      case .VV2F(let arg0):
+        return [ "tag" : "VV2F", "arg0" : arg0.toJSON]
+      case .VV3F(let arg0):
+        return [ "tag" : "VV3F", "arg0" : arg0.toJSON]
+      case .VV4F(let arg0):
+        return [ "tag" : "VV4F", "arg0" : arg0.toJSON]
+      case .VM22F(let arg0):
+        return [ "tag" : "VM22F", "arg0" : arg0.toJSON]
+      case .VM23F(let arg0):
+        return [ "tag" : "VM23F", "arg0" : arg0.toJSON]
+      case .VM24F(let arg0):
+        return [ "tag" : "VM24F", "arg0" : arg0.toJSON]
+      case .VM32F(let arg0):
+        return [ "tag" : "VM32F", "arg0" : arg0.toJSON]
+      case .VM33F(let arg0):
+        return [ "tag" : "VM33F", "arg0" : arg0.toJSON]
+      case .VM34F(let arg0):
+        return [ "tag" : "VM34F", "arg0" : arg0.toJSON]
+      case .VM42F(let arg0):
+        return [ "tag" : "VM42F", "arg0" : arg0.toJSON]
+      case .VM43F(let arg0):
+        return [ "tag" : "VM43F", "arg0" : arg0.toJSON]
+      case .VM44F(let arg0):
+        return [ "tag" : "VM44F", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension InputType {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Bool:
+        return [ "tag" : "Bool"]
+      case .V2B:
+        return [ "tag" : "V2B"]
+      case .V3B:
+        return [ "tag" : "V3B"]
+      case .V4B:
+        return [ "tag" : "V4B"]
+      case .Word:
+        return [ "tag" : "Word"]
+      case .V2U:
+        return [ "tag" : "V2U"]
+      case .V3U:
+        return [ "tag" : "V3U"]
+      case .V4U:
+        return [ "tag" : "V4U"]
+      case .Int:
+        return [ "tag" : "Int"]
+      case .V2I:
+        return [ "tag" : "V2I"]
+      case .V3I:
+        return [ "tag" : "V3I"]
+      case .V4I:
+        return [ "tag" : "V4I"]
+      case .Float:
+        return [ "tag" : "Float"]
+      case .V2F:
+        return [ "tag" : "V2F"]
+      case .V3F:
+        return [ "tag" : "V3F"]
+      case .V4F:
+        return [ "tag" : "V4F"]
+      case .M22F:
+        return [ "tag" : "M22F"]
+      case .M23F:
+        return [ "tag" : "M23F"]
+      case .M24F:
+        return [ "tag" : "M24F"]
+      case .M32F:
+        return [ "tag" : "M32F"]
+      case .M33F:
+        return [ "tag" : "M33F"]
+      case .M34F:
+        return [ "tag" : "M34F"]
+      case .M42F:
+        return [ "tag" : "M42F"]
+      case .M43F:
+        return [ "tag" : "M43F"]
+      case .M44F:
+        return [ "tag" : "M44F"]
+      case .STexture1D:
+        return [ "tag" : "STexture1D"]
+      case .STexture2D:
+        return [ "tag" : "STexture2D"]
+      case .STextureCube:
+        return [ "tag" : "STextureCube"]
+      case .STexture1DArray:
+        return [ "tag" : "STexture1DArray"]
+      case .STexture2DArray:
+        return [ "tag" : "STexture2DArray"]
+      case .STexture2DRect:
+        return [ "tag" : "STexture2DRect"]
+      case .FTexture1D:
+        return [ "tag" : "FTexture1D"]
+      case .FTexture2D:
+        return [ "tag" : "FTexture2D"]
+      case .FTexture3D:
+        return [ "tag" : "FTexture3D"]
+      case .FTextureCube:
+        return [ "tag" : "FTextureCube"]
+      case .FTexture1DArray:
+        return [ "tag" : "FTexture1DArray"]
+      case .FTexture2DArray:
+        return [ "tag" : "FTexture2DArray"]
+      case .FTexture2DMS:
+        return [ "tag" : "FTexture2DMS"]
+      case .FTexture2DMSArray:
+        return [ "tag" : "FTexture2DMSArray"]
+      case .FTextureBuffer:
+        return [ "tag" : "FTextureBuffer"]
+      case .FTexture2DRect:
+        return [ "tag" : "FTexture2DRect"]
+      case .ITexture1D:
+        return [ "tag" : "ITexture1D"]
+      case .ITexture2D:
+        return [ "tag" : "ITexture2D"]
+      case .ITexture3D:
+        return [ "tag" : "ITexture3D"]
+      case .ITextureCube:
+        return [ "tag" : "ITextureCube"]
+      case .ITexture1DArray:
+        return [ "tag" : "ITexture1DArray"]
+      case .ITexture2DArray:
+        return [ "tag" : "ITexture2DArray"]
+      case .ITexture2DMS:
+        return [ "tag" : "ITexture2DMS"]
+      case .ITexture2DMSArray:
+        return [ "tag" : "ITexture2DMSArray"]
+      case .ITextureBuffer:
+        return [ "tag" : "ITextureBuffer"]
+      case .ITexture2DRect:
+        return [ "tag" : "ITexture2DRect"]
+      case .UTexture1D:
+        return [ "tag" : "UTexture1D"]
+      case .UTexture2D:
+        return [ "tag" : "UTexture2D"]
+      case .UTexture3D:
+        return [ "tag" : "UTexture3D"]
+      case .UTextureCube:
+        return [ "tag" : "UTextureCube"]
+      case .UTexture1DArray:
+        return [ "tag" : "UTexture1DArray"]
+      case .UTexture2DArray:
+        return [ "tag" : "UTexture2DArray"]
+      case .UTexture2DMS:
+        return [ "tag" : "UTexture2DMS"]
+      case .UTexture2DMSArray:
+        return [ "tag" : "UTexture2DMSArray"]
+      case .UTextureBuffer:
+        return [ "tag" : "UTextureBuffer"]
+      case .UTexture2DRect:
+        return [ "tag" : "UTexture2DRect"]
+    }
+  }
+}
+extension PointSpriteCoordOrigin {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .LowerLeft:
+        return [ "tag" : "LowerLeft"]
+      case .UpperLeft:
+        return [ "tag" : "UpperLeft"]
+    }
+  }
+}
+extension PointSize {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .PointSize(let arg0):
+        return [ "tag" : "PointSize", "arg0" : arg0.toJSON]
+      case .ProgramPointSize:
+        return [ "tag" : "ProgramPointSize"]
+    }
+  }
+}
+extension PolygonOffset {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .NoOffset:
+        return [ "tag" : "NoOffset"]
+      case .Offset(let arg0, let arg1):
+        return [ "tag" : "Offset", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+extension FrontFace {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .CCW:
+        return [ "tag" : "CCW"]
+      case .CW:
+        return [ "tag" : "CW"]
+    }
+  }
+}
+extension PolygonMode {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .PolygonPoint(let arg0):
+        return [ "tag" : "PolygonPoint", "arg0" : arg0.toJSON]
+      case .PolygonLine(let arg0):
+        return [ "tag" : "PolygonLine", "arg0" : arg0.toJSON]
+      case .PolygonFill:
+        return [ "tag" : "PolygonFill"]
+    }
+  }
+}
+extension ProvokingVertex {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .FirstVertex:
+        return [ "tag" : "FirstVertex"]
+      case .LastVertex:
+        return [ "tag" : "LastVertex"]
+    }
+  }
+}
+extension CullMode {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .CullNone:
+        return [ "tag" : "CullNone"]
+      case .CullFront(let arg0):
+        return [ "tag" : "CullFront", "arg0" : arg0.toJSON]
+      case .CullBack(let arg0):
+        return [ "tag" : "CullBack", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension ComparisonFunction {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Never:
+        return [ "tag" : "Never"]
+      case .Less:
+        return [ "tag" : "Less"]
+      case .Equal:
+        return [ "tag" : "Equal"]
+      case .Lequal:
+        return [ "tag" : "Lequal"]
+      case .Greater:
+        return [ "tag" : "Greater"]
+      case .Notequal:
+        return [ "tag" : "Notequal"]
+      case .Gequal:
+        return [ "tag" : "Gequal"]
+      case .Always:
+        return [ "tag" : "Always"]
+    }
+  }
+}
+extension StencilOperation {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .OpZero:
+        return [ "tag" : "OpZero"]
+      case .OpKeep:
+        return [ "tag" : "OpKeep"]
+      case .OpReplace:
+        return [ "tag" : "OpReplace"]
+      case .OpIncr:
+        return [ "tag" : "OpIncr"]
+      case .OpIncrWrap:
+        return [ "tag" : "OpIncrWrap"]
+      case .OpDecr:
+        return [ "tag" : "OpDecr"]
+      case .OpDecrWrap:
+        return [ "tag" : "OpDecrWrap"]
+      case .OpInvert:
+        return [ "tag" : "OpInvert"]
+    }
+  }
+}
+extension BlendEquation {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .FuncAdd:
+        return [ "tag" : "FuncAdd"]
+      case .FuncSubtract:
+        return [ "tag" : "FuncSubtract"]
+      case .FuncReverseSubtract:
+        return [ "tag" : "FuncReverseSubtract"]
+      case .Min:
+        return [ "tag" : "Min"]
+      case .Max:
+        return [ "tag" : "Max"]
+    }
+  }
+}
+extension BlendingFactor {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Zero:
+        return [ "tag" : "Zero"]
+      case .One:
+        return [ "tag" : "One"]
+      case .SrcColor:
+        return [ "tag" : "SrcColor"]
+      case .OneMinusSrcColor:
+        return [ "tag" : "OneMinusSrcColor"]
+      case .DstColor:
+        return [ "tag" : "DstColor"]
+      case .OneMinusDstColor:
+        return [ "tag" : "OneMinusDstColor"]
+      case .SrcAlpha:
+        return [ "tag" : "SrcAlpha"]
+      case .OneMinusSrcAlpha:
+        return [ "tag" : "OneMinusSrcAlpha"]
+      case .DstAlpha:
+        return [ "tag" : "DstAlpha"]
+      case .OneMinusDstAlpha:
+        return [ "tag" : "OneMinusDstAlpha"]
+      case .ConstantColor:
+        return [ "tag" : "ConstantColor"]
+      case .OneMinusConstantColor:
+        return [ "tag" : "OneMinusConstantColor"]
+      case .ConstantAlpha:
+        return [ "tag" : "ConstantAlpha"]
+      case .OneMinusConstantAlpha:
+        return [ "tag" : "OneMinusConstantAlpha"]
+      case .SrcAlphaSaturate:
+        return [ "tag" : "SrcAlphaSaturate"]
+    }
+  }
+}
+extension LogicOperation {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Clear:
+        return [ "tag" : "Clear"]
+      case .And:
+        return [ "tag" : "And"]
+      case .AndReverse:
+        return [ "tag" : "AndReverse"]
+      case .Copy:
+        return [ "tag" : "Copy"]
+      case .AndInverted:
+        return [ "tag" : "AndInverted"]
+      case .Noop:
+        return [ "tag" : "Noop"]
+      case .Xor:
+        return [ "tag" : "Xor"]
+      case .Or:
+        return [ "tag" : "Or"]
+      case .Nor:
+        return [ "tag" : "Nor"]
+      case .Equiv:
+        return [ "tag" : "Equiv"]
+      case .Invert:
+        return [ "tag" : "Invert"]
+      case .OrReverse:
+        return [ "tag" : "OrReverse"]
+      case .CopyInverted:
+        return [ "tag" : "CopyInverted"]
+      case .OrInverted:
+        return [ "tag" : "OrInverted"]
+      case .Nand:
+        return [ "tag" : "Nand"]
+      case .Set:
+        return [ "tag" : "Set"]
+    }
+  }
+}
+extension StencilOps {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .StencilOps(let v):
+        return [ "tag" : "StencilOps"
+               , "frontStencilOp" : v.frontStencilOp.toJSON
+               , "backStencilOp" : v.backStencilOp.toJSON
+               ]
+    }
+  }
+}
+extension StencilTest {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .StencilTest(let v):
+        return [ "tag" : "StencilTest"
+               , "stencilComparision" : v.stencilComparision.toJSON
+               , "stencilReference" : v.stencilReference.toJSON
+               , "stencilMask" : v.stencilMask.toJSON
+               ]
+    }
+  }
+}
+extension StencilTests {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .StencilTests(let arg0, let arg1):
+        return [ "tag" : "StencilTests", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+extension FetchPrimitive {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Points:
+        return [ "tag" : "Points"]
+      case .Lines:
+        return [ "tag" : "Lines"]
+      case .Triangles:
+        return [ "tag" : "Triangles"]
+      case .LinesAdjacency:
+        return [ "tag" : "LinesAdjacency"]
+      case .TrianglesAdjacency:
+        return [ "tag" : "TrianglesAdjacency"]
+    }
+  }
+}
+extension OutputPrimitive {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .TrianglesOutput:
+        return [ "tag" : "TrianglesOutput"]
+      case .LinesOutput:
+        return [ "tag" : "LinesOutput"]
+      case .PointsOutput:
+        return [ "tag" : "PointsOutput"]
+    }
+  }
+}
+extension ColorArity {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Red:
+        return [ "tag" : "Red"]
+      case .RG:
+        return [ "tag" : "RG"]
+      case .RGB:
+        return [ "tag" : "RGB"]
+      case .RGBA:
+        return [ "tag" : "RGBA"]
+    }
+  }
+}
+extension Blending {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .NoBlending:
+        return [ "tag" : "NoBlending"]
+      case .BlendLogicOp(let arg0):
+        return [ "tag" : "BlendLogicOp", "arg0" : arg0.toJSON]
+      case .Blend(let v):
+        return [ "tag" : "Blend"
+               , "colorEqSrc" : v.colorEqSrc.toJSON
+               , "alphaEqSrc" : v.alphaEqSrc.toJSON
+               , "colorFSrc" : v.colorFSrc.toJSON
+               , "colorFDst" : v.colorFDst.toJSON
+               , "alphaFSrc" : v.alphaFSrc.toJSON
+               , "alphaFDst" : v.alphaFDst.toJSON
+               , "color" : v.color.toJSON
+               ]
+    }
+  }
+}
+extension RasterContext {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .PointCtx(let arg0, let arg1, let arg2):
+        return [ "tag" : "PointCtx", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON, "arg2" : arg2.toJSON]
+      case .LineCtx(let arg0, let arg1):
+        return [ "tag" : "LineCtx", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .TriangleCtx(let arg0, let arg1, let arg2, let arg3):
+        return [ "tag" : "TriangleCtx", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON, "arg2" : arg2.toJSON, "arg3" : arg3.toJSON]
+    }
+  }
+}
+extension FragmentOperation {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .DepthOp(let arg0, let arg1):
+        return [ "tag" : "DepthOp", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .StencilOp(let arg0, let arg1, let arg2):
+        return [ "tag" : "StencilOp", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON, "arg2" : arg2.toJSON]
+      case .ColorOp(let arg0, let arg1):
+        return [ "tag" : "ColorOp", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+extension AccumulationContext {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .AccumulationContext(let v):
+        return [ "tag" : "AccumulationContext"
+               , "accViewportName" : v.accViewportName.toJSON
+               , "accOperations" : v.accOperations.toJSON
+               ]
+    }
+  }
+}
+extension TextureDataType {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .FloatT(let arg0):
+        return [ "tag" : "FloatT", "arg0" : arg0.toJSON]
+      case .IntT(let arg0):
+        return [ "tag" : "IntT", "arg0" : arg0.toJSON]
+      case .WordT(let arg0):
+        return [ "tag" : "WordT", "arg0" : arg0.toJSON]
+      case .ShadowT:
+        return [ "tag" : "ShadowT"]
+    }
+  }
+}
+extension TextureType {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Texture1D(let arg0, let arg1):
+        return [ "tag" : "Texture1D", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .Texture2D(let arg0, let arg1):
+        return [ "tag" : "Texture2D", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .Texture3D(let arg0):
+        return [ "tag" : "Texture3D", "arg0" : arg0.toJSON]
+      case .TextureCube(let arg0):
+        return [ "tag" : "TextureCube", "arg0" : arg0.toJSON]
+      case .TextureRect(let arg0):
+        return [ "tag" : "TextureRect", "arg0" : arg0.toJSON]
+      case .Texture2DMS(let arg0, let arg1, let arg2, let arg3):
+        return [ "tag" : "Texture2DMS", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON, "arg2" : arg2.toJSON, "arg3" : arg3.toJSON]
+      case .TextureBuffer(let arg0):
+        return [ "tag" : "TextureBuffer", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension MipMap {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Mip(let arg0, let arg1):
+        return [ "tag" : "Mip", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .NoMip:
+        return [ "tag" : "NoMip"]
+      case .AutoMip(let arg0, let arg1):
+        return [ "tag" : "AutoMip", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+extension Filter {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Nearest:
+        return [ "tag" : "Nearest"]
+      case .Linear:
+        return [ "tag" : "Linear"]
+      case .NearestMipmapNearest:
+        return [ "tag" : "NearestMipmapNearest"]
+      case .NearestMipmapLinear:
+        return [ "tag" : "NearestMipmapLinear"]
+      case .LinearMipmapNearest:
+        return [ "tag" : "LinearMipmapNearest"]
+      case .LinearMipmapLinear:
+        return [ "tag" : "LinearMipmapLinear"]
+    }
+  }
+}
+extension EdgeMode {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Repeat:
+        return [ "tag" : "Repeat"]
+      case .MirroredRepeat:
+        return [ "tag" : "MirroredRepeat"]
+      case .ClampToEdge:
+        return [ "tag" : "ClampToEdge"]
+      case .ClampToBorder:
+        return [ "tag" : "ClampToBorder"]
+    }
+  }
+}
+extension ImageSemantic {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Depth:
+        return [ "tag" : "Depth"]
+      case .Stencil:
+        return [ "tag" : "Stencil"]
+      case .Color:
+        return [ "tag" : "Color"]
+    }
+  }
+}
+extension ImageRef {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .TextureImage(let arg0, let arg1, let arg2):
+        return [ "tag" : "TextureImage", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON, "arg2" : arg2.toJSON]
+      case .Framebuffer(let arg0):
+        return [ "tag" : "Framebuffer", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension ClearImage {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .ClearImage(let v):
+        return [ "tag" : "ClearImage"
+               , "imageSemantic" : v.imageSemantic.toJSON
+               , "clearValue" : v.clearValue.toJSON
+               ]
+    }
+  }
+}
+extension Command {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .SetRasterContext(let arg0):
+        return [ "tag" : "SetRasterContext", "arg0" : arg0.toJSON]
+      case .SetAccumulationContext(let arg0):
+        return [ "tag" : "SetAccumulationContext", "arg0" : arg0.toJSON]
+      case .SetRenderTarget(let arg0):
+        return [ "tag" : "SetRenderTarget", "arg0" : arg0.toJSON]
+      case .SetProgram(let arg0):
+        return [ "tag" : "SetProgram", "arg0" : arg0.toJSON]
+      case .SetSamplerUniform(let arg0, let arg1):
+        return [ "tag" : "SetSamplerUniform", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .SetTexture(let arg0, let arg1):
+        return [ "tag" : "SetTexture", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .SetSampler(let arg0, let arg1):
+        return [ "tag" : "SetSampler", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .RenderSlot(let arg0):
+        return [ "tag" : "RenderSlot", "arg0" : arg0.toJSON]
+      case .RenderStream(let arg0):
+        return [ "tag" : "RenderStream", "arg0" : arg0.toJSON]
+      case .ClearRenderTarget(let arg0):
+        return [ "tag" : "ClearRenderTarget", "arg0" : arg0.toJSON]
+      case .GenerateMipMap(let arg0):
+        return [ "tag" : "GenerateMipMap", "arg0" : arg0.toJSON]
+      case .SaveImage(let arg0, let arg1):
+        return [ "tag" : "SaveImage", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .LoadImage(let arg0, let arg1):
+        return [ "tag" : "LoadImage", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+extension SamplerDescriptor {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .SamplerDescriptor(let v):
+        return [ "tag" : "SamplerDescriptor"
+               , "samplerWrapS" : v.samplerWrapS.toJSON
+               , "samplerWrapT" : v.samplerWrapT.toJSON
+               , "samplerWrapR" : v.samplerWrapR.toJSON
+               , "samplerMinFilter" : v.samplerMinFilter.toJSON
+               , "samplerMagFilter" : v.samplerMagFilter.toJSON
+               , "samplerBorderColor" : v.samplerBorderColor.toJSON
+               , "samplerMinLod" : v.samplerMinLod.toJSON
+               , "samplerMaxLod" : v.samplerMaxLod.toJSON
+               , "samplerLodBias" : v.samplerLodBias.toJSON
+               , "samplerCompareFunc" : v.samplerCompareFunc.toJSON
+               ]
+    }
+  }
+}
+extension TextureDescriptor {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .TextureDescriptor(let v):
+        return [ "tag" : "TextureDescriptor"
+               , "textureType" : v.textureType.toJSON
+               , "textureSize" : v.textureSize.toJSON
+               , "textureSemantic" : v.textureSemantic.toJSON
+               , "textureSampler" : v.textureSampler.toJSON
+               , "textureBaseLevel" : v.textureBaseLevel.toJSON
+               , "textureMaxLevel" : v.textureMaxLevel.toJSON
+               ]
+    }
+  }
+}
+extension Parameter {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Parameter(let v):
+        return [ "tag" : "Parameter"
+               , "name" : v.name.toJSON
+               , "ty" : v.ty.toJSON
+               ]
+    }
+  }
+}
+extension Program {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Program(let v):
+        return [ "tag" : "Program"
+               , "programUniforms" : v.programUniforms.toJSON
+               , "programStreams" : v.programStreams.toJSON
+               , "programInTextures" : v.programInTextures.toJSON
+               , "programOutput" : v.programOutput.toJSON
+               , "vertexShader" : v.vertexShader.toJSON
+               , "geometryShader" : v.geometryShader.toJSON
+               , "fragmentShader" : v.fragmentShader.toJSON
+               ]
+    }
+  }
+}
+extension Slot {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Slot(let v):
+        return [ "tag" : "Slot"
+               , "slotName" : v.slotName.toJSON
+               , "slotStreams" : v.slotStreams.toJSON
+               , "slotUniforms" : v.slotUniforms.toJSON
+               , "slotPrimitive" : v.slotPrimitive.toJSON
+               , "slotPrograms" : v.slotPrograms.toJSON
+               ]
+    }
+  }
+}
+extension StreamData {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .StreamData(let v):
+        return [ "tag" : "StreamData"
+               , "streamData" : v.streamData.toJSON
+               , "streamType" : v.streamType.toJSON
+               , "streamPrimitive" : v.streamPrimitive.toJSON
+               , "streamPrograms" : v.streamPrograms.toJSON
+               ]
+    }
+  }
+}
+extension TargetItem {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .TargetItem(let v):
+        return [ "tag" : "TargetItem"
+               , "targetSemantic" : v.targetSemantic.toJSON
+               , "targetRef" : v.targetRef.toJSON
+               ]
+    }
+  }
+}
+extension RenderTarget {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .RenderTarget(let v):
+        return [ "tag" : "RenderTarget"
+               , "renderTargets" : v.renderTargets.toJSON
+               ]
+    }
+  }
+}
+extension Backend {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .WebGL1:
+        return [ "tag" : "WebGL1"]
+      case .OpenGL33:
+        return [ "tag" : "OpenGL33"]
+    }
+  }
+}
+extension Pipeline {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Pipeline(let v):
+        return [ "tag" : "Pipeline"
+               , "backend" : v.backend.toJSON
+               , "textures" : v.textures.toJSON
+               , "samplers" : v.samplers.toJSON
+               , "targets" : v.targets.toJSON
+               , "programs" : v.programs.toJSON
+               , "slots" : v.slots.toJSON
+               , "streams" : v.streams.toJSON
+               , "commands" : v.commands.toJSON
+               ]
+    }
+  }
+}
+
+enum Maybe<T> {
+  case Nothing
+  case Just(T)
+}
+
+enum Type {
+  case Int
+  case Int32
+  case Word
+  case Word32
+  case Float
+  case Bool
+  case String
+  case Array(Type)
+  case List(Type)
+  case Maybe(Type)
+  case Map(Type,Type)
+  case ArrayValue
+  case Value
+  case InputType
+  case PointSpriteCoordOrigin
+  case PointSize
+  case PolygonOffset
+  case FrontFace
+  case PolygonMode
+  case ProvokingVertex
+  case CullMode
+  case ComparisonFunction
+  case StencilOperation
+  case BlendEquation
+  case BlendingFactor
+  case LogicOperation
+  case StencilOps
+  case StencilTest
+  case StencilTests
+  case FetchPrimitive
+  case OutputPrimitive
+  case ColorArity
+  case Blending
+  case RasterContext
+  case FragmentOperation
+  case AccumulationContext
+  case TextureDataType
+  case TextureType
+  case MipMap
+  case Filter
+  case EdgeMode
+  case ImageSemantic
+  case ImageRef
+  case ClearImage
+  case Command
+  case SamplerDescriptor
+  case TextureDescriptor
+  case Parameter
+  case Program
+  case Slot
+  case StreamData
+  case TargetItem
+  case RenderTarget
+  case Backend
+  case Pipeline
+}
+
+func fromJSON(type: Type, personName: String) -> Any {
+  switch type {
+    case .Int:    return 0
+    case .Int32:  return 0
+    case .Word:   return 0
+    case .Word32: return 0
+    case .Float:  return 0.0
+    case .Bool:   return false
+    case .String: return ""
+    case .Array(let a): return fromJSON(a,personName)
+    case .List(let a):  return fromJSON(a,personName)
+    case .Maybe(let a): return fromJSON(a,personName)
+  }
+  return 0;
+}
\ No newline at end of file
diff --git a/ddl/out/IR2.hpp b/ddl/out/IR2.hpp
new file mode 100644
index 0000000..61fc2c6
--- /dev/null
+++ b/ddl/out/IR2.hpp
@@ -0,0 +1,1070 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.420877000000Z
+
+#ifndef HEADER_IR_H
+#define HEADER_IR_H
+
+#include "RT.hpp"
+
+
+typedef Int StreamName;
+
+typedef Int ProgramName;
+
+typedef Int TextureName;
+
+typedef Int SamplerName;
+
+typedef String UniformName;
+
+typedef Int SlotName;
+
+typedef Int FrameBufferComponent;
+
+typedef Int TextureUnit;
+
+typedef Int RenderTargetName;
+
+typedef std::map<::UniformName, ::TextureUnit> TextureUnitMapping;
+
+namespace data { 
+  class VBoolArray {
+  public: 
+    std::vector<Bool> _0;
+  };
+  class VIntArray {
+  public: 
+    std::vector<Int32> _0;
+  };
+  class VWordArray {
+  public: 
+    std::vector<Word32> _0;
+  };
+  class VFloatArray {
+  public: 
+    std::vector<Float> _0;
+  };
+}
+class ArrayValue {
+public:
+  enum class tag { 
+    VBoolArray,
+    VIntArray,
+    VWordArray,
+    VFloatArray
+  } tag;
+  std::shared_ptr<data::VBoolArray> VBoolArray;
+  std::shared_ptr<data::VIntArray> VIntArray;
+  std::shared_ptr<data::VWordArray> VWordArray;
+  std::shared_ptr<data::VFloatArray> VFloatArray;
+};
+namespace data { 
+  class VBool {
+  public: 
+    Bool _0;
+  };
+  class VV2B {
+  public: 
+    V2B _0;
+  };
+  class VV3B {
+  public: 
+    V3B _0;
+  };
+  class VV4B {
+  public: 
+    V4B _0;
+  };
+  class VWord {
+  public: 
+    Word32 _0;
+  };
+  class VV2U {
+  public: 
+    V2U _0;
+  };
+  class VV3U {
+  public: 
+    V3U _0;
+  };
+  class VV4U {
+  public: 
+    V4U _0;
+  };
+  class VInt {
+  public: 
+    Int32 _0;
+  };
+  class VV2I {
+  public: 
+    V2I _0;
+  };
+  class VV3I {
+  public: 
+    V3I _0;
+  };
+  class VV4I {
+  public: 
+    V4I _0;
+  };
+  class VFloat {
+  public: 
+    Float _0;
+  };
+  class VV2F {
+  public: 
+    V2F _0;
+  };
+  class VV3F {
+  public: 
+    V3F _0;
+  };
+  class VV4F {
+  public: 
+    V4F _0;
+  };
+  class VM22F {
+  public: 
+    M22F _0;
+  };
+  class VM23F {
+  public: 
+    M23F _0;
+  };
+  class VM24F {
+  public: 
+    M24F _0;
+  };
+  class VM32F {
+  public: 
+    M32F _0;
+  };
+  class VM33F {
+  public: 
+    M33F _0;
+  };
+  class VM34F {
+  public: 
+    M34F _0;
+  };
+  class VM42F {
+  public: 
+    M42F _0;
+  };
+  class VM43F {
+  public: 
+    M43F _0;
+  };
+  class VM44F {
+  public: 
+    M44F _0;
+  };
+}
+class Value {
+public:
+  enum class tag { 
+    VBool,
+    VV2B,
+    VV3B,
+    VV4B,
+    VWord,
+    VV2U,
+    VV3U,
+    VV4U,
+    VInt,
+    VV2I,
+    VV3I,
+    VV4I,
+    VFloat,
+    VV2F,
+    VV3F,
+    VV4F,
+    VM22F,
+    VM23F,
+    VM24F,
+    VM32F,
+    VM33F,
+    VM34F,
+    VM42F,
+    VM43F,
+    VM44F
+  } tag;
+  std::shared_ptr<data::VBool> VBool;
+  std::shared_ptr<data::VV2B> VV2B;
+  std::shared_ptr<data::VV3B> VV3B;
+  std::shared_ptr<data::VV4B> VV4B;
+  std::shared_ptr<data::VWord> VWord;
+  std::shared_ptr<data::VV2U> VV2U;
+  std::shared_ptr<data::VV3U> VV3U;
+  std::shared_ptr<data::VV4U> VV4U;
+  std::shared_ptr<data::VInt> VInt;
+  std::shared_ptr<data::VV2I> VV2I;
+  std::shared_ptr<data::VV3I> VV3I;
+  std::shared_ptr<data::VV4I> VV4I;
+  std::shared_ptr<data::VFloat> VFloat;
+  std::shared_ptr<data::VV2F> VV2F;
+  std::shared_ptr<data::VV3F> VV3F;
+  std::shared_ptr<data::VV4F> VV4F;
+  std::shared_ptr<data::VM22F> VM22F;
+  std::shared_ptr<data::VM23F> VM23F;
+  std::shared_ptr<data::VM24F> VM24F;
+  std::shared_ptr<data::VM32F> VM32F;
+  std::shared_ptr<data::VM33F> VM33F;
+  std::shared_ptr<data::VM34F> VM34F;
+  std::shared_ptr<data::VM42F> VM42F;
+  std::shared_ptr<data::VM43F> VM43F;
+  std::shared_ptr<data::VM44F> VM44F;
+};
+namespace data { 
+}
+class InputType {
+public:
+  enum class tag { 
+    Bool,
+    V2B,
+    V3B,
+    V4B,
+    Word,
+    V2U,
+    V3U,
+    V4U,
+    Int,
+    V2I,
+    V3I,
+    V4I,
+    Float,
+    V2F,
+    V3F,
+    V4F,
+    M22F,
+    M23F,
+    M24F,
+    M32F,
+    M33F,
+    M34F,
+    M42F,
+    M43F,
+    M44F,
+    STexture1D,
+    STexture2D,
+    STextureCube,
+    STexture1DArray,
+    STexture2DArray,
+    STexture2DRect,
+    FTexture1D,
+    FTexture2D,
+    FTexture3D,
+    FTextureCube,
+    FTexture1DArray,
+    FTexture2DArray,
+    FTexture2DMS,
+    FTexture2DMSArray,
+    FTextureBuffer,
+    FTexture2DRect,
+    ITexture1D,
+    ITexture2D,
+    ITexture3D,
+    ITextureCube,
+    ITexture1DArray,
+    ITexture2DArray,
+    ITexture2DMS,
+    ITexture2DMSArray,
+    ITextureBuffer,
+    ITexture2DRect,
+    UTexture1D,
+    UTexture2D,
+    UTexture3D,
+    UTextureCube,
+    UTexture1DArray,
+    UTexture2DArray,
+    UTexture2DMS,
+    UTexture2DMSArray,
+    UTextureBuffer,
+    UTexture2DRect
+  } tag;
+};
+namespace data { 
+}
+class PointSpriteCoordOrigin {
+public:
+  enum class tag { 
+    LowerLeft,
+    UpperLeft
+  } tag;
+};
+namespace data { 
+  class PointSize {
+  public: 
+    Float _0;
+  };
+}
+class PointSize {
+public:
+  enum class tag { 
+    PointSize,
+    ProgramPointSize
+  } tag;
+  std::shared_ptr<data::PointSize> PointSize;
+};
+namespace data { 
+  class Offset {
+  public: 
+    Float _0;
+    Float _1;
+  };
+}
+class PolygonOffset {
+public:
+  enum class tag { 
+    NoOffset,
+    Offset
+  } tag;
+  std::shared_ptr<data::Offset> Offset;
+};
+namespace data { 
+}
+class FrontFace {
+public:
+  enum class tag { 
+    CCW,
+    CW
+  } tag;
+};
+namespace data { 
+  class PolygonPoint {
+  public: 
+    std::shared_ptr<::PointSize> _0;
+  };
+  class PolygonLine {
+  public: 
+    Float _0;
+  };
+}
+class PolygonMode {
+public:
+  enum class tag { 
+    PolygonPoint,
+    PolygonLine,
+    PolygonFill
+  } tag;
+  std::shared_ptr<data::PolygonPoint> PolygonPoint;
+  std::shared_ptr<data::PolygonLine> PolygonLine;
+};
+namespace data { 
+}
+class ProvokingVertex {
+public:
+  enum class tag { 
+    FirstVertex,
+    LastVertex
+  } tag;
+};
+namespace data { 
+  class CullFront {
+  public: 
+    std::shared_ptr<::FrontFace> _0;
+  };
+  class CullBack {
+  public: 
+    std::shared_ptr<::FrontFace> _0;
+  };
+}
+class CullMode {
+public:
+  enum class tag { 
+    CullNone,
+    CullFront,
+    CullBack
+  } tag;
+  std::shared_ptr<data::CullFront> CullFront;
+  std::shared_ptr<data::CullBack> CullBack;
+};
+namespace data { 
+}
+class ComparisonFunction {
+public:
+  enum class tag { 
+    Never,
+    Less,
+    Equal,
+    Lequal,
+    Greater,
+    Notequal,
+    Gequal,
+    Always
+  } tag;
+};
+typedef ComparisonFunction DepthFunction;
+
+namespace data { 
+}
+class StencilOperation {
+public:
+  enum class tag { 
+    OpZero,
+    OpKeep,
+    OpReplace,
+    OpIncr,
+    OpIncrWrap,
+    OpDecr,
+    OpDecrWrap,
+    OpInvert
+  } tag;
+};
+namespace data { 
+}
+class BlendEquation {
+public:
+  enum class tag { 
+    FuncAdd,
+    FuncSubtract,
+    FuncReverseSubtract,
+    Min,
+    Max
+  } tag;
+};
+namespace data { 
+}
+class BlendingFactor {
+public:
+  enum class tag { 
+    Zero,
+    One,
+    SrcColor,
+    OneMinusSrcColor,
+    DstColor,
+    OneMinusDstColor,
+    SrcAlpha,
+    OneMinusSrcAlpha,
+    DstAlpha,
+    OneMinusDstAlpha,
+    ConstantColor,
+    OneMinusConstantColor,
+    ConstantAlpha,
+    OneMinusConstantAlpha,
+    SrcAlphaSaturate
+  } tag;
+};
+namespace data { 
+}
+class LogicOperation {
+public:
+  enum class tag { 
+    Clear,
+    And,
+    AndReverse,
+    Copy,
+    AndInverted,
+    Noop,
+    Xor,
+    Or,
+    Nor,
+    Equiv,
+    Invert,
+    OrReverse,
+    CopyInverted,
+    OrInverted,
+    Nand,
+    Set
+  } tag;
+};
+namespace data { 
+  class StencilOps {
+  public: 
+    std::shared_ptr<::StencilOperation> frontStencilOp;
+    std::shared_ptr<::StencilOperation> backStencilOp;
+  };
+}
+class StencilOps {
+public:
+  enum class tag { 
+    StencilOps
+  } tag;
+  std::shared_ptr<data::StencilOps> StencilOps;
+};
+namespace data { 
+  class StencilTest {
+  public: 
+    std::shared_ptr<::ComparisonFunction> stencilComparision;
+    Int32 stencilReference;
+    Word32 stencilMask;
+  };
+}
+class StencilTest {
+public:
+  enum class tag { 
+    StencilTest
+  } tag;
+  std::shared_ptr<data::StencilTest> StencilTest;
+};
+namespace data { 
+  class StencilTests {
+  public: 
+    std::shared_ptr<::StencilTest> _0;
+    std::shared_ptr<::StencilTest> _1;
+  };
+}
+class StencilTests {
+public:
+  enum class tag { 
+    StencilTests
+  } tag;
+  std::shared_ptr<data::StencilTests> StencilTests;
+};
+namespace data { 
+}
+class FetchPrimitive {
+public:
+  enum class tag { 
+    Points,
+    Lines,
+    Triangles,
+    LinesAdjacency,
+    TrianglesAdjacency
+  } tag;
+};
+namespace data { 
+}
+class OutputPrimitive {
+public:
+  enum class tag { 
+    TrianglesOutput,
+    LinesOutput,
+    PointsOutput
+  } tag;
+};
+namespace data { 
+}
+class ColorArity {
+public:
+  enum class tag { 
+    Red,
+    RG,
+    RGB,
+    RGBA
+  } tag;
+};
+namespace data { 
+  class BlendLogicOp {
+  public: 
+    std::shared_ptr<::LogicOperation> _0;
+  };
+  class Blend {
+  public: 
+    std::shared_ptr<::BlendEquation> colorEqSrc;
+    std::shared_ptr<::BlendEquation> alphaEqSrc;
+    std::shared_ptr<::BlendingFactor> colorFSrc;
+    std::shared_ptr<::BlendingFactor> colorFDst;
+    std::shared_ptr<::BlendingFactor> alphaFSrc;
+    std::shared_ptr<::BlendingFactor> alphaFDst;
+    V4F color;
+  };
+}
+class Blending {
+public:
+  enum class tag { 
+    NoBlending,
+    BlendLogicOp,
+    Blend
+  } tag;
+  std::shared_ptr<data::BlendLogicOp> BlendLogicOp;
+  std::shared_ptr<data::Blend> Blend;
+};
+namespace data { 
+  class PointCtx {
+  public: 
+    std::shared_ptr<::PointSize> _0;
+    Float _1;
+    std::shared_ptr<::PointSpriteCoordOrigin> _2;
+  };
+  class LineCtx {
+  public: 
+    Float _0;
+    std::shared_ptr<::ProvokingVertex> _1;
+  };
+  class TriangleCtx {
+  public: 
+    std::shared_ptr<::CullMode> _0;
+    std::shared_ptr<::PolygonMode> _1;
+    std::shared_ptr<::PolygonOffset> _2;
+    std::shared_ptr<::ProvokingVertex> _3;
+  };
+}
+class RasterContext {
+public:
+  enum class tag { 
+    PointCtx,
+    LineCtx,
+    TriangleCtx
+  } tag;
+  std::shared_ptr<data::PointCtx> PointCtx;
+  std::shared_ptr<data::LineCtx> LineCtx;
+  std::shared_ptr<data::TriangleCtx> TriangleCtx;
+};
+namespace data { 
+  class DepthOp {
+  public: 
+    std::shared_ptr<::DepthFunction> _0;
+    Bool _1;
+  };
+  class StencilOp {
+  public: 
+    std::shared_ptr<::StencilTests> _0;
+    std::shared_ptr<::StencilOps> _1;
+    std::shared_ptr<::StencilOps> _2;
+  };
+  class ColorOp {
+  public: 
+    std::shared_ptr<::Blending> _0;
+    std::shared_ptr<::Value> _1;
+  };
+}
+class FragmentOperation {
+public:
+  enum class tag { 
+    DepthOp,
+    StencilOp,
+    ColorOp
+  } tag;
+  std::shared_ptr<data::DepthOp> DepthOp;
+  std::shared_ptr<data::StencilOp> StencilOp;
+  std::shared_ptr<data::ColorOp> ColorOp;
+};
+namespace data { 
+  class AccumulationContext {
+  public: 
+    Maybe<String> accViewportName;
+    std::vector<std::shared_ptr<::FragmentOperation>> accOperations;
+  };
+}
+class AccumulationContext {
+public:
+  enum class tag { 
+    AccumulationContext
+  } tag;
+  std::shared_ptr<data::AccumulationContext> AccumulationContext;
+};
+namespace data { 
+  class FloatT {
+  public: 
+    std::shared_ptr<::ColorArity> _0;
+  };
+  class IntT {
+  public: 
+    std::shared_ptr<::ColorArity> _0;
+  };
+  class WordT {
+  public: 
+    std::shared_ptr<::ColorArity> _0;
+  };
+}
+class TextureDataType {
+public:
+  enum class tag { 
+    FloatT,
+    IntT,
+    WordT,
+    ShadowT
+  } tag;
+  std::shared_ptr<data::FloatT> FloatT;
+  std::shared_ptr<data::IntT> IntT;
+  std::shared_ptr<data::WordT> WordT;
+};
+namespace data { 
+  class Texture1D {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+    Int _1;
+  };
+  class Texture2D {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+    Int _1;
+  };
+  class Texture3D {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+  };
+  class TextureCube {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+  };
+  class TextureRect {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+  };
+  class Texture2DMS {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+    Int _1;
+    Int _2;
+    Bool _3;
+  };
+  class TextureBuffer {
+  public: 
+    std::shared_ptr<::TextureDataType> _0;
+  };
+}
+class TextureType {
+public:
+  enum class tag { 
+    Texture1D,
+    Texture2D,
+    Texture3D,
+    TextureCube,
+    TextureRect,
+    Texture2DMS,
+    TextureBuffer
+  } tag;
+  std::shared_ptr<data::Texture1D> Texture1D;
+  std::shared_ptr<data::Texture2D> Texture2D;
+  std::shared_ptr<data::Texture3D> Texture3D;
+  std::shared_ptr<data::TextureCube> TextureCube;
+  std::shared_ptr<data::TextureRect> TextureRect;
+  std::shared_ptr<data::Texture2DMS> Texture2DMS;
+  std::shared_ptr<data::TextureBuffer> TextureBuffer;
+};
+namespace data { 
+  class Mip {
+  public: 
+    Int _0;
+    Int _1;
+  };
+  class AutoMip {
+  public: 
+    Int _0;
+    Int _1;
+  };
+}
+class MipMap {
+public:
+  enum class tag { 
+    Mip,
+    NoMip,
+    AutoMip
+  } tag;
+  std::shared_ptr<data::Mip> Mip;
+  std::shared_ptr<data::AutoMip> AutoMip;
+};
+namespace data { 
+}
+class Filter {
+public:
+  enum class tag { 
+    Nearest,
+    Linear,
+    NearestMipmapNearest,
+    NearestMipmapLinear,
+    LinearMipmapNearest,
+    LinearMipmapLinear
+  } tag;
+};
+namespace data { 
+}
+class EdgeMode {
+public:
+  enum class tag { 
+    Repeat,
+    MirroredRepeat,
+    ClampToEdge,
+    ClampToBorder
+  } tag;
+};
+namespace data { 
+}
+class ImageSemantic {
+public:
+  enum class tag { 
+    Depth,
+    Stencil,
+    Color
+  } tag;
+};
+namespace data { 
+  class TextureImage {
+  public: 
+    ::TextureName _0;
+    Int _1;
+    Maybe<Int> _2;
+  };
+  class Framebuffer {
+  public: 
+    std::shared_ptr<::ImageSemantic> _0;
+  };
+}
+class ImageRef {
+public:
+  enum class tag { 
+    TextureImage,
+    Framebuffer
+  } tag;
+  std::shared_ptr<data::TextureImage> TextureImage;
+  std::shared_ptr<data::Framebuffer> Framebuffer;
+};
+namespace data { 
+  class ClearImage {
+  public: 
+    std::shared_ptr<::ImageSemantic> imageSemantic;
+    std::shared_ptr<::Value> clearValue;
+  };
+}
+class ClearImage {
+public:
+  enum class tag { 
+    ClearImage
+  } tag;
+  std::shared_ptr<data::ClearImage> ClearImage;
+};
+namespace data { 
+  class SetRasterContext {
+  public: 
+    std::shared_ptr<::RasterContext> _0;
+  };
+  class SetAccumulationContext {
+  public: 
+    std::shared_ptr<::AccumulationContext> _0;
+  };
+  class SetRenderTarget {
+  public: 
+    ::RenderTargetName _0;
+  };
+  class SetProgram {
+  public: 
+    ::ProgramName _0;
+  };
+  class SetSamplerUniform {
+  public: 
+    ::UniformName _0;
+    ::TextureUnit _1;
+  };
+  class SetTexture {
+  public: 
+    ::TextureUnit _0;
+    ::TextureName _1;
+  };
+  class SetSampler {
+  public: 
+    ::TextureUnit _0;
+    Maybe<::SamplerName> _1;
+  };
+  class RenderSlot {
+  public: 
+    ::SlotName _0;
+  };
+  class RenderStream {
+  public: 
+    ::StreamName _0;
+  };
+  class ClearRenderTarget {
+  public: 
+    std::vector<std::shared_ptr<::ClearImage>> _0;
+  };
+  class GenerateMipMap {
+  public: 
+    ::TextureUnit _0;
+  };
+  class SaveImage {
+  public: 
+    ::FrameBufferComponent _0;
+    std::shared_ptr<::ImageRef> _1;
+  };
+  class LoadImage {
+  public: 
+    std::shared_ptr<::ImageRef> _0;
+    ::FrameBufferComponent _1;
+  };
+}
+class Command {
+public:
+  enum class tag { 
+    SetRasterContext,
+    SetAccumulationContext,
+    SetRenderTarget,
+    SetProgram,
+    SetSamplerUniform,
+    SetTexture,
+    SetSampler,
+    RenderSlot,
+    RenderStream,
+    ClearRenderTarget,
+    GenerateMipMap,
+    SaveImage,
+    LoadImage
+  } tag;
+  std::shared_ptr<data::SetRasterContext> SetRasterContext;
+  std::shared_ptr<data::SetAccumulationContext> SetAccumulationContext;
+  std::shared_ptr<data::SetRenderTarget> SetRenderTarget;
+  std::shared_ptr<data::SetProgram> SetProgram;
+  std::shared_ptr<data::SetSamplerUniform> SetSamplerUniform;
+  std::shared_ptr<data::SetTexture> SetTexture;
+  std::shared_ptr<data::SetSampler> SetSampler;
+  std::shared_ptr<data::RenderSlot> RenderSlot;
+  std::shared_ptr<data::RenderStream> RenderStream;
+  std::shared_ptr<data::ClearRenderTarget> ClearRenderTarget;
+  std::shared_ptr<data::GenerateMipMap> GenerateMipMap;
+  std::shared_ptr<data::SaveImage> SaveImage;
+  std::shared_ptr<data::LoadImage> LoadImage;
+};
+namespace data { 
+  class SamplerDescriptor {
+  public: 
+    std::shared_ptr<::EdgeMode> samplerWrapS;
+    Maybe<std::shared_ptr<::EdgeMode>> samplerWrapT;
+    Maybe<std::shared_ptr<::EdgeMode>> samplerWrapR;
+    std::shared_ptr<::Filter> samplerMinFilter;
+    std::shared_ptr<::Filter> samplerMagFilter;
+    std::shared_ptr<::Value> samplerBorderColor;
+    Maybe<Float> samplerMinLod;
+    Maybe<Float> samplerMaxLod;
+    Float samplerLodBias;
+    Maybe<std::shared_ptr<::ComparisonFunction>> samplerCompareFunc;
+  };
+}
+class SamplerDescriptor {
+public:
+  enum class tag { 
+    SamplerDescriptor
+  } tag;
+  std::shared_ptr<data::SamplerDescriptor> SamplerDescriptor;
+};
+namespace data { 
+  class TextureDescriptor {
+  public: 
+    std::shared_ptr<::TextureType> textureType;
+    std::shared_ptr<::Value> textureSize;
+    std::shared_ptr<::ImageSemantic> textureSemantic;
+    std::shared_ptr<::SamplerDescriptor> textureSampler;
+    Int textureBaseLevel;
+    Int textureMaxLevel;
+  };
+}
+class TextureDescriptor {
+public:
+  enum class tag { 
+    TextureDescriptor
+  } tag;
+  std::shared_ptr<data::TextureDescriptor> TextureDescriptor;
+};
+namespace data { 
+  class Parameter {
+  public: 
+    String name;
+    std::shared_ptr<::InputType> ty;
+  };
+}
+class Parameter {
+public:
+  enum class tag { 
+    Parameter
+  } tag;
+  std::shared_ptr<data::Parameter> Parameter;
+};
+namespace data { 
+  class Program {
+  public: 
+    std::map<::UniformName, std::shared_ptr<::InputType>> programUniforms;
+    std::map<::UniformName, std::shared_ptr<::Parameter>> programStreams;
+    std::map<::UniformName, std::shared_ptr<::InputType>> programInTextures;
+    std::vector<std::shared_ptr<::Parameter>> programOutput;
+    String vertexShader;
+    Maybe<String> geometryShader;
+    String fragmentShader;
+  };
+}
+class Program {
+public:
+  enum class tag { 
+    Program
+  } tag;
+  std::shared_ptr<data::Program> Program;
+};
+namespace data { 
+  class Slot {
+  public: 
+    String slotName;
+    std::map<String, std::shared_ptr<::InputType>> slotStreams;
+    std::map<::UniformName, std::shared_ptr<::InputType>> slotUniforms;
+    std::shared_ptr<::FetchPrimitive> slotPrimitive;
+    std::vector<::ProgramName> slotPrograms;
+  };
+}
+class Slot {
+public:
+  enum class tag { 
+    Slot
+  } tag;
+  std::shared_ptr<data::Slot> Slot;
+};
+namespace data { 
+  class StreamData {
+  public: 
+    std::map<String, std::shared_ptr<::ArrayValue>> streamData;
+    std::map<String, std::shared_ptr<::InputType>> streamType;
+    std::shared_ptr<::FetchPrimitive> streamPrimitive;
+    std::vector<::ProgramName> streamPrograms;
+  };
+}
+class StreamData {
+public:
+  enum class tag { 
+    StreamData
+  } tag;
+  std::shared_ptr<data::StreamData> StreamData;
+};
+namespace data { 
+  class TargetItem {
+  public: 
+    std::shared_ptr<::ImageSemantic> targetSemantic;
+    Maybe<std::shared_ptr<::ImageRef>> targetRef;
+  };
+}
+class TargetItem {
+public:
+  enum class tag { 
+    TargetItem
+  } tag;
+  std::shared_ptr<data::TargetItem> TargetItem;
+};
+namespace data { 
+  class RenderTarget {
+  public: 
+    std::vector<std::shared_ptr<::TargetItem>> renderTargets;
+  };
+}
+class RenderTarget {
+public:
+  enum class tag { 
+    RenderTarget
+  } tag;
+  std::shared_ptr<data::RenderTarget> RenderTarget;
+};
+namespace data { 
+}
+class Backend {
+public:
+  enum class tag { 
+    WebGL1,
+    OpenGL33
+  } tag;
+};
+namespace data { 
+  class Pipeline {
+  public: 
+    std::shared_ptr<::Backend> backend;
+    std::vector<std::shared_ptr<::TextureDescriptor>> textures;
+    std::vector<std::shared_ptr<::SamplerDescriptor>> samplers;
+    std::vector<std::shared_ptr<::RenderTarget>> targets;
+    std::vector<std::shared_ptr<::Program>> programs;
+    std::vector<std::shared_ptr<::Slot>> slots;
+    std::vector<std::shared_ptr<::StreamData>> streams;
+    std::vector<std::shared_ptr<::Command>> commands;
+  };
+}
+class Pipeline {
+public:
+  enum class tag { 
+    Pipeline
+  } tag;
+  std::shared_ptr<data::Pipeline> Pipeline;
+};
+#endif
diff --git a/ddl/out/Mesh.cpp b/ddl/out/Mesh.cpp
new file mode 100644
index 0000000..1661d8e
--- /dev/null
+++ b/ddl/out/Mesh.cpp
@@ -0,0 +1,228 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.818584000000Z
+
+#include "Mesh.hpp"
+template<> json toJSON<std::shared_ptr<MeshAttribute>>(std::shared_ptr<MeshAttribute> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::MeshAttribute::tag::A_Float:
+      obj["tag"] = "A_Float";
+      {
+        std::shared_ptr<data::A_Float> tv = std::static_pointer_cast<data::A_Float>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_V2F:
+      obj["tag"] = "A_V2F";
+      {
+        std::shared_ptr<data::A_V2F> tv = std::static_pointer_cast<data::A_V2F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_V3F:
+      obj["tag"] = "A_V3F";
+      {
+        std::shared_ptr<data::A_V3F> tv = std::static_pointer_cast<data::A_V3F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_V4F:
+      obj["tag"] = "A_V4F";
+      {
+        std::shared_ptr<data::A_V4F> tv = std::static_pointer_cast<data::A_V4F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_M22F:
+      obj["tag"] = "A_M22F";
+      {
+        std::shared_ptr<data::A_M22F> tv = std::static_pointer_cast<data::A_M22F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_M33F:
+      obj["tag"] = "A_M33F";
+      {
+        std::shared_ptr<data::A_M33F> tv = std::static_pointer_cast<data::A_M33F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_M44F:
+      obj["tag"] = "A_M44F";
+      {
+        std::shared_ptr<data::A_M44F> tv = std::static_pointer_cast<data::A_M44F>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_Int:
+      obj["tag"] = "A_Int";
+      {
+        std::shared_ptr<data::A_Int> tv = std::static_pointer_cast<data::A_Int>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshAttribute::tag::A_Word:
+      obj["tag"] = "A_Word";
+      {
+        std::shared_ptr<data::A_Word> tv = std::static_pointer_cast<data::A_Word>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<MeshAttribute> fromJSON<std::shared_ptr<MeshAttribute>>(W<std::shared_ptr<MeshAttribute>> v, json &obj) {
+  enum ::MeshAttribute::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "A_Float") {
+    tagType = ::MeshAttribute::tag::A_Float;
+    std::shared_ptr<data::A_Float> tv(new data::A_Float());
+    tv->_0 = fromJSON(W<std::vector<Float>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_V2F") {
+    tagType = ::MeshAttribute::tag::A_V2F;
+    std::shared_ptr<data::A_V2F> tv(new data::A_V2F());
+    tv->_0 = fromJSON(W<std::vector<V2F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_V3F") {
+    tagType = ::MeshAttribute::tag::A_V3F;
+    std::shared_ptr<data::A_V3F> tv(new data::A_V3F());
+    tv->_0 = fromJSON(W<std::vector<V3F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_V4F") {
+    tagType = ::MeshAttribute::tag::A_V4F;
+    std::shared_ptr<data::A_V4F> tv(new data::A_V4F());
+    tv->_0 = fromJSON(W<std::vector<V4F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_M22F") {
+    tagType = ::MeshAttribute::tag::A_M22F;
+    std::shared_ptr<data::A_M22F> tv(new data::A_M22F());
+    tv->_0 = fromJSON(W<std::vector<M22F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_M33F") {
+    tagType = ::MeshAttribute::tag::A_M33F;
+    std::shared_ptr<data::A_M33F> tv(new data::A_M33F());
+    tv->_0 = fromJSON(W<std::vector<M33F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_M44F") {
+    tagType = ::MeshAttribute::tag::A_M44F;
+    std::shared_ptr<data::A_M44F> tv(new data::A_M44F());
+    tv->_0 = fromJSON(W<std::vector<M44F>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_Int") {
+    tagType = ::MeshAttribute::tag::A_Int;
+    std::shared_ptr<data::A_Int> tv(new data::A_Int());
+    tv->_0 = fromJSON(W<std::vector<Int32>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "A_Word") {
+    tagType = ::MeshAttribute::tag::A_Word;
+    std::shared_ptr<data::A_Word> tv(new data::A_Word());
+    tv->_0 = fromJSON(W<std::vector<Word32>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::MeshAttribute> o(new ::MeshAttribute());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<MeshPrimitive>>(std::shared_ptr<MeshPrimitive> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::MeshPrimitive::tag::P_Points:
+      obj["tag"] = "P_Points";
+      break;
+    case ::MeshPrimitive::tag::P_TriangleStrip:
+      obj["tag"] = "P_TriangleStrip";
+      break;
+    case ::MeshPrimitive::tag::P_Triangles:
+      obj["tag"] = "P_Triangles";
+      break;
+    case ::MeshPrimitive::tag::P_TriangleStripI:
+      obj["tag"] = "P_TriangleStripI";
+      {
+        std::shared_ptr<data::P_TriangleStripI> tv = std::static_pointer_cast<data::P_TriangleStripI>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+    case ::MeshPrimitive::tag::P_TrianglesI:
+      obj["tag"] = "P_TrianglesI";
+      {
+        std::shared_ptr<data::P_TrianglesI> tv = std::static_pointer_cast<data::P_TrianglesI>(v);
+        obj["arg0"] = toJSON(tv->_0);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<MeshPrimitive> fromJSON<std::shared_ptr<MeshPrimitive>>(W<std::shared_ptr<MeshPrimitive>> v, json &obj) {
+  enum ::MeshPrimitive::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "P_Points") {
+    tagType = ::MeshPrimitive::tag::P_Points;
+  }
+  else if (tag == "P_TriangleStrip") {
+    tagType = ::MeshPrimitive::tag::P_TriangleStrip;
+  }
+  else if (tag == "P_Triangles") {
+    tagType = ::MeshPrimitive::tag::P_Triangles;
+  }
+  else if (tag == "P_TriangleStripI") {
+    tagType = ::MeshPrimitive::tag::P_TriangleStripI;
+    std::shared_ptr<data::P_TriangleStripI> tv(new data::P_TriangleStripI());
+    tv->_0 = fromJSON(W<std::vector<Int32>>(), obj["arg0"]);
+    return tv;
+  }
+  else if (tag == "P_TrianglesI") {
+    tagType = ::MeshPrimitive::tag::P_TrianglesI;
+    std::shared_ptr<data::P_TrianglesI> tv(new data::P_TrianglesI());
+    tv->_0 = fromJSON(W<std::vector<Int32>>(), obj["arg0"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::MeshPrimitive> o(new ::MeshPrimitive());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<Mesh>>(std::shared_ptr<Mesh> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::Mesh::tag::Mesh:
+      obj["tag"] = "Mesh";
+      {
+        std::shared_ptr<data::Mesh> tv = std::static_pointer_cast<data::Mesh>(v);
+        obj["mAttributes"] = toJSON(tv->mAttributes);
+        obj["mPrimitive"] = toJSON(tv->mPrimitive);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<Mesh> fromJSON<std::shared_ptr<Mesh>>(W<std::shared_ptr<Mesh>> v, json &obj) {
+  enum ::Mesh::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "Mesh") {
+    tagType = ::Mesh::tag::Mesh;
+    std::shared_ptr<data::Mesh> tv(new data::Mesh());
+    tv->mAttributes = fromJSON(W<std::map<String, std::shared_ptr<::MeshAttribute>>>(), obj["mAttributes"]);
+    tv->mPrimitive = fromJSON(W<std::shared_ptr<::MeshPrimitive>>(), obj["mPrimitive"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::Mesh> o(new ::Mesh());
+  o->tag = tagType;
+  return o;
+}
+
diff --git a/ddl/out/Mesh.hpp b/ddl/out/Mesh.hpp
new file mode 100644
index 0000000..badf1da
--- /dev/null
+++ b/ddl/out/Mesh.hpp
@@ -0,0 +1,107 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.818584000000Z
+
+#ifndef HEADER_Mesh_H
+#define HEADER_Mesh_H
+
+#include "RT.hpp"
+
+
+class MeshAttribute {
+  public:
+    enum class tag { 
+      A_Float,
+      A_V2F,
+      A_V3F,
+      A_V4F,
+      A_M22F,
+      A_M33F,
+      A_M44F,
+      A_Int,
+      A_Word
+    } tag;
+};
+namespace data { 
+  class A_Float : public ::MeshAttribute {
+    public:
+      std::vector<Float> _0;
+      A_Float() { tag = tag::A_Float; }
+  };
+  class A_V2F : public ::MeshAttribute {
+    public:
+      std::vector<V2F> _0;
+      A_V2F() { tag = tag::A_V2F; }
+  };
+  class A_V3F : public ::MeshAttribute {
+    public:
+      std::vector<V3F> _0;
+      A_V3F() { tag = tag::A_V3F; }
+  };
+  class A_V4F : public ::MeshAttribute {
+    public:
+      std::vector<V4F> _0;
+      A_V4F() { tag = tag::A_V4F; }
+  };
+  class A_M22F : public ::MeshAttribute {
+    public:
+      std::vector<M22F> _0;
+      A_M22F() { tag = tag::A_M22F; }
+  };
+  class A_M33F : public ::MeshAttribute {
+    public:
+      std::vector<M33F> _0;
+      A_M33F() { tag = tag::A_M33F; }
+  };
+  class A_M44F : public ::MeshAttribute {
+    public:
+      std::vector<M44F> _0;
+      A_M44F() { tag = tag::A_M44F; }
+  };
+  class A_Int : public ::MeshAttribute {
+    public:
+      std::vector<Int32> _0;
+      A_Int() { tag = tag::A_Int; }
+  };
+  class A_Word : public ::MeshAttribute {
+    public:
+      std::vector<Word32> _0;
+      A_Word() { tag = tag::A_Word; }
+  };
+}
+class MeshPrimitive {
+  public:
+    enum class tag { 
+      P_Points,
+      P_TriangleStrip,
+      P_Triangles,
+      P_TriangleStripI,
+      P_TrianglesI
+    } tag;
+};
+namespace data { 
+  class P_TriangleStripI : public ::MeshPrimitive {
+    public:
+      std::vector<Int32> _0;
+      P_TriangleStripI() { tag = tag::P_TriangleStripI; }
+  };
+  class P_TrianglesI : public ::MeshPrimitive {
+    public:
+      std::vector<Int32> _0;
+      P_TrianglesI() { tag = tag::P_TrianglesI; }
+  };
+}
+class Mesh {
+  public:
+    enum class tag { 
+      Mesh
+    } tag;
+};
+namespace data { 
+  class Mesh : public ::Mesh {
+    public:
+      std::map<String, std::shared_ptr<::MeshAttribute>> mAttributes;
+      std::shared_ptr<::MeshPrimitive> mPrimitive;
+      Mesh() { tag = tag::Mesh; }
+  };
+}
+#endif
diff --git a/ddl/out/Mesh.hs b/ddl/out/Mesh.hs
new file mode 100644
index 0000000..13a6996
--- /dev/null
+++ b/ddl/out/Mesh.hs
@@ -0,0 +1,114 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.818584000000Z
+
+{-# LANGUAGE OverloadedStrings, RecordWildCards #-}
+module Mesh where
+
+import Data.Int
+import Data.Word
+import Data.Map
+import Data.Vector (Vector(..))
+import Linear
+
+import Data.Text
+import Data.Aeson hiding (Value,Bool)
+import Data.Aeson.Types hiding (Value,Bool)
+import Control.Monad
+
+
+data MeshAttribute
+  = A_Float (Vector Float)
+  | A_V2F (Vector V2F)
+  | A_V3F (Vector V3F)
+  | A_V4F (Vector V4F)
+  | A_M22F (Vector M22F)
+  | A_M33F (Vector M33F)
+  | A_M44F (Vector M44F)
+  | A_Int (Vector Int32)
+  | A_Word (Vector Word32)
+  deriving (Show, Eq, Ord)
+
+data MeshPrimitive
+  = P_Points
+  | P_TriangleStrip
+  | P_Triangles
+  | P_TriangleStripI (Vector Int32)
+  | P_TrianglesI (Vector Int32)
+  deriving (Show, Eq, Ord)
+
+data Mesh
+  = Mesh
+  { mAttributes :: Map String MeshAttribute
+  , mPrimitive :: MeshPrimitive
+  }
+
+  deriving (Show, Eq, Ord)
+
+
+instance ToJSON MeshAttribute where
+  toJSON v = case v of
+    A_Float arg0 -> object [ "tag" .= ("A_Float" :: Text), "arg0" .= arg0]
+    A_V2F arg0 -> object [ "tag" .= ("A_V2F" :: Text), "arg0" .= arg0]
+    A_V3F arg0 -> object [ "tag" .= ("A_V3F" :: Text), "arg0" .= arg0]
+    A_V4F arg0 -> object [ "tag" .= ("A_V4F" :: Text), "arg0" .= arg0]
+    A_M22F arg0 -> object [ "tag" .= ("A_M22F" :: Text), "arg0" .= arg0]
+    A_M33F arg0 -> object [ "tag" .= ("A_M33F" :: Text), "arg0" .= arg0]
+    A_M44F arg0 -> object [ "tag" .= ("A_M44F" :: Text), "arg0" .= arg0]
+    A_Int arg0 -> object [ "tag" .= ("A_Int" :: Text), "arg0" .= arg0]
+    A_Word arg0 -> object [ "tag" .= ("A_Word" :: Text), "arg0" .= arg0]
+
+instance FromJSON MeshAttribute where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "A_Float" -> A_Float <$> obj .: "arg0"
+      "A_V2F" -> A_V2F <$> obj .: "arg0"
+      "A_V3F" -> A_V3F <$> obj .: "arg0"
+      "A_V4F" -> A_V4F <$> obj .: "arg0"
+      "A_M22F" -> A_M22F <$> obj .: "arg0"
+      "A_M33F" -> A_M33F <$> obj .: "arg0"
+      "A_M44F" -> A_M44F <$> obj .: "arg0"
+      "A_Int" -> A_Int <$> obj .: "arg0"
+      "A_Word" -> A_Word <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON MeshPrimitive where
+  toJSON v = case v of
+    P_Points -> object [ "tag" .= ("P_Points" :: Text)]
+    P_TriangleStrip -> object [ "tag" .= ("P_TriangleStrip" :: Text)]
+    P_Triangles -> object [ "tag" .= ("P_Triangles" :: Text)]
+    P_TriangleStripI arg0 -> object [ "tag" .= ("P_TriangleStripI" :: Text), "arg0" .= arg0]
+    P_TrianglesI arg0 -> object [ "tag" .= ("P_TrianglesI" :: Text), "arg0" .= arg0]
+
+instance FromJSON MeshPrimitive where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "P_Points" -> pure P_Points
+      "P_TriangleStrip" -> pure P_TriangleStrip
+      "P_Triangles" -> pure P_Triangles
+      "P_TriangleStripI" -> P_TriangleStripI <$> obj .: "arg0"
+      "P_TrianglesI" -> P_TrianglesI <$> obj .: "arg0"
+  parseJSON _ = mzero
+
+instance ToJSON Mesh where
+  toJSON v = case v of
+    Mesh{..} -> object
+      [ "tag" .= ("Mesh" :: Text)
+      , "mAttributes" .= mAttributes
+      , "mPrimitive" .= mPrimitive
+      ]
+
+instance FromJSON Mesh where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "Mesh" -> do
+        mAttributes <- obj .: "mAttributes"
+        mPrimitive <- obj .: "mPrimitive"
+        pure $ Mesh
+          { mAttributes = mAttributes
+          , mPrimitive = mPrimitive
+          } 
+  parseJSON _ = mzero
+
diff --git a/ddl/out/Mesh.purs b/ddl/out/Mesh.purs
new file mode 100644
index 0000000..230c896
--- /dev/null
+++ b/ddl/out/Mesh.purs
@@ -0,0 +1,113 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.818584000000Z
+
+module Mesh where
+import Prelude
+import Data.Generic
+import Data.Maybe (Maybe(..))
+import Data.StrMap (StrMap(..))
+import Data.Map (Map(..))
+import Data.List (List(..))
+import Linear
+
+import Data.Argonaut.Combinators ((~>), (:=), (.?))
+import Data.Argonaut.Core (jsonEmptyObject)
+import Data.Argonaut.Printer (printJson)
+import Data.Argonaut.Encode (EncodeJson, encodeJson)
+import Data.Argonaut.Decode (DecodeJson, decodeJson)
+
+
+data MeshAttribute
+  = A_Float (Array Float)
+  | A_V2F (Array V2F)
+  | A_V3F (Array V3F)
+  | A_V4F (Array V4F)
+  | A_M22F (Array M22F)
+  | A_M33F (Array M33F)
+  | A_M44F (Array M44F)
+  | A_Int (Array Int32)
+  | A_Word (Array Word32)
+
+data MeshPrimitive
+  = P_Points
+  | P_TriangleStrip
+  | P_Triangles
+  | P_TriangleStripI (Array Int32)
+  | P_TrianglesI (Array Int32)
+
+data Mesh
+  = Mesh
+  { mAttributes :: StrMap MeshAttribute
+  , mPrimitive :: MeshPrimitive
+  }
+
+
+
+
+instance encodeJsonMeshAttribute :: EncodeJson MeshAttribute where
+  encodeJson v = case v of
+    A_Float arg0 -> "tag" := "A_Float" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_V2F arg0 -> "tag" := "A_V2F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_V3F arg0 -> "tag" := "A_V3F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_V4F arg0 -> "tag" := "A_V4F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_M22F arg0 -> "tag" := "A_M22F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_M33F arg0 -> "tag" := "A_M33F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_M44F arg0 -> "tag" := "A_M44F" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_Int arg0 -> "tag" := "A_Int" ~> "arg0" := arg0 ~> jsonEmptyObject
+    A_Word arg0 -> "tag" := "A_Word" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonMeshAttribute :: DecodeJson MeshAttribute where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "A_Float" -> A_Float <$> obj .? "arg0"
+      "A_V2F" -> A_V2F <$> obj .? "arg0"
+      "A_V3F" -> A_V3F <$> obj .? "arg0"
+      "A_V4F" -> A_V4F <$> obj .? "arg0"
+      "A_M22F" -> A_M22F <$> obj .? "arg0"
+      "A_M33F" -> A_M33F <$> obj .? "arg0"
+      "A_M44F" -> A_M44F <$> obj .? "arg0"
+      "A_Int" -> A_Int <$> obj .? "arg0"
+      "A_Word" -> A_Word <$> obj .? "arg0"
+
+instance encodeJsonMeshPrimitive :: EncodeJson MeshPrimitive where
+  encodeJson v = case v of
+    P_Points -> "tag" := "P_Points" ~> jsonEmptyObject
+    P_TriangleStrip -> "tag" := "P_TriangleStrip" ~> jsonEmptyObject
+    P_Triangles -> "tag" := "P_Triangles" ~> jsonEmptyObject
+    P_TriangleStripI arg0 -> "tag" := "P_TriangleStripI" ~> "arg0" := arg0 ~> jsonEmptyObject
+    P_TrianglesI arg0 -> "tag" := "P_TrianglesI" ~> "arg0" := arg0 ~> jsonEmptyObject
+
+instance decodeJsonMeshPrimitive :: DecodeJson MeshPrimitive where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "P_Points" -> pure P_Points
+      "P_TriangleStrip" -> pure P_TriangleStrip
+      "P_Triangles" -> pure P_Triangles
+      "P_TriangleStripI" -> P_TriangleStripI <$> obj .? "arg0"
+      "P_TrianglesI" -> P_TrianglesI <$> obj .? "arg0"
+
+instance encodeJsonMesh :: EncodeJson Mesh where
+  encodeJson v = case v of
+    Mesh r ->
+      "tag" := "Mesh" ~>
+      "mAttributes" := r.mAttributes ~>
+      "mPrimitive" := r.mPrimitive ~>
+      jsonEmptyObject
+
+instance decodeJsonMesh :: DecodeJson Mesh where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "Mesh" -> do
+        mAttributes <- obj .? "mAttributes"
+        mPrimitive <- obj .? "mPrimitive"
+        pure $ Mesh
+          { mAttributes:mAttributes
+          , mPrimitive:mPrimitive
+          } 
+
diff --git a/ddl/out/Mesh.swift b/ddl/out/Mesh.swift
new file mode 100644
index 0000000..df8ab88
--- /dev/null
+++ b/ddl/out/Mesh.swift
@@ -0,0 +1,174 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.818584000000Z
+
+enum MeshAttribute {
+  case A_Float(Array<Float>)
+  case A_V2F(Array<Int>)
+  case A_V3F(Array<Int>)
+  case A_V4F(Array<Int>)
+  case A_M22F(Array<Int>)
+  case A_M33F(Array<Int>)
+  case A_M44F(Array<Int>)
+  case A_Int(Array<Int32>)
+  case A_Word(Array<UInt32>)
+}
+
+enum MeshPrimitive {
+  case P_Points
+  case P_TriangleStrip
+  case P_Triangles
+  case P_TriangleStripI(Array<Int32>)
+  case P_TrianglesI(Array<Int32>)
+}
+
+enum Mesh {
+  case Mesh(Mesh_Data)
+    struct Mesh_Data {
+      var mAttributes : Dictionary<String, MeshAttribute>
+      var mPrimitive : MeshPrimitive
+    }
+}
+
+
+extension Int {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Int32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Float {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Bool {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension String {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Array {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Dictionary {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Maybe {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+
+
+
+extension MeshAttribute {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .A_Float(let arg0):
+        return [ "tag" : "A_Float", "arg0" : arg0.toJSON]
+      case .A_V2F(let arg0):
+        return [ "tag" : "A_V2F", "arg0" : arg0.toJSON]
+      case .A_V3F(let arg0):
+        return [ "tag" : "A_V3F", "arg0" : arg0.toJSON]
+      case .A_V4F(let arg0):
+        return [ "tag" : "A_V4F", "arg0" : arg0.toJSON]
+      case .A_M22F(let arg0):
+        return [ "tag" : "A_M22F", "arg0" : arg0.toJSON]
+      case .A_M33F(let arg0):
+        return [ "tag" : "A_M33F", "arg0" : arg0.toJSON]
+      case .A_M44F(let arg0):
+        return [ "tag" : "A_M44F", "arg0" : arg0.toJSON]
+      case .A_Int(let arg0):
+        return [ "tag" : "A_Int", "arg0" : arg0.toJSON]
+      case .A_Word(let arg0):
+        return [ "tag" : "A_Word", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension MeshPrimitive {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .P_Points:
+        return [ "tag" : "P_Points"]
+      case .P_TriangleStrip:
+        return [ "tag" : "P_TriangleStrip"]
+      case .P_Triangles:
+        return [ "tag" : "P_Triangles"]
+      case .P_TriangleStripI(let arg0):
+        return [ "tag" : "P_TriangleStripI", "arg0" : arg0.toJSON]
+      case .P_TrianglesI(let arg0):
+        return [ "tag" : "P_TrianglesI", "arg0" : arg0.toJSON]
+    }
+  }
+}
+extension Mesh {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .Mesh(let v):
+        return [ "tag" : "Mesh"
+               , "mAttributes" : v.mAttributes.toJSON
+               , "mPrimitive" : v.mPrimitive.toJSON
+               ]
+    }
+  }
+}
+
+enum Maybe<T> {
+  case Nothing
+  case Just(T)
+}
+
+enum Type {
+  case Int
+  case Int32
+  case Word
+  case Word32
+  case Float
+  case Bool
+  case String
+  case Array(Type)
+  case List(Type)
+  case Maybe(Type)
+  case Map(Type,Type)
+  case MeshAttribute
+  case MeshPrimitive
+  case Mesh
+}
+
+func fromJSON(type: Type, personName: String) -> Any {
+  switch type {
+    case .Int:    return 0
+    case .Int32:  return 0
+    case .Word:   return 0
+    case .Word32: return 0
+    case .Float:  return 0.0
+    case .Bool:   return false
+    case .String: return ""
+    case .Array(let a): return fromJSON(a,personName)
+    case .List(let a):  return fromJSON(a,personName)
+    case .Maybe(let a): return fromJSON(a,personName)
+  }
+  return 0;
+}
\ No newline at end of file
diff --git a/ddl/out/Mesh2.hpp b/ddl/out/Mesh2.hpp
new file mode 100644
index 0000000..aafa637
--- /dev/null
+++ b/ddl/out/Mesh2.hpp
@@ -0,0 +1,107 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.818584000000Z
+
+#ifndef HEADER_Mesh_H
+#define HEADER_Mesh_H
+
+#include "RT.hpp"
+
+
+namespace data { 
+  class A_Float {
+  public: 
+    std::vector<Float> _0;
+  };
+  class A_V2F {
+  public: 
+    std::vector<V2F> _0;
+  };
+  class A_V3F {
+  public: 
+    std::vector<V3F> _0;
+  };
+  class A_V4F {
+  public: 
+    std::vector<V4F> _0;
+  };
+  class A_M22F {
+  public: 
+    std::vector<M22F> _0;
+  };
+  class A_M33F {
+  public: 
+    std::vector<M33F> _0;
+  };
+  class A_M44F {
+  public: 
+    std::vector<M44F> _0;
+  };
+  class A_Int {
+  public: 
+    std::vector<Int32> _0;
+  };
+  class A_Word {
+  public: 
+    std::vector<Word32> _0;
+  };
+}
+class MeshAttribute {
+public:
+  enum class tag { 
+    A_Float,
+    A_V2F,
+    A_V3F,
+    A_V4F,
+    A_M22F,
+    A_M33F,
+    A_M44F,
+    A_Int,
+    A_Word
+  } tag;
+  std::shared_ptr<data::A_Float> A_Float;
+  std::shared_ptr<data::A_V2F> A_V2F;
+  std::shared_ptr<data::A_V3F> A_V3F;
+  std::shared_ptr<data::A_V4F> A_V4F;
+  std::shared_ptr<data::A_M22F> A_M22F;
+  std::shared_ptr<data::A_M33F> A_M33F;
+  std::shared_ptr<data::A_M44F> A_M44F;
+  std::shared_ptr<data::A_Int> A_Int;
+  std::shared_ptr<data::A_Word> A_Word;
+};
+namespace data { 
+  class P_TriangleStripI {
+  public: 
+    std::vector<Int32> _0;
+  };
+  class P_TrianglesI {
+  public: 
+    std::vector<Int32> _0;
+  };
+}
+class MeshPrimitive {
+public:
+  enum class tag { 
+    P_Points,
+    P_TriangleStrip,
+    P_Triangles,
+    P_TriangleStripI,
+    P_TrianglesI
+  } tag;
+  std::shared_ptr<data::P_TriangleStripI> P_TriangleStripI;
+  std::shared_ptr<data::P_TrianglesI> P_TrianglesI;
+};
+namespace data { 
+  class Mesh {
+  public: 
+    std::map<String, std::shared_ptr<::MeshAttribute>> mAttributes;
+    std::shared_ptr<::MeshPrimitive> mPrimitive;
+  };
+}
+class Mesh {
+public:
+  enum class tag { 
+    Mesh
+  } tag;
+  std::shared_ptr<data::Mesh> Mesh;
+};
+#endif
diff --git a/ddl/out/TypeInfo.cpp b/ddl/out/TypeInfo.cpp
new file mode 100644
index 0000000..abf93a5
--- /dev/null
+++ b/ddl/out/TypeInfo.cpp
@@ -0,0 +1,87 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.854088000000Z
+
+#include "TypeInfo.hpp"
+template<> json toJSON<std::shared_ptr<TypeInfo>>(std::shared_ptr<TypeInfo> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::TypeInfo::tag::TypeInfo:
+      obj["tag"] = "TypeInfo";
+      {
+        std::shared_ptr<data::TypeInfo> tv = std::static_pointer_cast<data::TypeInfo>(v);
+        obj["startLine"] = toJSON(tv->startLine);
+        obj["startColumn"] = toJSON(tv->startColumn);
+        obj["endLine"] = toJSON(tv->endLine);
+        obj["endColumn"] = toJSON(tv->endColumn);
+        obj["text"] = toJSON(tv->text);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<TypeInfo> fromJSON<std::shared_ptr<TypeInfo>>(W<std::shared_ptr<TypeInfo>> v, json &obj) {
+  enum ::TypeInfo::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "TypeInfo") {
+    tagType = ::TypeInfo::tag::TypeInfo;
+    std::shared_ptr<data::TypeInfo> tv(new data::TypeInfo());
+    tv->startLine = fromJSON(W<Int>(), obj["startLine"]);
+    tv->startColumn = fromJSON(W<Int>(), obj["startColumn"]);
+    tv->endLine = fromJSON(W<Int>(), obj["endLine"]);
+    tv->endColumn = fromJSON(W<Int>(), obj["endColumn"]);
+    tv->text = fromJSON(W<String>(), obj["text"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::TypeInfo> o(new ::TypeInfo());
+  o->tag = tagType;
+  return o;
+}
+
+template<> json toJSON<std::shared_ptr<MyEither>>(std::shared_ptr<MyEither> &v) {
+  json obj({});
+  switch (v->tag) { 
+    case ::MyEither::tag::MyLeft:
+      obj["tag"] = "MyLeft";
+      {
+        std::shared_ptr<data::MyLeft> tv = std::static_pointer_cast<data::MyLeft>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+    case ::MyEither::tag::MyRight:
+      obj["tag"] = "MyRight";
+      {
+        std::shared_ptr<data::MyRight> tv = std::static_pointer_cast<data::MyRight>(v);
+        obj["arg0"] = toJSON(tv->_0);
+        obj["arg1"] = toJSON(tv->_1);
+      }
+      break;
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<MyEither> fromJSON<std::shared_ptr<MyEither>>(W<std::shared_ptr<MyEither>> v, json &obj) {
+  enum ::MyEither::tag tagType;
+  std::string tag = obj["tag"];
+  if (tag == "MyLeft") {
+    tagType = ::MyEither::tag::MyLeft;
+    std::shared_ptr<data::MyLeft> tv(new data::MyLeft());
+    tv->_0 = fromJSON(W<std::shared_ptr<::TypeInfo>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::vector<std::shared_ptr<::TypeInfo>>>(), obj["arg1"]);
+    return tv;
+  }
+  else if (tag == "MyRight") {
+    tagType = ::MyEither::tag::MyRight;
+    std::shared_ptr<data::MyRight> tv(new data::MyRight());
+    tv->_0 = fromJSON(W<std::shared_ptr<::Pipeline>>(), obj["arg0"]);
+    tv->_1 = fromJSON(W<std::vector<std::shared_ptr<::TypeInfo>>>(), obj["arg1"]);
+    return tv;
+  }
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::MyEither> o(new ::MyEither());
+  o->tag = tagType;
+  return o;
+}
+
diff --git a/ddl/out/TypeInfo.hpp b/ddl/out/TypeInfo.hpp
new file mode 100644
index 0000000..afba764
--- /dev/null
+++ b/ddl/out/TypeInfo.hpp
@@ -0,0 +1,49 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.854088000000Z
+
+#ifndef HEADER_TypeInfo_H
+#define HEADER_TypeInfo_H
+
+#include "RT.hpp"
+
+#include "IR.hpp"
+
+class TypeInfo {
+  public:
+    enum class tag { 
+      TypeInfo
+    } tag;
+};
+namespace data { 
+  class TypeInfo : public ::TypeInfo {
+    public:
+      Int startLine;
+      Int startColumn;
+      Int endLine;
+      Int endColumn;
+      String text;
+      TypeInfo() { tag = tag::TypeInfo; }
+  };
+}
+class MyEither {
+  public:
+    enum class tag { 
+      MyLeft,
+      MyRight
+    } tag;
+};
+namespace data { 
+  class MyLeft : public ::MyEither {
+    public:
+      std::shared_ptr<::TypeInfo> _0;
+      std::vector<std::shared_ptr<::TypeInfo>> _1;
+      MyLeft() { tag = tag::MyLeft; }
+  };
+  class MyRight : public ::MyEither {
+    public:
+      std::shared_ptr<::Pipeline> _0;
+      std::vector<std::shared_ptr<::TypeInfo>> _1;
+      MyRight() { tag = tag::MyRight; }
+  };
+}
+#endif
diff --git a/ddl/out/TypeInfo.hs b/ddl/out/TypeInfo.hs
new file mode 100644
index 0000000..695315f
--- /dev/null
+++ b/ddl/out/TypeInfo.hs
@@ -0,0 +1,79 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.854088000000Z
+
+{-# LANGUAGE OverloadedStrings, RecordWildCards #-}
+module TypeInfo where
+
+import Data.Int
+import Data.Word
+import Data.Map
+import Data.Vector (Vector(..))
+import Linear
+
+import Data.Text
+import Data.Aeson hiding (Value,Bool)
+import Data.Aeson.Types hiding (Value,Bool)
+import Control.Monad
+
+import IR
+
+data TypeInfo
+  = TypeInfo
+  { startLine :: Int
+  , startColumn :: Int
+  , endLine :: Int
+  , endColumn :: Int
+  , text :: String
+  }
+
+  deriving (Show, Eq, Ord)
+
+data MyEither
+  = MyLeft TypeInfo (Vector TypeInfo)
+  | MyRight Pipeline (Vector TypeInfo)
+  deriving (Show, Eq, Ord)
+
+
+instance ToJSON TypeInfo where
+  toJSON v = case v of
+    TypeInfo{..} -> object
+      [ "tag" .= ("TypeInfo" :: Text)
+      , "startLine" .= startLine
+      , "startColumn" .= startColumn
+      , "endLine" .= endLine
+      , "endColumn" .= endColumn
+      , "text" .= text
+      ]
+
+instance FromJSON TypeInfo where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "TypeInfo" -> do
+        startLine <- obj .: "startLine"
+        startColumn <- obj .: "startColumn"
+        endLine <- obj .: "endLine"
+        endColumn <- obj .: "endColumn"
+        text <- obj .: "text"
+        pure $ TypeInfo
+          { startLine = startLine
+          , startColumn = startColumn
+          , endLine = endLine
+          , endColumn = endColumn
+          , text = text
+          } 
+  parseJSON _ = mzero
+
+instance ToJSON MyEither where
+  toJSON v = case v of
+    MyLeft arg0 arg1 -> object [ "tag" .= ("MyLeft" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+    MyRight arg0 arg1 -> object [ "tag" .= ("MyRight" :: Text), "arg0" .= arg0, "arg1" .= arg1]
+
+instance FromJSON MyEither where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of
+      "MyLeft" -> MyLeft <$> obj .: "arg0" <*> obj .: "arg1"
+      "MyRight" -> MyRight <$> obj .: "arg0" <*> obj .: "arg1"
+  parseJSON _ = mzero
+
diff --git a/ddl/out/TypeInfo.purs b/ddl/out/TypeInfo.purs
new file mode 100644
index 0000000..d2d8351
--- /dev/null
+++ b/ddl/out/TypeInfo.purs
@@ -0,0 +1,79 @@
+-- generated file, do not modify!
+-- 2015-12-21T12:00:19.854088000000Z
+
+module TypeInfo where
+import Prelude
+import Data.Generic
+import Data.Maybe (Maybe(..))
+import Data.StrMap (StrMap(..))
+import Data.Map (Map(..))
+import Data.List (List(..))
+import Linear
+
+import Data.Argonaut.Combinators ((~>), (:=), (.?))
+import Data.Argonaut.Core (jsonEmptyObject)
+import Data.Argonaut.Printer (printJson)
+import Data.Argonaut.Encode (EncodeJson, encodeJson)
+import Data.Argonaut.Decode (DecodeJson, decodeJson)
+
+import IR
+
+data TypeInfo
+  = TypeInfo
+  { startLine :: Int
+  , startColumn :: Int
+  , endLine :: Int
+  , endColumn :: Int
+  , text :: String
+  }
+
+
+data MyEither
+  = MyLeft TypeInfo (Array TypeInfo)
+  | MyRight Pipeline (Array TypeInfo)
+
+
+
+instance encodeJsonTypeInfo :: EncodeJson TypeInfo where
+  encodeJson v = case v of
+    TypeInfo r ->
+      "tag" := "TypeInfo" ~>
+      "startLine" := r.startLine ~>
+      "startColumn" := r.startColumn ~>
+      "endLine" := r.endLine ~>
+      "endColumn" := r.endColumn ~>
+      "text" := r.text ~>
+      jsonEmptyObject
+
+instance decodeJsonTypeInfo :: DecodeJson TypeInfo where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "TypeInfo" -> do
+        startLine <- obj .? "startLine"
+        startColumn <- obj .? "startColumn"
+        endLine <- obj .? "endLine"
+        endColumn <- obj .? "endColumn"
+        text <- obj .? "text"
+        pure $ TypeInfo
+          { startLine:startLine
+          , startColumn:startColumn
+          , endLine:endLine
+          , endColumn:endColumn
+          , text:text
+          } 
+
+instance encodeJsonMyEither :: EncodeJson MyEither where
+  encodeJson v = case v of
+    MyLeft arg0 arg1 -> "tag" := "MyLeft" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+    MyRight arg0 arg1 -> "tag" := "MyRight" ~> "arg0" := arg0 ~> "arg1" := arg1 ~> jsonEmptyObject
+
+instance decodeJsonMyEither :: DecodeJson MyEither where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of
+      "MyLeft" -> MyLeft <$> obj .? "arg0" <*> obj .? "arg1"
+      "MyRight" -> MyRight <$> obj .? "arg0" <*> obj .? "arg1"
+
diff --git a/ddl/out/TypeInfo.swift b/ddl/out/TypeInfo.swift
new file mode 100644
index 0000000..f05a343
--- /dev/null
+++ b/ddl/out/TypeInfo.swift
@@ -0,0 +1,134 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.854088000000Z
+
+enum TypeInfo {
+  case TypeInfo(TypeInfo_Data)
+    struct TypeInfo_Data {
+      var startLine : Int
+      var startColumn : Int
+      var endLine : Int
+      var endColumn : Int
+      var text : String
+    }
+}
+
+enum MyEither {
+  case MyLeft(TypeInfo,Array<TypeInfo>)
+  case MyRight(Pipeline,Array<TypeInfo>)
+}
+
+
+extension Int {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Int32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Float {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Bool {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension String {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Array {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Dictionary {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Maybe {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+
+
+
+extension TypeInfo {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .TypeInfo(let v):
+        return [ "tag" : "TypeInfo"
+               , "startLine" : v.startLine.toJSON
+               , "startColumn" : v.startColumn.toJSON
+               , "endLine" : v.endLine.toJSON
+               , "endColumn" : v.endColumn.toJSON
+               , "text" : v.text.toJSON
+               ]
+    }
+  }
+}
+extension MyEither {
+  var toJSON : [String: AnyObject] {
+    switch self {
+      case .MyLeft(let arg0, let arg1):
+        return [ "tag" : "MyLeft", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+      case .MyRight(let arg0, let arg1):
+        return [ "tag" : "MyRight", "arg0" : arg0.toJSON, "arg1" : arg1.toJSON]
+    }
+  }
+}
+
+enum Maybe<T> {
+  case Nothing
+  case Just(T)
+}
+
+enum Type {
+  case Int
+  case Int32
+  case Word
+  case Word32
+  case Float
+  case Bool
+  case String
+  case Array(Type)
+  case List(Type)
+  case Maybe(Type)
+  case Map(Type,Type)
+  case TypeInfo
+  case MyEither
+}
+
+func fromJSON(type: Type, personName: String) -> Any {
+  switch type {
+    case .Int:    return 0
+    case .Int32:  return 0
+    case .Word:   return 0
+    case .Word32: return 0
+    case .Float:  return 0.0
+    case .Bool:   return false
+    case .String: return ""
+    case .Array(let a): return fromJSON(a,personName)
+    case .List(let a):  return fromJSON(a,personName)
+    case .Maybe(let a): return fromJSON(a,personName)
+  }
+  return 0;
+}
\ No newline at end of file
diff --git a/ddl/out/TypeInfo2.hpp b/ddl/out/TypeInfo2.hpp
new file mode 100644
index 0000000..739db82
--- /dev/null
+++ b/ddl/out/TypeInfo2.hpp
@@ -0,0 +1,49 @@
+// generated file, do not modify!
+// 2015-12-21T12:00:19.854088000000Z
+
+#ifndef HEADER_TypeInfo_H
+#define HEADER_TypeInfo_H
+
+#include "RT.hpp"
+
+#include "IR.hpp"
+
+namespace data { 
+  class TypeInfo {
+  public: 
+    Int startLine;
+    Int startColumn;
+    Int endLine;
+    Int endColumn;
+    String text;
+  };
+}
+class TypeInfo {
+public:
+  enum class tag { 
+    TypeInfo
+  } tag;
+  std::shared_ptr<data::TypeInfo> TypeInfo;
+};
+namespace data { 
+  class MyLeft {
+  public: 
+    std::shared_ptr<::TypeInfo> _0;
+    std::vector<std::shared_ptr<::TypeInfo>> _1;
+  };
+  class MyRight {
+  public: 
+    std::shared_ptr<::Pipeline> _0;
+    std::vector<std::shared_ptr<::TypeInfo>> _1;
+  };
+}
+class MyEither {
+public:
+  enum class tag { 
+    MyLeft,
+    MyRight
+  } tag;
+  std::shared_ptr<data::MyLeft> MyLeft;
+  std::shared_ptr<data::MyRight> MyRight;
+};
+#endif
diff --git a/ddl/templates/data.cpp.ede b/ddl/templates/data.cpp.ede
new file mode 100644
index 0000000..39bf39d
--- /dev/null
+++ b/ddl/templates/data.cpp.ede
@@ -0,0 +1,41 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+#include "{{ moduleName }}.hpp"
+{% for t in definitions %}
+template<> json toJSON<std::shared_ptr<{{ t.value.dataName }}>>(std::shared_ptr<{{ t.value.dataName }}> &v) {
+  json obj({});
+  switch (v->tag) { {% for c in t.value.constructors %}
+    case ::{{ t.value.dataName }}::tag::{{ c.value.name }}:
+      obj["tag"] = "{{ c.value.name }}";{% if !(c.value.fields | empty) %}
+      {
+        std::shared_ptr<data::{{ c.value.name }}> tv = std::static_pointer_cast<data::{{ c.value.name }}>(v);{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+        obj["{{ f.value.fieldName }}"] = toJSON(tv->{{ f.value.fieldName }});{% else %}
+        obj["arg{{ f.index0 }}"] = toJSON(tv->_{{ f.index0 }});{% endif %}{% endfor %}
+      }{% endif %}
+      break;{% endfor %}
+  }
+  return obj;
+}
+
+template<> std::shared_ptr<{{ t.value.dataName }}> fromJSON<std::shared_ptr<{{ t.value.dataName }}>>(W<std::shared_ptr<{{ t.value.dataName }}>> v, json &obj) {
+  enum ::{{ t.value.dataName }}::tag tagType;
+  std::string tag = obj["tag"];
+  {% for c in t.value.constructors %}
+  {% if !c.first %}else {% endif %}if (tag == "{{ c.value.name }}") {
+    tagType = ::{{ t.value.dataName }}::tag::{{ c.value.name }};
+    {% if !(c.value.fields | empty) %}
+    std::shared_ptr<data::{{ c.value.name }}> tv(new data::{{ c.value.name }}());{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+    tv->{{ f.value.fieldName }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["{{ f.value.fieldName }}"]);{% else %}
+    tv->_{{ f.index0 }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["arg{{ f.index0 }}"]);{% endif %}{% endfor %}
+    return tv;
+    {% endif %}
+  }
+{% endfor %}
+  else throw "unknown constructor: " + tag;
+  std::shared_ptr<::{{ t.value.dataName }}> o(new ::{{ t.value.dataName }}());
+  o->tag = tagType;
+  return o;
+}
+
+{% endfor %}
diff --git a/ddl/templates/data.cs.ede b/ddl/templates/data.cs.ede
new file mode 100644
index 0000000..c88d41c
--- /dev/null
+++ b/ddl/templates/data.cs.ede
@@ -0,0 +1,27 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+using System.Collections.Generic;
+
+{% for m in imports %}
+using {{ m.value }};
+{% endfor %}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+class {{ t.value.dataName }} {
+    public enum Tag { {% for c in t.value.constructors %}
+      {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
+    };
+    public Tag tag;
+};
+
+namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
+  class {{ c.value.name }} : global::{{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+    public {{ f.value.fieldType | csType }} {{ f.value.fieldName }};{% else %}
+    public {{ f.value.fieldType | csType | parens }} _{{ f.index0 }};{% endif %}{% endfor %}
+  };{% endif %}{% endfor %}
+}
+{% endcase %}
+{% endfor %}
diff --git a/ddl/templates/data.hpp.ede b/ddl/templates/data.hpp.ede
new file mode 100644
index 0000000..dab478c
--- /dev/null
+++ b/ddl/templates/data.hpp.ede
@@ -0,0 +1,40 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+#ifndef HEADER_{{ moduleName }}_H
+#define HEADER_{{ moduleName }}_H
+
+#include "RT.hpp"
+
+{% for m in imports %}
+#include "{{ m.value }}.hpp"
+{% endfor %}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+class {{ t.value.dataName }} {
+  public:
+    enum class tag { {% for c in t.value.constructors %}
+      {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
+    } tag;
+};
+namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
+  class {{ c.value.name }} : public ::{{ t.value.dataName }} {
+    public:{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+      {{ f.value.fieldType | cppType }} {{ f.value.fieldName }};{% else %}
+      {{ f.value.fieldType | cppType | parens }} _{{ f.index0 }};{% endif %}{% endfor %}
+      {{ c.value.name }}() { tag = tag::{{ c.value.name }}; }
+  };{% endif %}{% endfor %}
+}
+{% when "TypeAlias" %}
+{% case t.value.aliasType.tag %}
+{% when "Data" %}
+typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }};
+{% else %}
+typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }};
+{% endcase %}
+
+{% endcase %}
+{% endfor %}
+#endif
diff --git a/ddl/templates/data.hpp2.ede b/ddl/templates/data.hpp2.ede
new file mode 100644
index 0000000..b28562d
--- /dev/null
+++ b/ddl/templates/data.hpp2.ede
@@ -0,0 +1,44 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+#ifndef HEADER_{{ moduleName }}_H
+#define HEADER_{{ moduleName }}_H
+
+#include "RT.hpp"
+
+{% for m in imports %}
+#include "{{ m.value }}.hpp"
+{% endfor %}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
+  class {{ c.value.name }} {
+  public: {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+    {{ f.value.fieldType | cppType }} {{ f.value.fieldName }};{% else %}
+    {{ f.value.fieldType | cppType | parens }} _{{ f.index0 }};{% endif %}{% endfor %}
+  };{% endif %}{% endfor %}
+}
+class {{ t.value.dataName }} {
+public:
+  enum class tag { {% for c in t.value.constructors %}
+    {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
+  } tag;
+  {% for c in t.value.constructors %}
+  {% if !(c.value.fields | empty) %}
+  std::shared_ptr<data::{{ c.value.name }}> {{ c.value.name }};
+  {% endif %}
+  {% endfor %}
+};
+{% when "TypeAlias" %}
+{% case t.value.aliasType.tag %}
+{% when "Data" %}
+typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }};
+{% else %}
+typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }};
+{% endcase %}
+
+{% endcase %}
+{% endfor %}
+#endif
diff --git a/ddl/templates/data.hs.ede b/ddl/templates/data.hs.ede
new file mode 100644
index 0000000..54a148b
--- /dev/null
+++ b/ddl/templates/data.hs.ede
@@ -0,0 +1,61 @@
+-- generated file, do not modify!
+-- {{ dateTime }}
+
+{-# LANGUAGE OverloadedStrings, RecordWildCards #-}
+module {{ moduleName }} where
+
+import Data.Int
+import Data.Word
+import Data.Map
+import Data.Vector (Vector(..))
+import Linear
+
+import Data.Text
+import Data.Aeson hiding (Value,Bool)
+import Data.Aeson.Types hiding (Value,Bool)
+import Control.Monad
+
+{% for m in imports %}
+import {{ m.value }}
+{% endfor %}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+data {{ t.value.dataName }}{% for c in t.value.constructors %}
+{% if c.value.fields | hasFieldNames %}
+  {% if c.first %}={% else %}|{% endif %} {{ c.value.name }}
+{% for f in c.value.fields %}{% if f.first %}  { {%else%}  , {%endif%}{{ f.value.fieldName }} :: {{ f.value.fieldType | hsType }}
+{% endfor %}
+  }
+{% else %}
+  {% if c.first %}={% else %}|{% endif %} {{ c.value.name }}{% for f in c.value.fields %} {{ f.value.fieldType | hsType | parens }}{% endfor %}{% endif %}{% endfor %}
+  deriving (Show, Eq, Ord)
+{% when "TypeAlias" %}
+type {{ t.value.aliasName }} = {{ t.value.aliasType | hsType }}
+{% endcase %}
+
+{% endfor %}
+
+{% for t in definitions %}
+instance ToJSON {{ t.value.dataName }} where
+  toJSON v = case v of{% for c in t.value.constructors %}{% if c.value.fields | hasFieldNames %}
+    {{ c.value.name }}{..} -> object
+      [ "tag" .= ("{{ c.value.name }}" :: Text){% for f in c.value.fields %}
+      , "{{ f.value.fieldName }}" .= {{ f.value.fieldName }}{% endfor %}
+      ]{% else %}
+    {{ c.value.name }}{% for f in c.value.fields %} arg{{ f.index0 }}{% endfor %} -> object [ "tag" .= ("{{ c.value.name }}" :: Text){% for f in c.value.fields %}, "arg{{ f.index0 }}" .= arg{{ f.index0 }}{% endfor %}]{% endif %}{% endfor %}
+
+instance FromJSON {{ t.value.dataName }} where
+  parseJSON (Object obj) = do
+    tag <- obj .: "tag"
+    case tag :: Text of{% for c in t.value.constructors %}{% if c.value.fields | hasFieldNames %}
+      "{{ c.value.name }}" -> do{% for f in c.value.fields %}
+        {{ f.value.fieldName }} <- obj .: "{{ f.value.fieldName }}"{% endfor %}
+        pure $ {{ c.value.name }}{% for f in c.value.fields %}
+          {% if f.first %}{ {% else %}, {%endif%}{{ f.value.fieldName }} = {{ f.value.fieldName }}{% endfor %}
+          } {% else %}
+      "{{ c.value.name }}" -> {% for f in c.value.fields %}{% if f.first %}{{ c.value.name }} <$>{% else %} <*>{% endif %} obj .: "arg{{ f.index0 }}"{%else%}pure {{ c.value.name }}{% endfor %}{% endif %}{% endfor %}
+  parseJSON _ = mzero
+
+{% endfor %}
\ No newline at end of file
diff --git a/ddl/templates/data.java.ede b/ddl/templates/data.java.ede
new file mode 100644
index 0000000..c85a521
--- /dev/null
+++ b/ddl/templates/data.java.ede
@@ -0,0 +1,26 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+{% for m in imports %}
+import {{ m.value }};
+{% endfor %}
+
+public class {{ moduleName }} {
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+  public class {{ t.value.dataName }} {
+    public enum Tag { {% for c in t.value.constructors %}
+      {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
+    }
+    public Tag tag;
+{% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
+    public class {{ c.value.name }}_ extends {{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+      public {{ f.value.fieldType | javaType }} {{ f.value.fieldName }};{% else %}
+      public {{ f.value.fieldType | javaType }} _{{ f.index0 }};{% endif %}{% endfor %}
+    }{% endif %}{% endfor %}
+  }
+
+{% endcase %}
+{% endfor %}
+}
\ No newline at end of file
diff --git a/ddl/templates/data.purs.ede b/ddl/templates/data.purs.ede
new file mode 100644
index 0000000..0474931
--- /dev/null
+++ b/ddl/templates/data.purs.ede
@@ -0,0 +1,68 @@
+-- generated file, do not modify!
+-- {{ dateTime }}
+
+module {{ moduleName }} where
+import Prelude
+import Data.Generic
+import Data.Maybe (Maybe(..))
+import Data.StrMap (StrMap(..))
+import Data.Map (Map(..))
+import Data.List (List(..))
+import Linear
+
+import Data.Argonaut.Combinators ((~>), (:=), (.?))
+import Data.Argonaut.Core (jsonEmptyObject)
+import Data.Argonaut.Printer (printJson)
+import Data.Argonaut.Encode (EncodeJson, encodeJson)
+import Data.Argonaut.Decode (DecodeJson, decodeJson)
+
+{% for m in imports %}
+import {{ m.value }}
+{% endfor %}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+data {{ t.value.dataName }}{% for c in t.value.constructors %}
+{% if c.value.fields | hasFieldNames %}
+  {% if c.first %}={% else %}|{% endif %} {{ c.value.name }}
+{% for f in c.value.fields %}{% if f.first %}  { {%else%}  , {%endif%}{{ f.value.fieldName }} :: {{ f.value.fieldType | psType }}
+{% endfor %}
+  }
+{% else %}
+  {% if c.first %}={% else %}|{% endif %} {{ c.value.name }}{% for f in c.value.fields %} {{ f.value.fieldType | psType | parens }}{% endfor %}{% endif %}{% endfor %}
+
+{% when "TypeAlias" %}
+type {{ t.value.aliasName }} = {{ t.value.aliasType | psType }}
+
+{% endcase %}
+{% endfor %}
+{% for t in definitions %}{% let l = t.value.instances | length %}{% if l > 0 %}{# FIXME!!! #}
+derive instance generic{{ t.value.dataName }} :: Generic {{ t.value.dataName }}
+instance show{{ t.value.dataName }} :: Show {{ t.value.dataName }} where show = gShow
+instance eq{{ t.value.dataName }}   :: Eq {{ t.value.dataName }}   where eq = gEq
+{% endif %}{% endlet %}{% endfor %}
+
+{# JSON Encode and Decode #}
+{% for t in definitions %}
+instance encodeJson{{ t.value.dataName }} :: EncodeJson {{ t.value.dataName }} where
+  encodeJson v = case v of{% for c in t.value.constructors %}{% if c.value.fields | hasFieldNames %}
+    {{ c.value.name }} r ->
+      "tag" := "{{ c.value.name }}" ~>{% for f in c.value.fields %}
+      "{{ f.value.fieldName }}" := r.{{ f.value.fieldName }} ~>{% endfor %}
+      jsonEmptyObject{% else %}
+    {{ c.value.name }}{% for f in c.value.fields %} arg{{ f.index0 }}{% endfor %} -> "tag" := "{{ c.value.name }}"{% for f in c.value.fields %} ~> "arg{{ f.index0 }}" := arg{{ f.index0 }}{% endfor %} ~> jsonEmptyObject{% endif %}{% endfor %}
+
+instance decodeJson{{ t.value.dataName }} :: DecodeJson {{ t.value.dataName }} where
+  decodeJson json = do
+    obj <- decodeJson json
+    tag <- obj .? "tag"
+    case tag of{% for c in t.value.constructors %}{% if c.value.fields | hasFieldNames %}
+      "{{ c.value.name }}" -> do{% for f in c.value.fields %}
+        {{ f.value.fieldName }} <- obj .? "{{ f.value.fieldName }}"{% endfor %}
+        pure $ {{ c.value.name }}{% for f in c.value.fields %}
+          {% if f.first %}{ {% else %}, {%endif%}{{ f.value.fieldName }}:{{ f.value.fieldName }}{% endfor %}
+          } {% else %}
+      "{{ c.value.name }}" -> {% for f in c.value.fields %}{% if f.first %}{{ c.value.name }} <$>{% else %} <*>{% endif %} obj .? "arg{{ f.index0 }}"{%else%}pure {{ c.value.name }}{% endfor %}{% endif %}{% endfor %}
+
+{% endfor %}
\ No newline at end of file
diff --git a/ddl/templates/data.swift.ede b/ddl/templates/data.swift.ede
new file mode 100644
index 0000000..f2a9039
--- /dev/null
+++ b/ddl/templates/data.swift.ede
@@ -0,0 +1,141 @@
+// generated file, do not modify!
+// {{ dateTime }}
+
+{% for t in dataAndType %}
+{% case t.value | constType %}
+{% when "DataDef" %}
+enum {{ t.value.dataName }} {
+{% for c in t.value.constructors %}
+{% if c.value.fields | hasFieldNames %}
+  case {{ c.value.name }}({{ c.value.name }}_Data)
+    struct {{ c.value.name }}_Data {
+{% for f in c.value.fields %}
+      var {{ f.value.fieldName }} : {{ f.value.fieldType | swiftType }}
+{% endfor %}
+    }
+{% else %}
+  case {{ c.value.name }}{% if !(c.value.fields | empty) %}({% for f in c.value.fields %}{{ f.value.fieldType | swiftType }}{% if !f.last %},{% endif %}{% endfor %}){% endif %}
+{% endif %}
+{% endfor %}
+}
+{% when "TypeAlias" %}
+typealias {{ t.value.aliasName }} = {{ t.value.aliasType | swiftType }}
+{% endcase %}
+
+{% endfor %}
+{#
+protocol ToJSON {
+    func toJSON(item: ItemType) -> [String: AnyObject]
+}
+#}
+
+extension Int {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Int32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension UInt32 {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Float {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Bool {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension String {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Array {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Dictionary {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+extension Maybe {
+    var toJSON : [String: AnyObject] {
+        return ["":""]
+    }
+}
+
+
+
+{% for t in definitions %}
+extension {{ t.value.dataName }} {
+  var toJSON : [String: AnyObject] {
+    switch self {
+{% for c in t.value.constructors %}
+{% if c.value.fields | hasFieldNames %}
+      case .{{ c.value.name }}(let v):
+        return [ "tag" : "{{ c.value.name }}"{% for f in c.value.fields %}
+               , "{{ f.value.fieldName }}" : v.{{ f.value.fieldName }}.toJSON{% endfor %}
+               ]
+{% else %}
+      case .{{ c.value.name }}{% if !(c.value.fields | empty) %}({% for f in c.value.fields %}let arg{{ f.index0 }}{% if !f.last %}, {% endif %}{% endfor %}){% endif %}:
+        return [ "tag" : "{{ c.value.name }}"{% for f in c.value.fields %}, "arg{{ f.index0 }}" : arg{{ f.index0 }}.toJSON{% endfor %}]
+{% endif %}
+{% endfor %}
+    }
+  }
+}
+{% endfor %}
+
+enum Maybe<T> {
+  case Nothing
+  case Just(T)
+}
+
+enum Type {
+  case Int
+  case Int32
+  case Word
+  case Word32
+  case Float
+  case Bool
+  case String
+  case Array(Type)
+  case List(Type)
+  case Maybe(Type)
+  case Map(Type,Type)
+{% for t in definitions %}
+  case {{ t.value.dataName }}
+{% endfor %}
+}
+
+func fromJSON(type: Type, personName: String) -> Any {
+  switch type {
+    case .Int:    return 0
+    case .Int32:  return 0
+    case .Word:   return 0
+    case .Word32: return 0
+    case .Float:  return 0.0
+    case .Bool:   return false
+    case .String: return ""
+    case .Array(let a): return fromJSON(a,personName)
+    case .List(let a):  return fromJSON(a,personName)
+    case .Maybe(let a): return fromJSON(a,personName)
+  }
+  return 0;
+}
\ No newline at end of file
diff --git a/ddl/test/idCpp.cpp b/ddl/test/idCpp.cpp
new file mode 100644
index 0000000..24894f4
--- /dev/null
+++ b/ddl/test/idCpp.cpp
@@ -0,0 +1,31 @@
+#include <string>
+#include <iostream>
+#include <istream>
+#include <ostream>
+#include <iterator>
+
+#include "Mesh.hpp"
+#include "IR.hpp"
+#include "TypeInfo.hpp"
+
+int main() {
+  // don't skip the whitespace while reading
+  std::cin >> std::noskipws;
+
+  // use stream iterators to copy the stream to a string
+  std::istream_iterator<char> it(std::cin);
+  std::istream_iterator<char> end;
+  std::string results(it, end);
+
+  try {
+    json jobjIn = json::parse(results);
+    std::shared_ptr<Pipeline> b = fromJSON(W<std::shared_ptr<Pipeline>>(),jobjIn);
+    std::shared_ptr<data::Pipeline> tv = std::static_pointer_cast<data::Pipeline>(b);
+    json jobjOut = toJSON(b);
+    std::cout << jobjOut;
+  } catch (std::string e) {
+    std::cout << "exception: " << e << "\n";
+  } catch (...) { std::cout << "default exception\n"; }
+
+  return 0;
+}
diff --git a/ddl/test/idHs.hs b/ddl/test/idHs.hs
new file mode 100644
index 0000000..7cd9917
--- /dev/null
+++ b/ddl/test/idHs.hs
@@ -0,0 +1,8 @@
+{-# LANGUAGE ScopedTypeVariables  #-}
+import qualified Data.ByteString.Lazy as B
+import Data.Aeson
+import IR
+
+main = do
+  Just (p :: Pipeline) <- decode <$> B.getContents
+  B.putStr $ encode p