diff --git a/.gitignore b/.gitignore
index 5463f727..e80058f6 100755
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@ _esy
 .merlin
 node_modules
 _build
+_opam
 _release
 *.byte
 *.native
diff --git a/snapshot_tests/operations/expected/apollo/generate/ewert_reproduction.res.txt b/snapshot_tests/operations/expected/apollo/generate/ewert_reproduction.res.txt
index b2c3b0c0..702d449b 100644
--- a/snapshot_tests/operations/expected/apollo/generate/ewert_reproduction.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/ewert_reproduction.res.txt
@@ -49,60 +49,56 @@ lastname
 
 }
 "
-  let parse = (
-    (value): t => {
-      user: {
-        let value = (value: Raw.t).user
-        (
-          {
-            id: {
-              let value = (value: Raw.t_user).id
-              value
-            },
-            firstname: {
-              let value = (value: Raw.t_user).firstname
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            },
-            lastname: {
-              let value = (value: Raw.t_user).lastname
-              value
-            },
-          }: t_user
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let user = {
-        let value = (value: t).user
-        (
-          {
-            let lastname = {
-              let value = (value: t_user).lastname
-              value
+  let parse = (value): t => {
+    user: {
+      let value = (value: Raw.t).user
+      (
+        {
+          id: {
+            let value = (value: Raw.t_user).id
+            value
+          },
+          firstname: {
+            let value = (value: Raw.t_user).firstname
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
             }
-            and firstname = {
-              let value = (value: t_user).firstname
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            }
-            and id = {
-              let value = (value: t_user).id
-              value
+          },
+          lastname: {
+            let value = (value: Raw.t_user).lastname
+            value
+          },
+        }: t_user
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let user = {
+      let value = (value: t).user
+      (
+        {
+          let lastname = {
+            let value = (value: t_user).lastname
+            value
+          }
+          and firstname = {
+            let value = (value: t_user).firstname
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
             }
-            {id, firstname, lastname}
-          }: Raw.t_user
-        )
-      }
-      {user: user}
-    }: t => Raw.t
-  )
+          }
+          and id = {
+            let value = (value: t_user).id
+            value
+          }
+          {id, firstname, lastname}
+        }: Raw.t_user
+      )
+    }
+    {user: user}
+  }
   let verifyArgsAndParse = (
     ~userId as _userId: [#NonNull_String],
     ~fragmentName as _UserData: [#UserData],
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentDefinition.res.txt
index 28334959..55164be0 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentDefinition.res.txt
@@ -45,59 +45,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -136,29 +132,25 @@ function back to the original JSON-compatible data ")
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNonNullable: nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNonNullable: nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
@@ -196,45 +188,41 @@ function back to the original JSON-compatible data ")
 listWithArg(arg1: $arg1)  
 }
 "
-  let parse = (
-    (value): t => {
-      listWithArg: {
-        let value = (value: Raw.t).listWithArg
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let listWithArg = {
-        let value = (value: t).listWithArg
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    listWithArg: {
+      let value = (value: Raw.t).listWithArg
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {listWithArg: listWithArg}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let listWithArg = {
+      let value = (value: t).listWithArg
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {listWithArg: listWithArg}
+  }
   let verifyArgsAndParse = (
     ~arg1 as _arg1: [#String],
     ~fragmentName as _FragmentWithArgs: [#FragmentWithArgs],
@@ -266,59 +254,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
@@ -349,59 +333,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentInFragment.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentInFragment.res.txt
index 4f47c025..c0c4d0c5 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentInFragment.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentInFragment.res.txt
@@ -32,45 +32,41 @@ function back to the original JSON-compatible data ")
 nullableOfNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {nullableOfNullable: nullableOfNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable: nullableOfNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -119,59 +115,55 @@ nullableOfNullable
 ",
     ListFragment.query,
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      listFragment: {
-        let value = (Obj.magic(value): ListFragment.Raw.t)
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
+      }
+    },
+    listFragment: {
+      let value = (Obj.magic(value): ListFragment.Raw.t)
 
-        ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let nullableOfNullable = {
-                let value = (value: t).nullableOfNullable
-                switch value {
-                | Some(value) =>
-                  Js.Nullable.return(
-                    Js.Array2.map(value, value =>
-                      switch value {
-                      | Some(value) => Js.Nullable.return(value)
-                      | None => Js.Nullable.null
-                      }
-                    ),
-                  )
-                | None => Js.Nullable.null
-                }
+      ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let nullableOfNullable = {
+              let value = (value: t).nullableOfNullable
+              switch value {
+              | Some(value) =>
+                Js.Nullable.return(
+                  Js.Array2.map(value, value =>
+                    switch value {
+                    | Some(value) => Js.Nullable.return(value)
+                    | None => Js.Nullable.null
+                    }
+                  ),
+                )
+              | None => Js.Nullable.null
               }
-              {"nullableOfNullable": nullableOfNullable}
-            }): Js.Json.t
-          ),
+            }
+            {"nullableOfNullable": nullableOfNullable}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentOnInterface.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentOnInterface.res.txt
index 3be22af6..dcedda2f 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentOnInterface.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentOnInterface.res.txt
@@ -45,23 +45,19 @@ __typename
 id  
 }
 "
-  let parse = (
-    (value): t => {
-      id: {
-        let value = (value: Raw.t).id
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let id = {
-        let value = (value: t).id
-        value
-      }
-      {id: id}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    id: {
+      let value = (value: Raw.t).id
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let id = {
+      let value = (value: t).id
+      value
+    }
+    {id: id}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InterfaceFragment: [#InterfaceFragment],
     value: Raw.t,
@@ -119,37 +115,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnotherFragment: [#AnotherFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -192,37 +184,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnonUser: [#AnonUser], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #AnonUser => ()
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentUnion.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentUnion.res.txt
index e8057703..e833e440 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentUnion.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentUnion.res.txt
@@ -37,23 +37,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -92,23 +88,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _HumanFragment: [#HumanFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentWithdifferentReturnType.res.txt
index e379a226..c755e269 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentWithdifferentReturnType.res.txt
@@ -41,59 +41,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/apollo/generate/fragmentvariableinput.res.txt b/snapshot_tests/operations/expected/apollo/generate/fragmentvariableinput.res.txt
index 2ed62e81..8a9970fd 100644
--- a/snapshot_tests/operations/expected/apollo/generate/fragmentvariableinput.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/fragmentvariableinput.res.txt
@@ -35,54 +35,50 @@ id
 
 }
 "
-  let parse = (
-    (value): t => {
-      reposts: {
-        let value = (value: Raw.t).reposts
-        Js.Array2.map(value, value =>
-          switch Js.toOption(value) {
-          | Some(value) =>
-            Some(
-              (
-                {
-                  id: {
-                    let value = (value: Raw.t_reposts).id
-                    value
-                  },
-                }: t_reposts
-              ),
-            )
-          | None => None
-          }
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let reposts = {
-        let value = (value: t).reposts
-        Js.Array2.map(value, value =>
-          switch value {
-          | Some(value) =>
-            Js.Nullable.return(
-              (
-                {
-                  let id = {
-                    let value = (value: t_reposts).id
-                    value
-                  }
-                  {id: id}
-                }: Raw.t_reposts
-              ),
-            )
-          | None => Js.Nullable.null
-          }
-        )
-      }
-      {reposts: reposts}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    reposts: {
+      let value = (value: Raw.t).reposts
+      Js.Array2.map(value, value =>
+        switch Js.toOption(value) {
+        | Some(value) =>
+          Some(
+            (
+              {
+                id: {
+                  let value = (value: Raw.t_reposts).id
+                  value
+                },
+              }: t_reposts
+            ),
+          )
+        | None => None
+        }
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let reposts = {
+      let value = (value: t).reposts
+      Js.Array2.map(value, value =>
+        switch value {
+        | Some(value) =>
+          Js.Nullable.return(
+            (
+              {
+                let id = {
+                  let value = (value: t_reposts).id
+                  value
+                }
+                {id: id}
+              }: Raw.t_reposts
+            ),
+          )
+        | None => Js.Nullable.null
+        }
+      )
+    }
+    {reposts: reposts}
+  }
   let verifyArgsAndParse = (
     ~name as _name: [#NonNull_String],
     ~fragmentName as _test: [#test],
diff --git a/snapshot_tests/operations/expected/apollo/generate/hasuraRepro.res.txt b/snapshot_tests/operations/expected/apollo/generate/hasuraRepro.res.txt
index 3ac6e8c0..dd070aaa 100644
--- a/snapshot_tests/operations/expected/apollo/generate/hasuraRepro.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/hasuraRepro.res.txt
@@ -28,23 +28,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _Dog: [#Dog], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Dog => ()
diff --git a/snapshot_tests/operations/expected/apollo/generate/record.res.txt b/snapshot_tests/operations/expected/apollo/generate/record.res.txt
index f8b76a95..c11046fe 100644
--- a/snapshot_tests/operations/expected/apollo/generate/record.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/record.res.txt
@@ -333,31 +333,27 @@ string
 int  
 }
 "
-    let parse = (
-      (value): t => {
-        string: {
-          let value = (value: Raw.t).string
-          value
-        },
-        int: {
-          let value = (value: Raw.t).int
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let int = {
-          let value = (value: t).int
-          value
-        }
-        and string = {
-          let value = (value: t).string
-          value
-        }
-        {string, int}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      string: {
+        let value = (value: Raw.t).string
+        value
+      },
+      int: {
+        let value = (value: Raw.t).int
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let int = {
+        let value = (value: t).int
+        value
+      }
+      and string = {
+        let value = (value: t).string
+        value
+      }
+      {string, int}
+    }
     let verifyArgsAndParse = (~fragmentName as _Fragment: [#Fragment], value: Raw.t) => parse(value)
     let verifyName = x => switch x {
     | #Fragment => ()
@@ -600,39 +596,35 @@ name
 barkVolume  
 }
 "
-    let parse = (
-      (value): t => {
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        barkVolume: {
-          let value = (value: Raw.t).barkVolume
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let barkVolume = {
-          let value = (value: t).barkVolume
-          value
-        }
-        and name = {
-          let value = (value: t).name
-          value
-        }
-        and __typename = {
-          let value = (value: t).__typename
-          value
-        }
-        {__typename, name, barkVolume}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      barkVolume: {
+        let value = (value: Raw.t).barkVolume
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let barkVolume = {
+        let value = (value: t).barkVolume
+        value
+      }
+      and name = {
+        let value = (value: t).name
+        value
+      }
+      and __typename = {
+        let value = (value: t).__typename
+        value
+      }
+      {__typename, name, barkVolume}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/apollo/generate/tagged_template.res.txt b/snapshot_tests/operations/expected/apollo/generate/tagged_template.res.txt
index 6c3dd713..0aa5f74c 100644
--- a/snapshot_tests/operations/expected/apollo/generate/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/tagged_template.res.txt
@@ -1545,59 +1545,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -1847,59 +1843,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment8: [#ListFragment8], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/apollo/generate/union.res.txt b/snapshot_tests/operations/expected/apollo/generate/union.res.txt
index b01f6a3c..16612a7a 100644
--- a/snapshot_tests/operations/expected/apollo/generate/union.res.txt
+++ b/snapshot_tests/operations/expected/apollo/generate/union.res.txt
@@ -541,31 +541,27 @@ name
 __typename  
 }
 "
-    let parse = (
-      (value): named => {
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-      }: Raw.t => named
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let __typename = {
-          let value = (value: named).__typename
-          value
-        }
-        and name = {
-          let value = (value: named).name
-          value
-        }
-        {name, __typename}
-      }: named => Raw.t
-    )
+    let parse = (value): named => {
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let __typename = {
+        let value = (value: named).__typename
+        value
+      }
+      and name = {
+        let value = (value: named).name
+        value
+      }
+      {name, __typename}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFields: [#DogFields], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/native/generate/ewert_reproduction.res.txt b/snapshot_tests/operations/expected/native/generate/ewert_reproduction.res.txt
index b2c3b0c0..702d449b 100644
--- a/snapshot_tests/operations/expected/native/generate/ewert_reproduction.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/ewert_reproduction.res.txt
@@ -49,60 +49,56 @@ lastname
 
 }
 "
-  let parse = (
-    (value): t => {
-      user: {
-        let value = (value: Raw.t).user
-        (
-          {
-            id: {
-              let value = (value: Raw.t_user).id
-              value
-            },
-            firstname: {
-              let value = (value: Raw.t_user).firstname
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            },
-            lastname: {
-              let value = (value: Raw.t_user).lastname
-              value
-            },
-          }: t_user
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let user = {
-        let value = (value: t).user
-        (
-          {
-            let lastname = {
-              let value = (value: t_user).lastname
-              value
+  let parse = (value): t => {
+    user: {
+      let value = (value: Raw.t).user
+      (
+        {
+          id: {
+            let value = (value: Raw.t_user).id
+            value
+          },
+          firstname: {
+            let value = (value: Raw.t_user).firstname
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
             }
-            and firstname = {
-              let value = (value: t_user).firstname
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            }
-            and id = {
-              let value = (value: t_user).id
-              value
+          },
+          lastname: {
+            let value = (value: Raw.t_user).lastname
+            value
+          },
+        }: t_user
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let user = {
+      let value = (value: t).user
+      (
+        {
+          let lastname = {
+            let value = (value: t_user).lastname
+            value
+          }
+          and firstname = {
+            let value = (value: t_user).firstname
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
             }
-            {id, firstname, lastname}
-          }: Raw.t_user
-        )
-      }
-      {user: user}
-    }: t => Raw.t
-  )
+          }
+          and id = {
+            let value = (value: t_user).id
+            value
+          }
+          {id, firstname, lastname}
+        }: Raw.t_user
+      )
+    }
+    {user: user}
+  }
   let verifyArgsAndParse = (
     ~userId as _userId: [#NonNull_String],
     ~fragmentName as _UserData: [#UserData],
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentDefinition.res.txt
index 28334959..55164be0 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentDefinition.res.txt
@@ -45,59 +45,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -136,29 +132,25 @@ function back to the original JSON-compatible data ")
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNonNullable: nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNonNullable: nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
@@ -196,45 +188,41 @@ function back to the original JSON-compatible data ")
 listWithArg(arg1: $arg1)  
 }
 "
-  let parse = (
-    (value): t => {
-      listWithArg: {
-        let value = (value: Raw.t).listWithArg
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let listWithArg = {
-        let value = (value: t).listWithArg
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    listWithArg: {
+      let value = (value: Raw.t).listWithArg
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {listWithArg: listWithArg}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let listWithArg = {
+      let value = (value: t).listWithArg
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {listWithArg: listWithArg}
+  }
   let verifyArgsAndParse = (
     ~arg1 as _arg1: [#String],
     ~fragmentName as _FragmentWithArgs: [#FragmentWithArgs],
@@ -266,59 +254,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
@@ -349,59 +333,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentInFragment.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentInFragment.res.txt
index 4f47c025..c0c4d0c5 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentInFragment.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentInFragment.res.txt
@@ -32,45 +32,41 @@ function back to the original JSON-compatible data ")
 nullableOfNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {nullableOfNullable: nullableOfNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable: nullableOfNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -119,59 +115,55 @@ nullableOfNullable
 ",
     ListFragment.query,
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      listFragment: {
-        let value = (Obj.magic(value): ListFragment.Raw.t)
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
+      }
+    },
+    listFragment: {
+      let value = (Obj.magic(value): ListFragment.Raw.t)
 
-        ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let nullableOfNullable = {
-                let value = (value: t).nullableOfNullable
-                switch value {
-                | Some(value) =>
-                  Js.Nullable.return(
-                    Js.Array2.map(value, value =>
-                      switch value {
-                      | Some(value) => Js.Nullable.return(value)
-                      | None => Js.Nullable.null
-                      }
-                    ),
-                  )
-                | None => Js.Nullable.null
-                }
+      ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let nullableOfNullable = {
+              let value = (value: t).nullableOfNullable
+              switch value {
+              | Some(value) =>
+                Js.Nullable.return(
+                  Js.Array2.map(value, value =>
+                    switch value {
+                    | Some(value) => Js.Nullable.return(value)
+                    | None => Js.Nullable.null
+                    }
+                  ),
+                )
+              | None => Js.Nullable.null
               }
-              {"nullableOfNullable": nullableOfNullable}
-            }): Js.Json.t
-          ),
+            }
+            {"nullableOfNullable": nullableOfNullable}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentOnInterface.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentOnInterface.res.txt
index 3be22af6..dcedda2f 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentOnInterface.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentOnInterface.res.txt
@@ -45,23 +45,19 @@ __typename
 id  
 }
 "
-  let parse = (
-    (value): t => {
-      id: {
-        let value = (value: Raw.t).id
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let id = {
-        let value = (value: t).id
-        value
-      }
-      {id: id}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    id: {
+      let value = (value: Raw.t).id
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let id = {
+      let value = (value: t).id
+      value
+    }
+    {id: id}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InterfaceFragment: [#InterfaceFragment],
     value: Raw.t,
@@ -119,37 +115,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnotherFragment: [#AnotherFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -192,37 +184,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnonUser: [#AnonUser], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #AnonUser => ()
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentUnion.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentUnion.res.txt
index e8057703..e833e440 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentUnion.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentUnion.res.txt
@@ -37,23 +37,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -92,23 +88,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _HumanFragment: [#HumanFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentWithdifferentReturnType.res.txt
index e379a226..c755e269 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentWithdifferentReturnType.res.txt
@@ -41,59 +41,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/native/generate/fragmentvariableinput.res.txt b/snapshot_tests/operations/expected/native/generate/fragmentvariableinput.res.txt
index 2ed62e81..8a9970fd 100644
--- a/snapshot_tests/operations/expected/native/generate/fragmentvariableinput.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/fragmentvariableinput.res.txt
@@ -35,54 +35,50 @@ id
 
 }
 "
-  let parse = (
-    (value): t => {
-      reposts: {
-        let value = (value: Raw.t).reposts
-        Js.Array2.map(value, value =>
-          switch Js.toOption(value) {
-          | Some(value) =>
-            Some(
-              (
-                {
-                  id: {
-                    let value = (value: Raw.t_reposts).id
-                    value
-                  },
-                }: t_reposts
-              ),
-            )
-          | None => None
-          }
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let reposts = {
-        let value = (value: t).reposts
-        Js.Array2.map(value, value =>
-          switch value {
-          | Some(value) =>
-            Js.Nullable.return(
-              (
-                {
-                  let id = {
-                    let value = (value: t_reposts).id
-                    value
-                  }
-                  {id: id}
-                }: Raw.t_reposts
-              ),
-            )
-          | None => Js.Nullable.null
-          }
-        )
-      }
-      {reposts: reposts}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    reposts: {
+      let value = (value: Raw.t).reposts
+      Js.Array2.map(value, value =>
+        switch Js.toOption(value) {
+        | Some(value) =>
+          Some(
+            (
+              {
+                id: {
+                  let value = (value: Raw.t_reposts).id
+                  value
+                },
+              }: t_reposts
+            ),
+          )
+        | None => None
+        }
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let reposts = {
+      let value = (value: t).reposts
+      Js.Array2.map(value, value =>
+        switch value {
+        | Some(value) =>
+          Js.Nullable.return(
+            (
+              {
+                let id = {
+                  let value = (value: t_reposts).id
+                  value
+                }
+                {id: id}
+              }: Raw.t_reposts
+            ),
+          )
+        | None => Js.Nullable.null
+        }
+      )
+    }
+    {reposts: reposts}
+  }
   let verifyArgsAndParse = (
     ~name as _name: [#NonNull_String],
     ~fragmentName as _test: [#test],
diff --git a/snapshot_tests/operations/expected/native/generate/hasuraRepro.res.txt b/snapshot_tests/operations/expected/native/generate/hasuraRepro.res.txt
index 3ac6e8c0..dd070aaa 100644
--- a/snapshot_tests/operations/expected/native/generate/hasuraRepro.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/hasuraRepro.res.txt
@@ -28,23 +28,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _Dog: [#Dog], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Dog => ()
diff --git a/snapshot_tests/operations/expected/native/generate/record.res.txt b/snapshot_tests/operations/expected/native/generate/record.res.txt
index f8b76a95..c11046fe 100644
--- a/snapshot_tests/operations/expected/native/generate/record.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/record.res.txt
@@ -333,31 +333,27 @@ string
 int  
 }
 "
-    let parse = (
-      (value): t => {
-        string: {
-          let value = (value: Raw.t).string
-          value
-        },
-        int: {
-          let value = (value: Raw.t).int
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let int = {
-          let value = (value: t).int
-          value
-        }
-        and string = {
-          let value = (value: t).string
-          value
-        }
-        {string, int}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      string: {
+        let value = (value: Raw.t).string
+        value
+      },
+      int: {
+        let value = (value: Raw.t).int
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let int = {
+        let value = (value: t).int
+        value
+      }
+      and string = {
+        let value = (value: t).string
+        value
+      }
+      {string, int}
+    }
     let verifyArgsAndParse = (~fragmentName as _Fragment: [#Fragment], value: Raw.t) => parse(value)
     let verifyName = x => switch x {
     | #Fragment => ()
@@ -600,39 +596,35 @@ name
 barkVolume  
 }
 "
-    let parse = (
-      (value): t => {
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        barkVolume: {
-          let value = (value: Raw.t).barkVolume
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let barkVolume = {
-          let value = (value: t).barkVolume
-          value
-        }
-        and name = {
-          let value = (value: t).name
-          value
-        }
-        and __typename = {
-          let value = (value: t).__typename
-          value
-        }
-        {__typename, name, barkVolume}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      barkVolume: {
+        let value = (value: Raw.t).barkVolume
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let barkVolume = {
+        let value = (value: t).barkVolume
+        value
+      }
+      and name = {
+        let value = (value: t).name
+        value
+      }
+      and __typename = {
+        let value = (value: t).__typename
+        value
+      }
+      {__typename, name, barkVolume}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/native/generate/tagged_template.res.txt b/snapshot_tests/operations/expected/native/generate/tagged_template.res.txt
index 6c3dd713..0aa5f74c 100644
--- a/snapshot_tests/operations/expected/native/generate/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/tagged_template.res.txt
@@ -1545,59 +1545,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -1847,59 +1843,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment8: [#ListFragment8], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/native/generate/union.res.txt b/snapshot_tests/operations/expected/native/generate/union.res.txt
index b01f6a3c..16612a7a 100644
--- a/snapshot_tests/operations/expected/native/generate/union.res.txt
+++ b/snapshot_tests/operations/expected/native/generate/union.res.txt
@@ -541,31 +541,27 @@ name
 __typename  
 }
 "
-    let parse = (
-      (value): named => {
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-      }: Raw.t => named
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let __typename = {
-          let value = (value: named).__typename
-          value
-        }
-        and name = {
-          let value = (value: named).name
-          value
-        }
-        {name, __typename}
-      }: named => Raw.t
-    )
+    let parse = (value): named => {
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let __typename = {
+        let value = (value: named).__typename
+        value
+      }
+      and name = {
+        let value = (value: named).name
+        value
+      }
+      {name, __typename}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFields: [#DogFields], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/records/generate/ewert_reproduction.res.txt b/snapshot_tests/operations/expected/records/generate/ewert_reproduction.res.txt
index b2c3b0c0..702d449b 100644
--- a/snapshot_tests/operations/expected/records/generate/ewert_reproduction.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/ewert_reproduction.res.txt
@@ -49,60 +49,56 @@ lastname
 
 }
 "
-  let parse = (
-    (value): t => {
-      user: {
-        let value = (value: Raw.t).user
-        (
-          {
-            id: {
-              let value = (value: Raw.t_user).id
-              value
-            },
-            firstname: {
-              let value = (value: Raw.t_user).firstname
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            },
-            lastname: {
-              let value = (value: Raw.t_user).lastname
-              value
-            },
-          }: t_user
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let user = {
-        let value = (value: t).user
-        (
-          {
-            let lastname = {
-              let value = (value: t_user).lastname
-              value
+  let parse = (value): t => {
+    user: {
+      let value = (value: Raw.t).user
+      (
+        {
+          id: {
+            let value = (value: Raw.t_user).id
+            value
+          },
+          firstname: {
+            let value = (value: Raw.t_user).firstname
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
             }
-            and firstname = {
-              let value = (value: t_user).firstname
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            }
-            and id = {
-              let value = (value: t_user).id
-              value
+          },
+          lastname: {
+            let value = (value: Raw.t_user).lastname
+            value
+          },
+        }: t_user
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let user = {
+      let value = (value: t).user
+      (
+        {
+          let lastname = {
+            let value = (value: t_user).lastname
+            value
+          }
+          and firstname = {
+            let value = (value: t_user).firstname
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
             }
-            {id, firstname, lastname}
-          }: Raw.t_user
-        )
-      }
-      {user: user}
-    }: t => Raw.t
-  )
+          }
+          and id = {
+            let value = (value: t_user).id
+            value
+          }
+          {id, firstname, lastname}
+        }: Raw.t_user
+      )
+    }
+    {user: user}
+  }
   let verifyArgsAndParse = (
     ~userId as _userId: [#NonNull_String],
     ~fragmentName as _UserData: [#UserData],
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentDefinition.res.txt
index 28334959..55164be0 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentDefinition.res.txt
@@ -45,59 +45,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -136,29 +132,25 @@ function back to the original JSON-compatible data ")
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNonNullable: nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNonNullable: nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
@@ -196,45 +188,41 @@ function back to the original JSON-compatible data ")
 listWithArg(arg1: $arg1)  
 }
 "
-  let parse = (
-    (value): t => {
-      listWithArg: {
-        let value = (value: Raw.t).listWithArg
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let listWithArg = {
-        let value = (value: t).listWithArg
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    listWithArg: {
+      let value = (value: Raw.t).listWithArg
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {listWithArg: listWithArg}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let listWithArg = {
+      let value = (value: t).listWithArg
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {listWithArg: listWithArg}
+  }
   let verifyArgsAndParse = (
     ~arg1 as _arg1: [#String],
     ~fragmentName as _FragmentWithArgs: [#FragmentWithArgs],
@@ -266,59 +254,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
@@ -349,59 +333,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentInFragment.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentInFragment.res.txt
index 4f47c025..c0c4d0c5 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentInFragment.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentInFragment.res.txt
@@ -32,45 +32,41 @@ function back to the original JSON-compatible data ")
 nullableOfNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {nullableOfNullable: nullableOfNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable: nullableOfNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -119,59 +115,55 @@ nullableOfNullable
 ",
     ListFragment.query,
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      listFragment: {
-        let value = (Obj.magic(value): ListFragment.Raw.t)
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
+      }
+    },
+    listFragment: {
+      let value = (Obj.magic(value): ListFragment.Raw.t)
 
-        ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let nullableOfNullable = {
-                let value = (value: t).nullableOfNullable
-                switch value {
-                | Some(value) =>
-                  Js.Nullable.return(
-                    Js.Array2.map(value, value =>
-                      switch value {
-                      | Some(value) => Js.Nullable.return(value)
-                      | None => Js.Nullable.null
-                      }
-                    ),
-                  )
-                | None => Js.Nullable.null
-                }
+      ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let nullableOfNullable = {
+              let value = (value: t).nullableOfNullable
+              switch value {
+              | Some(value) =>
+                Js.Nullable.return(
+                  Js.Array2.map(value, value =>
+                    switch value {
+                    | Some(value) => Js.Nullable.return(value)
+                    | None => Js.Nullable.null
+                    }
+                  ),
+                )
+              | None => Js.Nullable.null
               }
-              {"nullableOfNullable": nullableOfNullable}
-            }): Js.Json.t
-          ),
+            }
+            {"nullableOfNullable": nullableOfNullable}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentOnInterface.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentOnInterface.res.txt
index 3be22af6..dcedda2f 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentOnInterface.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentOnInterface.res.txt
@@ -45,23 +45,19 @@ __typename
 id  
 }
 "
-  let parse = (
-    (value): t => {
-      id: {
-        let value = (value: Raw.t).id
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let id = {
-        let value = (value: t).id
-        value
-      }
-      {id: id}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    id: {
+      let value = (value: Raw.t).id
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let id = {
+      let value = (value: t).id
+      value
+    }
+    {id: id}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InterfaceFragment: [#InterfaceFragment],
     value: Raw.t,
@@ -119,37 +115,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnotherFragment: [#AnotherFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -192,37 +184,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnonUser: [#AnonUser], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #AnonUser => ()
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentUnion.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentUnion.res.txt
index e8057703..e833e440 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentUnion.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentUnion.res.txt
@@ -37,23 +37,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -92,23 +88,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _HumanFragment: [#HumanFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentWithdifferentReturnType.res.txt
index e379a226..c755e269 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentWithdifferentReturnType.res.txt
@@ -41,59 +41,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/records/generate/fragmentvariableinput.res.txt b/snapshot_tests/operations/expected/records/generate/fragmentvariableinput.res.txt
index 2ed62e81..8a9970fd 100644
--- a/snapshot_tests/operations/expected/records/generate/fragmentvariableinput.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/fragmentvariableinput.res.txt
@@ -35,54 +35,50 @@ id
 
 }
 "
-  let parse = (
-    (value): t => {
-      reposts: {
-        let value = (value: Raw.t).reposts
-        Js.Array2.map(value, value =>
-          switch Js.toOption(value) {
-          | Some(value) =>
-            Some(
-              (
-                {
-                  id: {
-                    let value = (value: Raw.t_reposts).id
-                    value
-                  },
-                }: t_reposts
-              ),
-            )
-          | None => None
-          }
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let reposts = {
-        let value = (value: t).reposts
-        Js.Array2.map(value, value =>
-          switch value {
-          | Some(value) =>
-            Js.Nullable.return(
-              (
-                {
-                  let id = {
-                    let value = (value: t_reposts).id
-                    value
-                  }
-                  {id: id}
-                }: Raw.t_reposts
-              ),
-            )
-          | None => Js.Nullable.null
-          }
-        )
-      }
-      {reposts: reposts}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    reposts: {
+      let value = (value: Raw.t).reposts
+      Js.Array2.map(value, value =>
+        switch Js.toOption(value) {
+        | Some(value) =>
+          Some(
+            (
+              {
+                id: {
+                  let value = (value: Raw.t_reposts).id
+                  value
+                },
+              }: t_reposts
+            ),
+          )
+        | None => None
+        }
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let reposts = {
+      let value = (value: t).reposts
+      Js.Array2.map(value, value =>
+        switch value {
+        | Some(value) =>
+          Js.Nullable.return(
+            (
+              {
+                let id = {
+                  let value = (value: t_reposts).id
+                  value
+                }
+                {id: id}
+              }: Raw.t_reposts
+            ),
+          )
+        | None => Js.Nullable.null
+        }
+      )
+    }
+    {reposts: reposts}
+  }
   let verifyArgsAndParse = (
     ~name as _name: [#NonNull_String],
     ~fragmentName as _test: [#test],
diff --git a/snapshot_tests/operations/expected/records/generate/hasuraRepro.res.txt b/snapshot_tests/operations/expected/records/generate/hasuraRepro.res.txt
index 3ac6e8c0..dd070aaa 100644
--- a/snapshot_tests/operations/expected/records/generate/hasuraRepro.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/hasuraRepro.res.txt
@@ -28,23 +28,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _Dog: [#Dog], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Dog => ()
diff --git a/snapshot_tests/operations/expected/records/generate/record.res.txt b/snapshot_tests/operations/expected/records/generate/record.res.txt
index f8b76a95..c11046fe 100644
--- a/snapshot_tests/operations/expected/records/generate/record.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/record.res.txt
@@ -333,31 +333,27 @@ string
 int  
 }
 "
-    let parse = (
-      (value): t => {
-        string: {
-          let value = (value: Raw.t).string
-          value
-        },
-        int: {
-          let value = (value: Raw.t).int
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let int = {
-          let value = (value: t).int
-          value
-        }
-        and string = {
-          let value = (value: t).string
-          value
-        }
-        {string, int}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      string: {
+        let value = (value: Raw.t).string
+        value
+      },
+      int: {
+        let value = (value: Raw.t).int
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let int = {
+        let value = (value: t).int
+        value
+      }
+      and string = {
+        let value = (value: t).string
+        value
+      }
+      {string, int}
+    }
     let verifyArgsAndParse = (~fragmentName as _Fragment: [#Fragment], value: Raw.t) => parse(value)
     let verifyName = x => switch x {
     | #Fragment => ()
@@ -600,39 +596,35 @@ name
 barkVolume  
 }
 "
-    let parse = (
-      (value): t => {
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        barkVolume: {
-          let value = (value: Raw.t).barkVolume
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let barkVolume = {
-          let value = (value: t).barkVolume
-          value
-        }
-        and name = {
-          let value = (value: t).name
-          value
-        }
-        and __typename = {
-          let value = (value: t).__typename
-          value
-        }
-        {__typename, name, barkVolume}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      barkVolume: {
+        let value = (value: Raw.t).barkVolume
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let barkVolume = {
+        let value = (value: t).barkVolume
+        value
+      }
+      and name = {
+        let value = (value: t).name
+        value
+      }
+      and __typename = {
+        let value = (value: t).__typename
+        value
+      }
+      {__typename, name, barkVolume}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/records/generate/tagged_template.res.txt b/snapshot_tests/operations/expected/records/generate/tagged_template.res.txt
index 6c3dd713..0aa5f74c 100644
--- a/snapshot_tests/operations/expected/records/generate/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/tagged_template.res.txt
@@ -1545,59 +1545,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -1847,59 +1843,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment8: [#ListFragment8], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/records/generate/union.res.txt b/snapshot_tests/operations/expected/records/generate/union.res.txt
index b01f6a3c..16612a7a 100644
--- a/snapshot_tests/operations/expected/records/generate/union.res.txt
+++ b/snapshot_tests/operations/expected/records/generate/union.res.txt
@@ -541,31 +541,27 @@ name
 __typename  
 }
 "
-    let parse = (
-      (value): named => {
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-      }: Raw.t => named
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let __typename = {
-          let value = (value: named).__typename
-          value
-        }
-        and name = {
-          let value = (value: named).name
-          value
-        }
-        {name, __typename}
-      }: named => Raw.t
-    )
+    let parse = (value): named => {
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let __typename = {
+        let value = (value: named).__typename
+        value
+      }
+      and name = {
+        let value = (value: named).name
+        value
+      }
+      {name, __typename}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFields: [#DogFields], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/template/generate/ewert_reproduction.res.txt b/snapshot_tests/operations/expected/template/generate/ewert_reproduction.res.txt
index b2c3b0c0..702d449b 100644
--- a/snapshot_tests/operations/expected/template/generate/ewert_reproduction.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/ewert_reproduction.res.txt
@@ -49,60 +49,56 @@ lastname
 
 }
 "
-  let parse = (
-    (value): t => {
-      user: {
-        let value = (value: Raw.t).user
-        (
-          {
-            id: {
-              let value = (value: Raw.t_user).id
-              value
-            },
-            firstname: {
-              let value = (value: Raw.t_user).firstname
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            },
-            lastname: {
-              let value = (value: Raw.t_user).lastname
-              value
-            },
-          }: t_user
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let user = {
-        let value = (value: t).user
-        (
-          {
-            let lastname = {
-              let value = (value: t_user).lastname
-              value
+  let parse = (value): t => {
+    user: {
+      let value = (value: Raw.t).user
+      (
+        {
+          id: {
+            let value = (value: Raw.t_user).id
+            value
+          },
+          firstname: {
+            let value = (value: Raw.t_user).firstname
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
             }
-            and firstname = {
-              let value = (value: t_user).firstname
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            }
-            and id = {
-              let value = (value: t_user).id
-              value
+          },
+          lastname: {
+            let value = (value: Raw.t_user).lastname
+            value
+          },
+        }: t_user
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let user = {
+      let value = (value: t).user
+      (
+        {
+          let lastname = {
+            let value = (value: t_user).lastname
+            value
+          }
+          and firstname = {
+            let value = (value: t_user).firstname
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
             }
-            {id, firstname, lastname}
-          }: Raw.t_user
-        )
-      }
-      {user: user}
-    }: t => Raw.t
-  )
+          }
+          and id = {
+            let value = (value: t_user).id
+            value
+          }
+          {id, firstname, lastname}
+        }: Raw.t_user
+      )
+    }
+    {user: user}
+  }
   let verifyArgsAndParse = (
     ~userId as _userId: [#NonNull_String],
     ~fragmentName as _UserData: [#UserData],
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentDefinition.res.txt
index 28334959..55164be0 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentDefinition.res.txt
@@ -45,59 +45,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -136,29 +132,25 @@ function back to the original JSON-compatible data ")
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNonNullable: nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNonNullable: nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
@@ -196,45 +188,41 @@ function back to the original JSON-compatible data ")
 listWithArg(arg1: $arg1)  
 }
 "
-  let parse = (
-    (value): t => {
-      listWithArg: {
-        let value = (value: Raw.t).listWithArg
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let listWithArg = {
-        let value = (value: t).listWithArg
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    listWithArg: {
+      let value = (value: Raw.t).listWithArg
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {listWithArg: listWithArg}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let listWithArg = {
+      let value = (value: t).listWithArg
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {listWithArg: listWithArg}
+  }
   let verifyArgsAndParse = (
     ~arg1 as _arg1: [#String],
     ~fragmentName as _FragmentWithArgs: [#FragmentWithArgs],
@@ -266,59 +254,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
@@ -349,59 +333,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentInFragment.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentInFragment.res.txt
index 4f47c025..c0c4d0c5 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentInFragment.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentInFragment.res.txt
@@ -32,45 +32,41 @@ function back to the original JSON-compatible data ")
 nullableOfNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {nullableOfNullable: nullableOfNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable: nullableOfNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -119,59 +115,55 @@ nullableOfNullable
 ",
     ListFragment.query,
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      listFragment: {
-        let value = (Obj.magic(value): ListFragment.Raw.t)
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
+      }
+    },
+    listFragment: {
+      let value = (Obj.magic(value): ListFragment.Raw.t)
 
-        ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let nullableOfNullable = {
-                let value = (value: t).nullableOfNullable
-                switch value {
-                | Some(value) =>
-                  Js.Nullable.return(
-                    Js.Array2.map(value, value =>
-                      switch value {
-                      | Some(value) => Js.Nullable.return(value)
-                      | None => Js.Nullable.null
-                      }
-                    ),
-                  )
-                | None => Js.Nullable.null
-                }
+      ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let nullableOfNullable = {
+              let value = (value: t).nullableOfNullable
+              switch value {
+              | Some(value) =>
+                Js.Nullable.return(
+                  Js.Array2.map(value, value =>
+                    switch value {
+                    | Some(value) => Js.Nullable.return(value)
+                    | None => Js.Nullable.null
+                    }
+                  ),
+                )
+              | None => Js.Nullable.null
               }
-              {"nullableOfNullable": nullableOfNullable}
-            }): Js.Json.t
-          ),
+            }
+            {"nullableOfNullable": nullableOfNullable}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentOnInterface.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentOnInterface.res.txt
index 3be22af6..dcedda2f 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentOnInterface.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentOnInterface.res.txt
@@ -45,23 +45,19 @@ __typename
 id  
 }
 "
-  let parse = (
-    (value): t => {
-      id: {
-        let value = (value: Raw.t).id
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let id = {
-        let value = (value: t).id
-        value
-      }
-      {id: id}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    id: {
+      let value = (value: Raw.t).id
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let id = {
+      let value = (value: t).id
+      value
+    }
+    {id: id}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InterfaceFragment: [#InterfaceFragment],
     value: Raw.t,
@@ -119,37 +115,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnotherFragment: [#AnotherFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -192,37 +184,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnonUser: [#AnonUser], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #AnonUser => ()
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentUnion.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentUnion.res.txt
index e8057703..e833e440 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentUnion.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentUnion.res.txt
@@ -37,23 +37,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -92,23 +88,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _HumanFragment: [#HumanFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentWithdifferentReturnType.res.txt
index e379a226..c755e269 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentWithdifferentReturnType.res.txt
@@ -41,59 +41,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/template/generate/fragmentvariableinput.res.txt b/snapshot_tests/operations/expected/template/generate/fragmentvariableinput.res.txt
index 2ed62e81..8a9970fd 100644
--- a/snapshot_tests/operations/expected/template/generate/fragmentvariableinput.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/fragmentvariableinput.res.txt
@@ -35,54 +35,50 @@ id
 
 }
 "
-  let parse = (
-    (value): t => {
-      reposts: {
-        let value = (value: Raw.t).reposts
-        Js.Array2.map(value, value =>
-          switch Js.toOption(value) {
-          | Some(value) =>
-            Some(
-              (
-                {
-                  id: {
-                    let value = (value: Raw.t_reposts).id
-                    value
-                  },
-                }: t_reposts
-              ),
-            )
-          | None => None
-          }
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let reposts = {
-        let value = (value: t).reposts
-        Js.Array2.map(value, value =>
-          switch value {
-          | Some(value) =>
-            Js.Nullable.return(
-              (
-                {
-                  let id = {
-                    let value = (value: t_reposts).id
-                    value
-                  }
-                  {id: id}
-                }: Raw.t_reposts
-              ),
-            )
-          | None => Js.Nullable.null
-          }
-        )
-      }
-      {reposts: reposts}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    reposts: {
+      let value = (value: Raw.t).reposts
+      Js.Array2.map(value, value =>
+        switch Js.toOption(value) {
+        | Some(value) =>
+          Some(
+            (
+              {
+                id: {
+                  let value = (value: Raw.t_reposts).id
+                  value
+                },
+              }: t_reposts
+            ),
+          )
+        | None => None
+        }
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let reposts = {
+      let value = (value: t).reposts
+      Js.Array2.map(value, value =>
+        switch value {
+        | Some(value) =>
+          Js.Nullable.return(
+            (
+              {
+                let id = {
+                  let value = (value: t_reposts).id
+                  value
+                }
+                {id: id}
+              }: Raw.t_reposts
+            ),
+          )
+        | None => Js.Nullable.null
+        }
+      )
+    }
+    {reposts: reposts}
+  }
   let verifyArgsAndParse = (
     ~name as _name: [#NonNull_String],
     ~fragmentName as _test: [#test],
diff --git a/snapshot_tests/operations/expected/template/generate/hasuraRepro.res.txt b/snapshot_tests/operations/expected/template/generate/hasuraRepro.res.txt
index 3ac6e8c0..dd070aaa 100644
--- a/snapshot_tests/operations/expected/template/generate/hasuraRepro.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/hasuraRepro.res.txt
@@ -28,23 +28,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _Dog: [#Dog], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Dog => ()
diff --git a/snapshot_tests/operations/expected/template/generate/record.res.txt b/snapshot_tests/operations/expected/template/generate/record.res.txt
index f8b76a95..c11046fe 100644
--- a/snapshot_tests/operations/expected/template/generate/record.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/record.res.txt
@@ -333,31 +333,27 @@ string
 int  
 }
 "
-    let parse = (
-      (value): t => {
-        string: {
-          let value = (value: Raw.t).string
-          value
-        },
-        int: {
-          let value = (value: Raw.t).int
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let int = {
-          let value = (value: t).int
-          value
-        }
-        and string = {
-          let value = (value: t).string
-          value
-        }
-        {string, int}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      string: {
+        let value = (value: Raw.t).string
+        value
+      },
+      int: {
+        let value = (value: Raw.t).int
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let int = {
+        let value = (value: t).int
+        value
+      }
+      and string = {
+        let value = (value: t).string
+        value
+      }
+      {string, int}
+    }
     let verifyArgsAndParse = (~fragmentName as _Fragment: [#Fragment], value: Raw.t) => parse(value)
     let verifyName = x => switch x {
     | #Fragment => ()
@@ -600,39 +596,35 @@ name
 barkVolume  
 }
 "
-    let parse = (
-      (value): t => {
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        barkVolume: {
-          let value = (value: Raw.t).barkVolume
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let barkVolume = {
-          let value = (value: t).barkVolume
-          value
-        }
-        and name = {
-          let value = (value: t).name
-          value
-        }
-        and __typename = {
-          let value = (value: t).__typename
-          value
-        }
-        {__typename, name, barkVolume}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      barkVolume: {
+        let value = (value: Raw.t).barkVolume
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let barkVolume = {
+        let value = (value: t).barkVolume
+        value
+      }
+      and name = {
+        let value = (value: t).name
+        value
+      }
+      and __typename = {
+        let value = (value: t).__typename
+        value
+      }
+      {__typename, name, barkVolume}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/template/generate/tagged_template.res.txt b/snapshot_tests/operations/expected/template/generate/tagged_template.res.txt
index 6c3dd713..0aa5f74c 100644
--- a/snapshot_tests/operations/expected/template/generate/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/tagged_template.res.txt
@@ -1545,59 +1545,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -1847,59 +1843,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment8: [#ListFragment8], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/template/generate/union.res.txt b/snapshot_tests/operations/expected/template/generate/union.res.txt
index b01f6a3c..16612a7a 100644
--- a/snapshot_tests/operations/expected/template/generate/union.res.txt
+++ b/snapshot_tests/operations/expected/template/generate/union.res.txt
@@ -541,31 +541,27 @@ name
 __typename  
 }
 "
-    let parse = (
-      (value): named => {
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-      }: Raw.t => named
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let __typename = {
-          let value = (value: named).__typename
-          value
-        }
-        and name = {
-          let value = (value: named).name
-          value
-        }
-        {name, __typename}
-      }: named => Raw.t
-    )
+    let parse = (value): named => {
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let __typename = {
+        let value = (value: named).__typename
+        value
+      }
+      and name = {
+        let value = (value: named).name
+        value
+      }
+      {name, __typename}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFields: [#DogFields], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/uncurried/compile/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/uncurried/compile/fragmentDefinition.res.txt
index b2f73389..64ee99fb 100644
--- a/snapshot_tests/operations/expected/uncurried/compile/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/compile/fragmentDefinition.res.txt
@@ -266,37 +266,39 @@ var Raw$5 = {};
 var query$3 = "query MyQuery($arg1: String)  {\nl1: lists  {\n...ListFragment   \n}\n\nl2: lists  {\n...ListFragment   \n...ListFragment   \n}\n\nl3: lists  {\nnullableOfNullable  \n...ListFragment   \n...ListFragment   \n}\n\nl4: lists  {\nnullableOfNullable  \n...InlineListFragment   \n}\n\nl5: lists  {\n...FragmentWithArgs   \n}\n\n}\nfragment FragmentWithArgs on Lists   {\nlistWithArg(arg1: $arg1)  \n}\nfragment ListFragment on Lists   {\nnullableOfNullable  \nnullableOfNonNullable  \n}\nfragment InlineListFragment on Lists   {\nnullableOfNullable  \nnullableOfNonNullable  \n}\n";
 
 function parse$5(value) {
-  var value$1 = value.l2;
-  var value$2 = value.l3;
-  var value$3 = value$2["nullableOfNullable"];
-  var value$4 = value.l4;
-  var value$5 = value$4["nullableOfNullable"];
+  var value$1 = value.l1;
+  var value$2 = value.l2;
+  var value$3 = value.l3;
+  var value$4 = value$3["nullableOfNullable"];
+  var value$5 = value.l4;
+  var value$6 = value$5["nullableOfNullable"];
+  var value$7 = value.l5;
   return {
-          l1: parse(value.l1),
+          l1: parse(value$1),
           l2: {
-            frag1: parse(value$1),
-            frag2: parse(value$1)
+            frag1: parse(value$2),
+            frag2: parse(value$2)
           },
           l3: {
-            nullableOfNullable: !(value$3 == null) ? value$3.map(function (value) {
+            nullableOfNullable: !(value$4 == null) ? value$4.map(function (value) {
                     if (!(value == null)) {
                       return value;
                     }
                     
                   }) : undefined,
-            frag1: parse(value$2),
-            frag2: parse(value$2)
+            frag1: parse(value$3),
+            frag2: parse(value$3)
           },
           l4: {
-            nullableOfNullable: !(value$5 == null) ? value$5.map(function (value) {
+            nullableOfNullable: !(value$6 == null) ? value$6.map(function (value) {
                     if (!(value == null)) {
                       return value;
                     }
                     
                   }) : undefined,
-            inlineListFragment: parse$3(value$4)
+            inlineListFragment: parse$3(value$5)
           },
-          l5: parse$2(value.l5)
+          l5: parse$2(value$7)
         };
 }
 
@@ -380,8 +382,9 @@ var Raw$6 = {};
 var query$4 = "query   {\nlists  {\n...ListFragment   \n}\n\n}\nfragment ListFragment on Lists   {\nnullableOfNullable  \nnullableOfNonNullable  \n}\n";
 
 function parse$6(value) {
+  var value$1 = value.lists;
   return {
-          lists: parse(value.lists)
+          lists: parse(value$1)
         };
 }
 
diff --git a/snapshot_tests/operations/expected/uncurried/compile/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/uncurried/compile/fragmentWithdifferentReturnType.res.txt
index 956d928c..f006af0f 100644
--- a/snapshot_tests/operations/expected/uncurried/compile/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/compile/fragmentWithdifferentReturnType.res.txt
@@ -70,8 +70,9 @@ lists  {
 ${query}`;
 
 function parse$1(value) {
+  var value$1 = value.lists;
   return {
-          lists: parse(value.lists)
+          lists: parse(value$1)
         };
 }
 
diff --git a/snapshot_tests/operations/expected/uncurried/compile/record.res.txt b/snapshot_tests/operations/expected/uncurried/compile/record.res.txt
index 079e80ce..034d1a36 100644
--- a/snapshot_tests/operations/expected/uncurried/compile/record.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/compile/record.res.txt
@@ -197,8 +197,9 @@ var Raw$4 = {};
 var query$1 = "query   {\nvariousScalars  {\n...Fragment   \n}\n\n}\nfragment Fragment on VariousScalars   {\nstring  \nint  \n}\n";
 
 function parse$4(value) {
+  var value$1 = value.variousScalars;
   return {
-          variousScalars: parse$3(value.variousScalars)
+          variousScalars: parse$3(value$1)
         };
 }
 
diff --git a/snapshot_tests/operations/expected/uncurried/compile/tagged_template.res.txt b/snapshot_tests/operations/expected/uncurried/compile/tagged_template.res.txt
index d557048b..5cf4e49d 100644
--- a/snapshot_tests/operations/expected/uncurried/compile/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/compile/tagged_template.res.txt
@@ -673,8 +673,9 @@ lists  {
 ${query$6}`;
 
 function parse$7(value) {
+  var value$1 = value.lists;
   return {
-          lists: parse$6(value.lists)
+          lists: parse$6(value$1)
         };
 }
 
@@ -719,8 +720,9 @@ lists  {
 ${query$6}`;
 
 function parse$8(value) {
+  var value$1 = value.lists;
   return {
-          lists: parse$6(value.lists)
+          lists: parse$6(value$1)
         };
 }
 
@@ -765,8 +767,9 @@ lists  {
 ${query$6}`;
 
 function parse$9(value) {
+  var value$1 = value.lists;
   return {
-          lists: parse$6(value.lists)
+          lists: parse$6(value$1)
         };
 }
 
@@ -864,25 +867,26 @@ var query$11 = ApolloClient.gql([
     ], query$10);
 
 function parse$11(value) {
-  var value$1 = value.variousScalars;
-  var value$2 = value$1.nullableString;
-  var value$3 = value$1.nullableInt;
-  var value$4 = value$1.nullableFloat;
-  var value$5 = value$1.nullableBoolean;
-  var value$6 = value$1.nullableID;
+  var value$1 = value.lists;
+  var value$2 = value.variousScalars;
+  var value$3 = value$2.nullableString;
+  var value$4 = value$2.nullableInt;
+  var value$5 = value$2.nullableFloat;
+  var value$6 = value$2.nullableBoolean;
+  var value$7 = value$2.nullableID;
   return {
-          lists: parse$10(value.lists),
+          lists: parse$10(value$1),
           variousScalars: {
-            nullableString: !(value$2 == null) ? value$2 : undefined,
-            string: value$1.string,
-            nullableInt: !(value$3 == null) ? value$3 : undefined,
-            int: value$1.int,
-            nullableFloat: !(value$4 == null) ? value$4 : undefined,
-            float: value$1.float,
-            nullableBoolean: !(value$5 == null) ? value$5 : undefined,
-            boolean: value$1.boolean,
-            nullableID: !(value$6 == null) ? value$6 : undefined,
-            id: value$1.id
+            nullableString: !(value$3 == null) ? value$3 : undefined,
+            string: value$2.string,
+            nullableInt: !(value$4 == null) ? value$4 : undefined,
+            int: value$2.int,
+            nullableFloat: !(value$5 == null) ? value$5 : undefined,
+            float: value$2.float,
+            nullableBoolean: !(value$6 == null) ? value$6 : undefined,
+            boolean: value$2.boolean,
+            nullableID: !(value$7 == null) ? value$7 : undefined,
+            id: value$2.id
           }
         };
 }
diff --git a/snapshot_tests/operations/expected/uncurried/generate/ewert_reproduction.res.txt b/snapshot_tests/operations/expected/uncurried/generate/ewert_reproduction.res.txt
index b2c3b0c0..702d449b 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/ewert_reproduction.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/ewert_reproduction.res.txt
@@ -49,60 +49,56 @@ lastname
 
 }
 "
-  let parse = (
-    (value): t => {
-      user: {
-        let value = (value: Raw.t).user
-        (
-          {
-            id: {
-              let value = (value: Raw.t_user).id
-              value
-            },
-            firstname: {
-              let value = (value: Raw.t_user).firstname
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            },
-            lastname: {
-              let value = (value: Raw.t_user).lastname
-              value
-            },
-          }: t_user
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let user = {
-        let value = (value: t).user
-        (
-          {
-            let lastname = {
-              let value = (value: t_user).lastname
-              value
+  let parse = (value): t => {
+    user: {
+      let value = (value: Raw.t).user
+      (
+        {
+          id: {
+            let value = (value: Raw.t_user).id
+            value
+          },
+          firstname: {
+            let value = (value: Raw.t_user).firstname
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
             }
-            and firstname = {
-              let value = (value: t_user).firstname
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            }
-            and id = {
-              let value = (value: t_user).id
-              value
+          },
+          lastname: {
+            let value = (value: Raw.t_user).lastname
+            value
+          },
+        }: t_user
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let user = {
+      let value = (value: t).user
+      (
+        {
+          let lastname = {
+            let value = (value: t_user).lastname
+            value
+          }
+          and firstname = {
+            let value = (value: t_user).firstname
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
             }
-            {id, firstname, lastname}
-          }: Raw.t_user
-        )
-      }
-      {user: user}
-    }: t => Raw.t
-  )
+          }
+          and id = {
+            let value = (value: t_user).id
+            value
+          }
+          {id, firstname, lastname}
+        }: Raw.t_user
+      )
+    }
+    {user: user}
+  }
   let verifyArgsAndParse = (
     ~userId as _userId: [#NonNull_String],
     ~fragmentName as _UserData: [#UserData],
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentDefinition.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentDefinition.res.txt
index 28334959..55164be0 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentDefinition.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentDefinition.res.txt
@@ -45,59 +45,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -136,29 +132,25 @@ function back to the original JSON-compatible data ")
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNonNullable: nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNonNullable: nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
@@ -196,45 +188,41 @@ function back to the original JSON-compatible data ")
 listWithArg(arg1: $arg1)  
 }
 "
-  let parse = (
-    (value): t => {
-      listWithArg: {
-        let value = (value: Raw.t).listWithArg
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let listWithArg = {
-        let value = (value: t).listWithArg
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    listWithArg: {
+      let value = (value: Raw.t).listWithArg
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {listWithArg: listWithArg}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let listWithArg = {
+      let value = (value: t).listWithArg
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {listWithArg: listWithArg}
+  }
   let verifyArgsAndParse = (
     ~arg1 as _arg1: [#String],
     ~fragmentName as _FragmentWithArgs: [#FragmentWithArgs],
@@ -266,59 +254,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
@@ -349,59 +333,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InlineListFragment: [#InlineListFragment],
     value: Raw.t,
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentInFragment.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentInFragment.res.txt
index 4f47c025..c0c4d0c5 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentInFragment.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentInFragment.res.txt
@@ -32,45 +32,41 @@ function back to the original JSON-compatible data ")
 nullableOfNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      {nullableOfNullable: nullableOfNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable: nullableOfNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -119,59 +115,55 @@ nullableOfNullable
 ",
     ListFragment.query,
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      listFragment: {
-        let value = (Obj.magic(value): ListFragment.Raw.t)
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "nullableOfNullable"))
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
+      }
+    },
+    listFragment: {
+      let value = (Obj.magic(value): ListFragment.Raw.t)
 
-        ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let nullableOfNullable = {
-                let value = (value: t).nullableOfNullable
-                switch value {
-                | Some(value) =>
-                  Js.Nullable.return(
-                    Js.Array2.map(value, value =>
-                      switch value {
-                      | Some(value) => Js.Nullable.return(value)
-                      | None => Js.Nullable.null
-                      }
-                    ),
-                  )
-                | None => Js.Nullable.null
-                }
+      ListFragment.verifyArgsAndParse(~fragmentName=#ListFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(ListFragment.serialize((value: t).listFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let nullableOfNullable = {
+              let value = (value: t).nullableOfNullable
+              switch value {
+              | Some(value) =>
+                Js.Nullable.return(
+                  Js.Array2.map(value, value =>
+                    switch value {
+                    | Some(value) => Js.Nullable.return(value)
+                    | None => Js.Nullable.null
+                    }
+                  ),
+                )
+              | None => Js.Nullable.null
               }
-              {"nullableOfNullable": nullableOfNullable}
-            }): Js.Json.t
-          ),
+            }
+            {"nullableOfNullable": nullableOfNullable}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _Another: [#Another], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Another => ()
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentOnInterface.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentOnInterface.res.txt
index 3be22af6..dcedda2f 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentOnInterface.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentOnInterface.res.txt
@@ -45,23 +45,19 @@ __typename
 id  
 }
 "
-  let parse = (
-    (value): t => {
-      id: {
-        let value = (value: Raw.t).id
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let id = {
-        let value = (value: t).id
-        value
-      }
-      {id: id}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    id: {
+      let value = (value: Raw.t).id
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let id = {
+      let value = (value: t).id
+      value
+    }
+    {id: id}
+  }
   let verifyArgsAndParse = (
     ~fragmentName as _InterfaceFragment: [#InterfaceFragment],
     value: Raw.t,
@@ -119,37 +115,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnotherFragment: [#AnotherFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -192,37 +184,33 @@ id
 ",
     InterfaceFragment.query,
   )
-  let parse = (
-    (value): t => {
-      id: {
-        let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
-        value
-      },
-      interfaceFragment: {
-        let value = (Obj.magic(value): InterfaceFragment.Raw.t)
+  let parse = (value): t => {
+    id: {
+      let value = Obj.magic(Js.Dict.unsafeGet(Obj.magic(value), "id"))
+      value
+    },
+    interfaceFragment: {
+      let value = (Obj.magic(value): InterfaceFragment.Raw.t)
 
-        InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t =>
-      Obj.magic(
-        Js.Array2.reduce(
-          [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
-          Graphql_ppx_runtime.deepMerge,
-          (
-            Obj.magic({
-              let id = {
-                let value = (value: t).id
-                value
-              }
-              {"id": id}
-            }): Js.Json.t
-          ),
+      InterfaceFragment.verifyArgsAndParse(~fragmentName=#InterfaceFragment, value)
+    },
+  }
+  let serialize = (value): Raw.t =>
+    Obj.magic(
+      Js.Array2.reduce(
+        [(Obj.magic(InterfaceFragment.serialize((value: t).interfaceFragment)): Js.Json.t)],
+        Graphql_ppx_runtime.deepMerge,
+        (
+          Obj.magic({
+            let id = {
+              let value = (value: t).id
+              value
+            }
+            {"id": id}
+          }): Js.Json.t
         ),
-      ): t => Raw.t
-  )
+      ),
+    )
   let verifyArgsAndParse = (~fragmentName as _AnonUser: [#AnonUser], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #AnonUser => ()
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentUnion.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentUnion.res.txt
index e8057703..e833e440 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentUnion.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentUnion.res.txt
@@ -37,23 +37,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -92,23 +88,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _HumanFragment: [#HumanFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentWithdifferentReturnType.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentWithdifferentReturnType.res.txt
index e379a226..c755e269 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentWithdifferentReturnType.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentWithdifferentReturnType.res.txt
@@ -41,59 +41,55 @@ nullableOfNullable
 nullableOfNonNullable  
 }
 "
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/uncurried/generate/fragmentvariableinput.res.txt b/snapshot_tests/operations/expected/uncurried/generate/fragmentvariableinput.res.txt
index 2ed62e81..8a9970fd 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/fragmentvariableinput.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/fragmentvariableinput.res.txt
@@ -35,54 +35,50 @@ id
 
 }
 "
-  let parse = (
-    (value): t => {
-      reposts: {
-        let value = (value: Raw.t).reposts
-        Js.Array2.map(value, value =>
-          switch Js.toOption(value) {
-          | Some(value) =>
-            Some(
-              (
-                {
-                  id: {
-                    let value = (value: Raw.t_reposts).id
-                    value
-                  },
-                }: t_reposts
-              ),
-            )
-          | None => None
-          }
-        )
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let reposts = {
-        let value = (value: t).reposts
-        Js.Array2.map(value, value =>
-          switch value {
-          | Some(value) =>
-            Js.Nullable.return(
-              (
-                {
-                  let id = {
-                    let value = (value: t_reposts).id
-                    value
-                  }
-                  {id: id}
-                }: Raw.t_reposts
-              ),
-            )
-          | None => Js.Nullable.null
-          }
-        )
-      }
-      {reposts: reposts}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    reposts: {
+      let value = (value: Raw.t).reposts
+      Js.Array2.map(value, value =>
+        switch Js.toOption(value) {
+        | Some(value) =>
+          Some(
+            (
+              {
+                id: {
+                  let value = (value: Raw.t_reposts).id
+                  value
+                },
+              }: t_reposts
+            ),
+          )
+        | None => None
+        }
+      )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let reposts = {
+      let value = (value: t).reposts
+      Js.Array2.map(value, value =>
+        switch value {
+        | Some(value) =>
+          Js.Nullable.return(
+            (
+              {
+                let id = {
+                  let value = (value: t_reposts).id
+                  value
+                }
+                {id: id}
+              }: Raw.t_reposts
+            ),
+          )
+        | None => Js.Nullable.null
+        }
+      )
+    }
+    {reposts: reposts}
+  }
   let verifyArgsAndParse = (
     ~name as _name: [#NonNull_String],
     ~fragmentName as _test: [#test],
diff --git a/snapshot_tests/operations/expected/uncurried/generate/hasuraRepro.res.txt b/snapshot_tests/operations/expected/uncurried/generate/hasuraRepro.res.txt
index 3ac6e8c0..dd070aaa 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/hasuraRepro.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/hasuraRepro.res.txt
@@ -28,23 +28,19 @@ function back to the original JSON-compatible data ")
 name  
 }
 "
-  let parse = (
-    (value): t => {
-      name: {
-        let value = (value: Raw.t).name
-        value
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let name = {
-        let value = (value: t).name
-        value
-      }
-      {name: name}
-    }: t => Raw.t
-  )
+  let parse = (value): t => {
+    name: {
+      let value = (value: Raw.t).name
+      value
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let name = {
+      let value = (value: t).name
+      value
+    }
+    {name: name}
+  }
   let verifyArgsAndParse = (~fragmentName as _Dog: [#Dog], value: Raw.t) => parse(value)
   let verifyName = x => switch x {
   | #Dog => ()
diff --git a/snapshot_tests/operations/expected/uncurried/generate/record.res.txt b/snapshot_tests/operations/expected/uncurried/generate/record.res.txt
index f8b76a95..c11046fe 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/record.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/record.res.txt
@@ -333,31 +333,27 @@ string
 int  
 }
 "
-    let parse = (
-      (value): t => {
-        string: {
-          let value = (value: Raw.t).string
-          value
-        },
-        int: {
-          let value = (value: Raw.t).int
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let int = {
-          let value = (value: t).int
-          value
-        }
-        and string = {
-          let value = (value: t).string
-          value
-        }
-        {string, int}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      string: {
+        let value = (value: Raw.t).string
+        value
+      },
+      int: {
+        let value = (value: Raw.t).int
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let int = {
+        let value = (value: t).int
+        value
+      }
+      and string = {
+        let value = (value: t).string
+        value
+      }
+      {string, int}
+    }
     let verifyArgsAndParse = (~fragmentName as _Fragment: [#Fragment], value: Raw.t) => parse(value)
     let verifyName = x => switch x {
     | #Fragment => ()
@@ -600,39 +596,35 @@ name
 barkVolume  
 }
 "
-    let parse = (
-      (value): t => {
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        barkVolume: {
-          let value = (value: Raw.t).barkVolume
-          value
-        },
-      }: Raw.t => t
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let barkVolume = {
-          let value = (value: t).barkVolume
-          value
-        }
-        and name = {
-          let value = (value: t).name
-          value
-        }
-        and __typename = {
-          let value = (value: t).__typename
-          value
-        }
-        {__typename, name, barkVolume}
-      }: t => Raw.t
-    )
+    let parse = (value): t => {
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      barkVolume: {
+        let value = (value: Raw.t).barkVolume
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let barkVolume = {
+        let value = (value: t).barkVolume
+        value
+      }
+      and name = {
+        let value = (value: t).name
+        value
+      }
+      and __typename = {
+        let value = (value: t).__typename
+        value
+      }
+      {__typename, name, barkVolume}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFragment: [#DogFragment], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/uncurried/generate/tagged_template.res.txt b/snapshot_tests/operations/expected/uncurried/generate/tagged_template.res.txt
index 6c3dd713..0aa5f74c 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/tagged_template.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/tagged_template.res.txt
@@ -1545,59 +1545,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment: [#ListFragment], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
@@ -1847,59 +1843,55 @@ nullableOfNonNullable
     ],
     [],
   )
-  let parse = (
-    (value): t => {
-      nullableOfNullable: {
-        let value = (value: Raw.t).nullableOfNullable
-        switch Js.toOption(value) {
-        | Some(value) =>
-          Some(
-            Js.Array2.map(value, value =>
-              switch Js.toOption(value) {
-              | Some(value) => Some(value)
-              | None => None
-              }
-            ),
-          )
-        | None => None
-        }
-      },
-      nullableOfNonNullable: {
-        let value = (value: Raw.t).nullableOfNonNullable
-        switch Js.toOption(value) {
-        | Some(value) => Some(Js.Array2.map(value, value => value))
-        | None => None
-        }
-      },
-    }: Raw.t => t
-  )
-  let serialize = (
-    (value): Raw.t => {
-      let nullableOfNonNullable = {
-        let value = (value: t).nullableOfNonNullable
-        switch value {
-        | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
-        | None => Js.Nullable.null
-        }
+  let parse = (value): t => {
+    nullableOfNullable: {
+      let value = (value: Raw.t).nullableOfNullable
+      switch Js.toOption(value) {
+      | Some(value) =>
+        Some(
+          Js.Array2.map(value, value =>
+            switch Js.toOption(value) {
+            | Some(value) => Some(value)
+            | None => None
+            }
+          ),
+        )
+      | None => None
       }
-      and nullableOfNullable = {
-        let value = (value: t).nullableOfNullable
-        switch value {
-        | Some(value) =>
-          Js.Nullable.return(
-            Js.Array2.map(value, value =>
-              switch value {
-              | Some(value) => Js.Nullable.return(value)
-              | None => Js.Nullable.null
-              }
-            ),
-          )
-        | None => Js.Nullable.null
-        }
+    },
+    nullableOfNonNullable: {
+      let value = (value: Raw.t).nullableOfNonNullable
+      switch Js.toOption(value) {
+      | Some(value) => Some(Js.Array2.map(value, value => value))
+      | None => None
       }
-      {nullableOfNullable, nullableOfNonNullable}
-    }: t => Raw.t
-  )
+    },
+  }
+  let serialize = (value): Raw.t => {
+    let nullableOfNonNullable = {
+      let value = (value: t).nullableOfNonNullable
+      switch value {
+      | Some(value) => Js.Nullable.return(Js.Array2.map(value, value => value))
+      | None => Js.Nullable.null
+      }
+    }
+    and nullableOfNullable = {
+      let value = (value: t).nullableOfNullable
+      switch value {
+      | Some(value) =>
+        Js.Nullable.return(
+          Js.Array2.map(value, value =>
+            switch value {
+            | Some(value) => Js.Nullable.return(value)
+            | None => Js.Nullable.null
+            }
+          ),
+        )
+      | None => Js.Nullable.null
+      }
+    }
+    {nullableOfNullable, nullableOfNonNullable}
+  }
   let verifyArgsAndParse = (~fragmentName as _ListFragment8: [#ListFragment8], value: Raw.t) =>
     parse(value)
   let verifyName = x => switch x {
diff --git a/snapshot_tests/operations/expected/uncurried/generate/union.res.txt b/snapshot_tests/operations/expected/uncurried/generate/union.res.txt
index b01f6a3c..16612a7a 100644
--- a/snapshot_tests/operations/expected/uncurried/generate/union.res.txt
+++ b/snapshot_tests/operations/expected/uncurried/generate/union.res.txt
@@ -541,31 +541,27 @@ name
 __typename  
 }
 "
-    let parse = (
-      (value): named => {
-        name: {
-          let value = (value: Raw.t).name
-          value
-        },
-        __typename: {
-          let value = (value: Raw.t).__typename
-          value
-        },
-      }: Raw.t => named
-    )
-    let serialize = (
-      (value): Raw.t => {
-        let __typename = {
-          let value = (value: named).__typename
-          value
-        }
-        and name = {
-          let value = (value: named).name
-          value
-        }
-        {name, __typename}
-      }: named => Raw.t
-    )
+    let parse = (value): named => {
+      name: {
+        let value = (value: Raw.t).name
+        value
+      },
+      __typename: {
+        let value = (value: Raw.t).__typename
+        value
+      },
+    }
+    let serialize = (value): Raw.t => {
+      let __typename = {
+        let value = (value: named).__typename
+        value
+      }
+      and name = {
+        let value = (value: named).name
+        value
+      }
+      {name, __typename}
+    }
     let verifyArgsAndParse = (~fragmentName as _DogFields: [#DogFields], value: Raw.t) =>
       parse(value)
     let verifyName = x => switch x {
diff --git a/src/ppx/output_module.ml b/src/ppx/output_module.ml
index 29fdabd2..74942dbe 100644
--- a/src/ppx/output_module.ml
+++ b/src/ppx/output_module.ml
@@ -45,23 +45,23 @@ let pretty_print (query : string) : string =
     |> List.map (fun l -> String.trim l)
     |> List.filter (fun l -> l <> "")
     |> List.map (fun line ->
-         let prevIndent = !indent in
-         String.iter
-           (function
-             | '{' -> indent := !indent + 1
-             | '}' -> indent := !indent - 1
-             | _ -> ())
-           line;
-         let currIndent =
-           match prevIndent < !indent with
-           | true -> prevIndent
-           | false -> !indent
-         in
-         let currIndent =
-           match currIndent < 1 with true -> 1 | false -> currIndent
-         in
-         let line = String.make (currIndent * 2) ' ' ^ line in
-         line)
+           let prevIndent = !indent in
+           String.iter
+             (function
+               | '{' -> indent := !indent + 1
+               | '}' -> indent := !indent - 1
+               | _ -> ())
+             line;
+           let currIndent =
+             match prevIndent < !indent with
+             | true -> prevIndent
+             | false -> !indent
+           in
+           let currIndent =
+             match currIndent < 1 with true -> 1 | false -> currIndent
+           in
+           let line = String.make (currIndent * 2) ' ' ^ line in
+           line)
     |> String.concat "\n"
   in
   str ^ "\n"
@@ -170,12 +170,12 @@ let rec emit_json config = function
       Ast_helper.Exp.array
         (vs
         |> List.map (fun (key, value) ->
-             Ast_helper.Exp.tuple
-               [
-                 Ast_helper.Exp.constant
-                   (Pconst_string (key, Location.none, None));
-                 emit_json config value;
-               ]))
+               Ast_helper.Exp.tuple
+                 [
+                   Ast_helper.Exp.constant
+                     (Pconst_string (key, Location.none, None));
+                   emit_json config value;
+                 ]))
     in
     add_uapp [%expr Js.Json.object_ (Js.Dict.fromArray [%e pairs])]
   | `List ls ->
@@ -565,19 +565,19 @@ let generate_operation_signature config variable_defs res_structure =
                 | (_, Some _, _), Some return_type ->
                   return_type
                 | _ -> "string")]
-            [@@ocaml.doc " The GraphQL query "]];
+          [@@ocaml.doc " The GraphQL query "]];
       wrap_sig_uncurried_fn
         [%sigi:
           val parse : Raw.t -> t
-            [@@ocaml.doc
-              " Parse the JSON-compatible GraphQL data to ReasonML data types "]];
+          [@@ocaml.doc
+            " Parse the JSON-compatible GraphQL data to ReasonML data types "]];
       wrap_sig_uncurried_fn
         [%sigi:
           val serialize : t -> Raw.t
-            [@@ocaml.doc
-              " Serialize the ReasonML GraphQL data that was parsed using the \
-               parse\n\
-               function back to the original JSON compatible data "]];
+          [@@ocaml.doc
+            " Serialize the ReasonML GraphQL data that was parsed using the \
+             parse\n\
+             function back to the original JSON compatible data "]];
     ];
     serialize_variable_signatures;
     (match variable_constructor_signatures with
@@ -901,14 +901,16 @@ let generate_fragment_signature config name variable_definitions _has_error
                 | (_, Some _, _), Some return_type ->
                   return_type
                 | _ -> "string")]
-            [@@ocaml.doc " the GraphQL fragment "]];
-        [%sigi:
-          val parse : Raw.t -> [%t type_name]
+          [@@ocaml.doc " the GraphQL fragment "]];
+        wrap_sig_uncurried_fn
+          [%sigi:
+            val parse : Raw.t -> [%t type_name]
             [@@ocaml.doc
               " Parse the raw JSON-compatible GraphQL data into ReasonML data \
                types "]];
-        [%sigi:
-          val serialize : [%t type_name] -> Raw.t
+        wrap_sig_uncurried_fn
+          [%sigi:
+            val serialize : [%t type_name] -> Raw.t
             [@@ocaml.doc
               " Serialize the ReasonML GraphQL data that was parsed using the \
                parse\n\
@@ -1015,7 +1017,6 @@ let generate_fragment_implementation config name
              None);
       ]
   in
-  let type_name = base_type_name (Option.get_or_else "t" type_name) in
   let contents =
     [
       [ [%stri [@@@ocaml.warning "-32-30"]] ];
@@ -1024,13 +1025,8 @@ let generate_fragment_implementation config name
       graphql_external config (Graphql_ast.Fragment fragment);
       [
         [%stri let query = [%e printed_query]];
-        wrap_as_uncurried_fn
-          [%stri
-            let parse = (fun value -> [%e parse_fn] : Raw.t -> [%t type_name])];
-        wrap_as_uncurried_fn
-          [%stri
-            let serialize =
-              (fun value -> [%e serialize_fn] : [%t type_name] -> Raw.t)];
+        wrap_as_uncurried_fn [%stri let parse value = [%e parse_fn]];
+        wrap_as_uncurried_fn [%stri let serialize value = [%e serialize_fn]];
       ];
       [
         [%stri let verifyArgsAndParse = [%e verify_parse]];
@@ -1116,22 +1112,22 @@ let generate_modules module_name module_type operations =
     let contents =
       operations
       |> List.map (fun (operation, config) ->
-           (generate_definition config operation, config))
+             (generate_definition config operation, config))
       |> List.mapi
            (fun i (((definition, name, contents, loc), signature), config) ->
-           let module_type =
-             match module_type with
-             | Some module_type -> module_type
-             | None -> Ast_helper.Mty.mk (Pmty_signature signature)
-           in
-           match name with
-           | Some name ->
-             wrap_query_module ~loc ~module_type definition (Some name) contents
-               config
-           | None ->
-             wrap_query_module ~loc ~module_type definition
-               (Some ("Untitled" ^ string_of_int i))
-               contents config)
+             let module_type =
+               match module_type with
+               | Some module_type -> module_type
+               | None -> Ast_helper.Mty.mk (Pmty_signature signature)
+             in
+             match name with
+             | Some name ->
+               wrap_query_module ~loc ~module_type definition (Some name)
+                 contents config
+             | None ->
+               wrap_query_module ~loc ~module_type definition
+                 (Some ("Untitled" ^ string_of_int i))
+                 contents config)
       |> List.concat
     in
     match module_name with
@@ -1157,16 +1153,16 @@ let generate_module_interfaces module_name operations =
     let contents =
       operations
       |> List.map (fun (operation, config) ->
-           (generate_definition config operation, config))
+             (generate_definition config operation, config))
       |> List.mapi (fun i (((definition, name, _, _), signature), config) ->
-           match name with
-           | Some name ->
-             wrap_query_module_signature ~signature definition (Some name)
-               config
-           | None ->
-             wrap_query_module_signature ~signature definition
-               (Some ("Untitled" ^ string_of_int i))
-               config)
+             match name with
+             | Some name ->
+               wrap_query_module_signature ~signature definition (Some name)
+                 config
+             | None ->
+               wrap_query_module_signature ~signature definition
+                 (Some ("Untitled" ^ string_of_int i))
+                 config)
       |> List.concat
     in
     match module_name with