---
With {
 expression: FunctionApplication {
  function: Variable {
   identifier: "import",
   position: (4, 6),
  },
  arguments: [
   Path {
    parts: [
     Raw {
      content: "../default.nix",
      position: (4, 13),
     },
    ],
    position: (4, 13),
   },
  ],
 },
 target: LetIn {
  bindings: [
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "testSanitizeDerivationName",
       position: (8, 3),
      },
     ],
    },
    to: Function {
     argument: Destructured {
      identifier: None,
      arguments: [
       DestructuredArgument {
        identifier: "name",
        default: None,
       },
       DestructuredArgument {
        identifier: "expected",
        default: None,
       },
      ],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "drv",
           position: (10, 5),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "derivation",
          position: (10, 11),
         },
         arguments: [
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "name",
                position: (11, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "strings",
                position: (11, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "sanitizeDerivationName",
                  position: (11, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "name",
                position: (11, 45),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "builder",
                position: (12, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "x",
                position: (12, 18),
               },
              ],
              position: (12, 17),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "system",
                position: (13, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "x",
                position: (13, 17),
               },
              ],
              position: (13, 16),
             },
            },
           ],
           recursive: false,
           position: (10, 22),
          },
         ],
        },
       },
      ],
      target: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "expr",
            position: (17, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (17, 12),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "seq",
              position: (17, 21),
             },
            ],
           },
           default: None,
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "drv",
             position: (17, 25),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "drvPath",
               position: (17, 29),
              },
             ],
            },
            default: None,
           },
           PropertyAccess {
            expression: Variable {
             identifier: "drv",
             position: (17, 37),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (17, 41),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Inherit {
         from: None,
         attributes: [
          Raw {
           content: "expected",
           position: (18, 13),
          },
         ],
        },
       ],
       recursive: false,
       position: (15, 6),
      },
      position: (9, 3),
     },
     position: (8, 32),
    },
   },
  ],
  target: FunctionApplication {
   function: Variable {
    identifier: "runTests",
    position: (23, 1),
   },
   arguments: [
    Map {
     bindings: [
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testId",
          position: (28, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (29, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "id",
            position: (29, 12),
           },
           arguments: [
            Int {
             value: 1,
             position: (29, 15),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (30, 5),
            },
           ],
          },
          to: Int {
           value: 1,
           position: (30, 16),
          },
         },
        ],
        recursive: false,
        position: (28, 12),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testConst",
          position: (33, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (34, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "const",
            position: (34, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (34, 18),
            },
            Int {
             value: 3,
             position: (34, 20),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (35, 5),
            },
           ],
          },
          to: Int {
           value: 2,
           position: (35, 16),
          },
         },
        ],
        recursive: false,
        position: (33, 15),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testPipe",
          position: (38, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (39, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "pipe",
            position: (39, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (39, 17),
            },
            List {
             elements: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "x",
                },
                definition: BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "x",
                   position: (40, 11),
                  },
                  Int {
                   value: 2,
                   position: (40, 15),
                  },
                 ],
                 position: (40, 13),
                },
                position: (40, 8),
               },
               position: (40, 7),
              },
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "x",
                },
                definition: BinaryOperation {
                 operator: Multiplication,
                 operands: [
                  Variable {
                   identifier: "x",
                   position: (41, 11),
                  },
                  Int {
                   value: 2,
                   position: (41, 15),
                  },
                 ],
                 position: (41, 13),
                },
                position: (41, 8),
               },
               position: (41, 7),
              },
             ],
             position: (39, 19),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (43, 5),
            },
           ],
          },
          to: Int {
           value: 8,
           position: (43, 16),
          },
         },
        ],
        recursive: false,
        position: (38, 14),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testPipeEmpty",
          position: (46, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (47, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "pipe",
            position: (47, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (47, 17),
            },
            List {
             elements: [],
             position: (47, 19),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (48, 5),
            },
           ],
          },
          to: Int {
           value: 2,
           position: (48, 16),
          },
         },
        ],
        recursive: false,
        position: (46, 19),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testPipeStrings",
          position: (51, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (52, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "pipe",
            position: (52, 12),
           },
           arguments: [
            List {
             elements: [
              Int {
               value: 3,
               position: (52, 19),
              },
              Int {
               value: 4,
               position: (52, 21),
              },
             ],
             position: (52, 17),
            },
            List {
             elements: [
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (53, 8),
                },
                arguments: [
                 Variable {
                  identifier: "toString",
                  position: (53, 12),
                 },
                ],
               },
               position: (53, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (54, 8),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "s",
                   },
                   definition: BinaryOperation {
                    operator: Addition,
                    operands: [
                     Variable {
                      identifier: "s",
                      position: (54, 16),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "\n",
                        position: (54, 21),
                       },
                      ],
                      position: (54, 20),
                     },
                    ],
                    position: (54, 18),
                   },
                   position: (54, 13),
                  },
                  position: (54, 12),
                 },
                ],
               },
               position: (54, 7),
              },
              Variable {
               identifier: "concatStrings",
               position: (55, 7),
              },
             ],
             position: (52, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (57, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "3\n4\n",
             position: (58, 1),
            },
           ],
           position: (57, 16),
          },
         },
        ],
        recursive: false,
        position: (51, 21),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testAnd",
          position: (70, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (71, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "and",
            position: (71, 12),
           },
           arguments: [
            Variable {
             identifier: "true",
             position: (71, 16),
            },
            Variable {
             identifier: "false",
             position: (71, 21),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (72, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (72, 16),
          },
         },
        ],
        recursive: false,
        position: (70, 13),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFix",
          position: (75, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (76, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "fix",
            position: (76, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "a",
                    position: (76, 21),
                   },
                  ],
                 },
                 to: IfThenElse {
                  predicate: HasProperty {
                   expression: Variable {
                    identifier: "x",
                    position: (76, 28),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "a",
                      position: (76, 32),
                     },
                    ],
                   },
                   position: (76, 30),
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "a",
                     position: (76, 40),
                    },
                   ],
                   position: (76, 39),
                  },
                  else_: String {
                   parts: [
                    Raw {
                     content: "b",
                     position: (76, 49),
                    },
                   ],
                   position: (76, 48),
                  },
                  position: (76, 25),
                 },
                },
               ],
               recursive: false,
               position: (76, 20),
              },
              position: (76, 17),
             },
             position: (76, 16),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (77, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (77, 17),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "a",
                position: (77, 22),
               },
              ],
              position: (77, 21),
             },
            },
           ],
           recursive: false,
           position: (77, 16),
          },
         },
        ],
        recursive: false,
        position: (75, 13),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testComposeExtensions",
          position: (80, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (81, 5),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "obj",
                position: (81, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "makeExtensible",
               position: (81, 22),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "self",
                 },
                 definition: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "foo",
                       position: (81, 46),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "self",
                      position: (81, 52),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "bar",
                        position: (81, 57),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                  recursive: false,
                  position: (81, 44),
                 },
                 position: (81, 38),
                },
                position: (81, 37),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "f",
                position: (82, 16),
               },
              ],
             },
             to: Function {
              argument: Simple {
               identifier: "self",
              },
              definition: Function {
               argument: Simple {
                identifier: "super",
               },
               definition: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "bar",
                     position: (82, 35),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "false",
                   position: (82, 41),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "baz",
                     position: (82, 48),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (82, 54),
                  },
                 },
                ],
                recursive: false,
                position: (82, 33),
               },
               position: (82, 26),
              },
              position: (82, 20),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "g",
                position: (83, 16),
               },
              ],
             },
             to: Function {
              argument: Simple {
               identifier: "self",
              },
              definition: Function {
               argument: Simple {
                identifier: "super",
               },
               definition: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "bar",
                     position: (83, 35),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "super",
                    position: (83, 41),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "baz",
                      position: (83, 47),
                     },
                    ],
                   },
                   default: Some(
                    Variable {
                     identifier: "false",
                     position: (83, 54),
                    },
                   ),
                  },
                 },
                ],
                recursive: false,
                position: (83, 33),
               },
               position: (83, 26),
              },
              position: (83, 20),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "f_o_g",
                position: (84, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "composeExtensions",
               position: (84, 24),
              },
              arguments: [
               Variable {
                identifier: "f",
                position: (84, 42),
               },
               Variable {
                identifier: "g",
                position: (84, 44),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "composed",
                position: (85, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "obj",
                position: (85, 27),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "extend",
                  position: (85, 31),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "f_o_g",
                position: (85, 38),
               },
              ],
             },
            },
           ],
           target: PropertyAccess {
            expression: Variable {
             identifier: "composed",
             position: (86, 15),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "foo",
               position: (86, 24),
              },
             ],
            },
            default: None,
           },
           position: (81, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (87, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (87, 16),
          },
         },
        ],
        recursive: false,
        position: (80, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testComposeManyExtensions0",
          position: (90, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (91, 5),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "obj",
                position: (91, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "makeExtensible",
               position: (91, 22),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "self",
                 },
                 definition: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "foo",
                       position: (91, 46),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (91, 52),
                    },
                   },
                  ],
                  recursive: false,
                  position: (91, 44),
                 },
                 position: (91, 38),
                },
                position: (91, 37),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "emptyComposition",
                position: (92, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "composeManyExtensions",
               position: (92, 35),
              },
              arguments: [
               List {
                elements: [],
                position: (92, 57),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "composed",
                position: (93, 16),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "obj",
                position: (93, 27),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "extend",
                  position: (93, 31),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "emptyComposition",
                position: (93, 38),
               },
              ],
             },
            },
           ],
           target: PropertyAccess {
            expression: Variable {
             identifier: "composed",
             position: (94, 15),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "foo",
               position: (94, 24),
              },
             ],
            },
            default: None,
           },
           position: (91, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (95, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (95, 16),
          },
         },
        ],
        recursive: false,
        position: (90, 32),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testComposeManyExtensions",
          position: (98, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "f",
             position: (99, 9),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "self",
           },
           definition: Function {
            argument: Simple {
             identifier: "super",
            },
            definition: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "bar",
                  position: (99, 28),
                 },
                ],
               },
               to: Variable {
                identifier: "false",
                position: (99, 34),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "baz",
                  position: (99, 41),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (99, 47),
               },
              },
             ],
             recursive: false,
             position: (99, 26),
            },
            position: (99, 19),
           },
           position: (99, 13),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "g",
             position: (100, 9),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "self",
           },
           definition: Function {
            argument: Simple {
             identifier: "super",
            },
            definition: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "bar",
                  position: (100, 28),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "super",
                 position: (100, 34),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "baz",
                   position: (100, 40),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "false",
                  position: (100, 47),
                 },
                ),
               },
              },
             ],
             recursive: false,
             position: (100, 26),
            },
            position: (100, 19),
           },
           position: (100, 13),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "h",
             position: (101, 9),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "self",
           },
           definition: Function {
            argument: Simple {
             identifier: "super",
            },
            definition: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "qux",
                  position: (101, 28),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "super",
                 position: (101, 34),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "bar",
                   position: (101, 40),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "false",
                  position: (101, 47),
                 },
                ),
               },
              },
             ],
             recursive: false,
             position: (101, 26),
            },
            position: (101, 19),
           },
           position: (101, 13),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "obj",
             position: (102, 9),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "makeExtensible",
            position: (102, 15),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "self",
              },
              definition: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "foo",
                    position: (102, 39),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "self",
                   position: (102, 45),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "qux",
                     position: (102, 50),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (102, 37),
              },
              position: (102, 31),
             },
             position: (102, 30),
            },
           ],
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (104, 5),
             },
            ],
           },
           to: LetIn {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "composition",
                 position: (104, 16),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "composeManyExtensions",
                position: (104, 30),
               },
               arguments: [
                List {
                 elements: [
                  Variable {
                   identifier: "f",
                   position: (104, 53),
                  },
                  Variable {
                   identifier: "g",
                   position: (104, 55),
                  },
                  Variable {
                   identifier: "h",
                   position: (104, 57),
                  },
                 ],
                 position: (104, 52),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "composed",
                 position: (105, 16),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "obj",
                 position: (105, 27),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "extend",
                   position: (105, 31),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "composition",
                 position: (105, 38),
                },
               ],
              },
             },
            ],
            target: PropertyAccess {
             expression: Variable {
              identifier: "composed",
              position: (106, 15),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "foo",
                position: (106, 24),
               },
              ],
             },
             default: None,
            },
            position: (104, 12),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (107, 5),
             },
            ],
           },
           to: PropertyAccess {
            expression: Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "obj",
                position: (107, 17),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "extend",
                  position: (107, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "composeExtensions",
                  position: (107, 29),
                 },
                 arguments: [
                  Variable {
                   identifier: "f",
                   position: (107, 47),
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "composeExtensions",
                     position: (107, 50),
                    },
                    arguments: [
                     Variable {
                      identifier: "g",
                      position: (107, 68),
                     },
                     Variable {
                      identifier: "h",
                      position: (107, 70),
                     },
                    ],
                   },
                   position: (107, 49),
                  },
                 ],
                },
                position: (107, 28),
               },
              ],
             },
             position: (107, 16),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "foo",
               position: (107, 75),
              },
             ],
            },
            default: None,
           },
          },
         ],
         recursive: false,
         position: (103, 8),
        },
        position: (99, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testBitAnd",
          position: (110, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (111, 5),
            },
           ],
          },
          to: Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "bitAnd",
             position: (111, 13),
            },
            arguments: [
             Int {
              value: 3,
              position: (111, 20),
             },
             Int {
              value: 10,
              position: (111, 22),
             },
            ],
           },
           position: (111, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (112, 5),
            },
           ],
          },
          to: Int {
           value: 2,
           position: (112, 16),
          },
         },
        ],
        recursive: false,
        position: (110, 16),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testBitOr",
          position: (115, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (116, 5),
            },
           ],
          },
          to: Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "bitOr",
             position: (116, 13),
            },
            arguments: [
             Int {
              value: 3,
              position: (116, 19),
             },
             Int {
              value: 10,
              position: (116, 21),
             },
            ],
           },
           position: (116, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (117, 5),
            },
           ],
          },
          to: Int {
           value: 11,
           position: (117, 16),
          },
         },
        ],
        recursive: false,
        position: (115, 15),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testBitXor",
          position: (120, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (121, 5),
            },
           ],
          },
          to: Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "bitXor",
             position: (121, 13),
            },
            arguments: [
             Int {
              value: 3,
              position: (121, 20),
             },
             Int {
              value: 10,
              position: (121, 22),
             },
            ],
           },
           position: (121, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (122, 5),
            },
           ],
          },
          to: Int {
           value: 9,
           position: (122, 16),
          },
         },
        ],
        recursive: false,
        position: (120, 16),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToHexString",
          position: (125, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (126, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "toHexString",
            position: (126, 12),
           },
           arguments: [
            Int {
             value: 250,
             position: (126, 24),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (127, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "FA",
             position: (127, 17),
            },
           ],
           position: (127, 16),
          },
         },
        ],
        recursive: false,
        position: (125, 21),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToBaseDigits",
          position: (130, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (131, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "toBaseDigits",
            position: (131, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (131, 25),
            },
            Int {
             value: 6,
             position: (131, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (132, 5),
            },
           ],
          },
          to: List {
           elements: [
            Int {
             value: 1,
             position: (132, 18),
            },
            Int {
             value: 1,
             position: (132, 20),
            },
            Int {
             value: 0,
             position: (132, 22),
            },
           ],
           position: (132, 16),
          },
         },
        ],
        recursive: false,
        position: (130, 22),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFunctionArgsFunctor",
          position: (135, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (136, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "functionArgs",
            position: (136, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "__functor",
                  position: (136, 27),
                 },
                ],
               },
               to: Function {
                argument: Simple {
                 identifier: "self",
                },
                definition: Function {
                 argument: Destructured {
                  identifier: None,
                  arguments: [
                   DestructuredArgument {
                    identifier: "a",
                    default: None,
                   },
                   DestructuredArgument {
                    identifier: "b",
                    default: None,
                   },
                  ],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "null",
                  position: (136, 55),
                 },
                 position: (136, 45),
                },
                position: (136, 39),
               },
              },
             ],
             recursive: false,
             position: (136, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (137, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (137, 18),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (137, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "b",
                position: (137, 29),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (137, 33),
             },
            },
           ],
           recursive: false,
           position: (137, 16),
          },
         },
        ],
        recursive: false,
        position: (135, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFunctionArgsSetFunctionArgs",
          position: (140, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (141, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "functionArgs",
            position: (141, 12),
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "setFunctionArgs",
               position: (141, 26),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "args",
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "args",
                   position: (141, 49),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "x",
                     position: (141, 54),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (141, 43),
                },
                position: (141, 42),
               },
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "x",
                     position: (141, 59),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "false",
                   position: (141, 63),
                  },
                 },
                ],
                recursive: false,
                position: (141, 57),
               },
              ],
             },
             position: (141, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (142, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "x",
                position: (142, 18),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (142, 22),
             },
            },
           ],
           recursive: false,
           position: (142, 16),
          },
         },
        ],
        recursive: false,
        position: (140, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testConcatMapStrings",
          position: (147, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (148, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "concatMapStrings",
            position: (148, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: BinaryOperation {
               operator: Addition,
               operands: [
                Variable {
                 identifier: "x",
                 position: (148, 33),
                },
                String {
                 parts: [
                  Raw {
                   content: ";",
                   position: (148, 38),
                  },
                 ],
                 position: (148, 37),
                },
               ],
               position: (148, 35),
              },
              position: (148, 30),
             },
             position: (148, 29),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (148, 44),
                },
               ],
               position: (148, 43),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (148, 48),
                },
               ],
               position: (148, 47),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (148, 52),
                },
               ],
               position: (148, 51),
              },
             ],
             position: (148, 42),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (149, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "a;b;c;",
             position: (149, 17),
            },
           ],
           position: (149, 16),
          },
         },
        ],
        recursive: false,
        position: (147, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testConcatStringsSep",
          position: (152, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (153, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (153, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",",
               position: (153, 30),
              },
             ],
             position: (153, 29),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (153, 35),
                },
               ],
               position: (153, 34),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (153, 39),
                },
               ],
               position: (153, 38),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (153, 43),
                },
               ],
               position: (153, 42),
              },
             ],
             position: (153, 33),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (154, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "a,b,c",
             position: (154, 17),
            },
           ],
           position: (154, 16),
          },
         },
        ],
        recursive: false,
        position: (152, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsSimple",
          position: (157, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (158, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (158, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (158, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
               position: (158, 33),
              },
             ],
             position: (158, 32),
            },
            String {
             parts: [
              Raw {
               content: "a.b.c.d",
               position: (158, 37),
              },
             ],
             position: (158, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (159, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
               position: (159, 19),
              },
             ],
             position: (159, 18),
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (159, 23),
              },
             ],
             position: (159, 22),
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (159, 27),
              },
             ],
             position: (159, 26),
            },
            String {
             parts: [
              Raw {
               content: "d",
               position: (159, 31),
              },
             ],
             position: (159, 30),
            },
           ],
           position: (159, 16),
          },
         },
        ],
        recursive: false,
        position: (157, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsEmpty",
          position: (162, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (163, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (163, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (163, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
               position: (163, 33),
              },
             ],
             position: (163, 32),
            },
            String {
             parts: [
              Raw {
               content: "a..b",
               position: (163, 37),
              },
             ],
             position: (163, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (164, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
               position: (164, 19),
              },
             ],
             position: (164, 18),
            },
            String {
             parts: [],
             position: (164, 22),
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (164, 26),
              },
             ],
             position: (164, 25),
            },
           ],
           position: (164, 16),
          },
         },
        ],
        recursive: false,
        position: (162, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsOne",
          position: (167, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (168, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (168, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (168, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ":",
               position: (168, 33),
              },
             ],
             position: (168, 32),
            },
            String {
             parts: [
              Raw {
               content: "a.b",
               position: (168, 37),
              },
             ],
             position: (168, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (169, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a.b",
               position: (169, 19),
              },
             ],
             position: (169, 18),
            },
           ],
           position: (169, 16),
          },
         },
        ],
        recursive: false,
        position: (167, 25),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsNone",
          position: (172, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (173, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (173, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (173, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
               position: (173, 33),
              },
             ],
             position: (173, 32),
            },
            String {
             parts: [],
             position: (173, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (174, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [],
             position: (174, 18),
            },
           ],
           position: (174, 16),
          },
         },
        ],
        recursive: false,
        position: (172, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsFirstEmpty",
          position: (177, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (178, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (178, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (178, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "/",
               position: (178, 33),
              },
             ],
             position: (178, 32),
            },
            String {
             parts: [
              Raw {
               content: "/a/b/c",
               position: (178, 37),
              },
             ],
             position: (178, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (179, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [],
             position: (179, 18),
            },
            String {
             parts: [
              Raw {
               content: "a",
               position: (179, 22),
              },
             ],
             position: (179, 21),
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (179, 26),
              },
             ],
             position: (179, 25),
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (179, 30),
              },
             ],
             position: (179, 29),
            },
           ],
           position: (179, 16),
          },
         },
        ],
        recursive: false,
        position: (177, 32),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsLastEmpty",
          position: (182, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (183, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (183, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (183, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ":",
               position: (183, 33),
              },
             ],
             position: (183, 32),
            },
            String {
             parts: [
              Raw {
               content: "2001:db8:0:0042::8a2e:370:",
               position: (183, 37),
              },
             ],
             position: (183, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (184, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "2001",
               position: (184, 19),
              },
             ],
             position: (184, 18),
            },
            String {
             parts: [
              Raw {
               content: "db8",
               position: (184, 26),
              },
             ],
             position: (184, 25),
            },
            String {
             parts: [
              Raw {
               content: "0",
               position: (184, 32),
              },
             ],
             position: (184, 31),
            },
            String {
             parts: [
              Raw {
               content: "0042",
               position: (184, 36),
              },
             ],
             position: (184, 35),
            },
            String {
             parts: [],
             position: (184, 42),
            },
            String {
             parts: [
              Raw {
               content: "8a2e",
               position: (184, 46),
              },
             ],
             position: (184, 45),
            },
            String {
             parts: [
              Raw {
               content: "370",
               position: (184, 53),
              },
             ],
             position: (184, 52),
            },
            String {
             parts: [],
             position: (184, 58),
            },
           ],
           position: (184, 16),
          },
         },
        ],
        recursive: false,
        position: (182, 31),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsRegex",
          position: (187, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (188, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (188, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitString",
               position: (188, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\\[{}]()^$?*+|.",
               position: (188, 33),
              },
             ],
             position: (188, 32),
            },
            String {
             parts: [
              Raw {
               content: "A\\[{}]()^$?*+|.B",
               position: (188, 51),
              },
             ],
             position: (188, 50),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (189, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "A",
               position: (189, 19),
              },
             ],
             position: (189, 18),
            },
            String {
             parts: [
              Raw {
               content: "B",
               position: (189, 23),
              },
             ],
             position: (189, 22),
            },
           ],
           position: (189, 16),
          },
         },
        ],
        recursive: false,
        position: (187, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitStringsDerivation",
          position: (192, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (193, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "take",
            position: (193, 12),
           },
           arguments: [
            Int {
             value: 3,
             position: (193, 17),
            },
            Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "strings",
                position: (193, 21),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "splitString",
                  position: (193, 29),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "/",
                  position: (193, 42),
                 },
                ],
                position: (193, 41),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "derivation",
                  position: (193, 46),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "name",
                        position: (194, 7),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "name",
                        position: (194, 15),
                       },
                      ],
                      position: (194, 14),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "builder",
                        position: (195, 7),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "builder",
                        position: (195, 18),
                       },
                      ],
                      position: (195, 17),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "system",
                        position: (196, 7),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "system",
                        position: (196, 17),
                       },
                      ],
                      position: (196, 16),
                     },
                    },
                   ],
                   recursive: false,
                   position: (193, 57),
                  },
                 ],
                },
                position: (193, 45),
               },
              ],
             },
             position: (193, 20),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (198, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [],
             position: (198, 17),
            },
            String {
             parts: [
              Raw {
               content: "nix",
               position: (198, 21),
              },
             ],
             position: (198, 20),
            },
            String {
             parts: [
              Raw {
               content: "store",
               position: (198, 27),
              },
             ],
             position: (198, 26),
            },
           ],
           position: (198, 16),
          },
         },
        ],
        recursive: false,
        position: (192, 32),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitVersionSingle",
          position: (201, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (202, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (202, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitVersion",
               position: (202, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (202, 35),
              },
             ],
             position: (202, 34),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (203, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (203, 19),
              },
             ],
             position: (203, 18),
            },
           ],
           position: (203, 16),
          },
         },
        ],
        recursive: false,
        position: (201, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitVersionDouble",
          position: (206, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (207, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (207, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitVersion",
               position: (207, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1.2",
               position: (207, 35),
              },
             ],
             position: (207, 34),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (208, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (208, 19),
              },
             ],
             position: (208, 18),
            },
            String {
             parts: [
              Raw {
               content: "2",
               position: (208, 23),
              },
             ],
             position: (208, 22),
            },
           ],
           position: (208, 16),
          },
         },
        ],
        recursive: false,
        position: (206, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSplitVersionTriple",
          position: (211, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (212, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (212, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "splitVersion",
               position: (212, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1.2.3",
               position: (212, 35),
              },
             ],
             position: (212, 34),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (213, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (213, 19),
              },
             ],
             position: (213, 18),
            },
            String {
             parts: [
              Raw {
               content: "2",
               position: (213, 23),
              },
             ],
             position: (213, 22),
            },
            String {
             parts: [
              Raw {
               content: "3",
               position: (213, 27),
              },
             ],
             position: (213, 26),
            },
           ],
           position: (213, 16),
          },
         },
        ],
        recursive: false,
        position: (211, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testIsStorePath",
          position: (216, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (217, 5),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "goodPath",
                position: (218, 11),
               },
              ],
             },
             to: String {
              parts: [
               Interpolation {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (219, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "storeDir",
                    position: (219, 25),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11",
                position: (219, 34),
               },
              ],
              position: (219, 13),
             },
            },
           ],
           target: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "storePath",
                 position: (221, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (221, 21),
               },
               arguments: [
                Variable {
                 identifier: "goodPath",
                 position: (221, 33),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "storePathDerivation",
                 position: (222, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (222, 31),
               },
               arguments: [
                PropertyAccess {
                 expression: Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "import",
                    position: (222, 44),
                   },
                   arguments: [
                    Path {
                     parts: [
                      Raw {
                       content: "../..",
                       position: (222, 51),
                      },
                     ],
                     position: (222, 51),
                    },
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "system",
                          position: (222, 59),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "x86_64-linux",
                          position: (222, 69),
                         },
                        ],
                        position: (222, 68),
                       },
                      },
                     ],
                     recursive: false,
                     position: (222, 57),
                    },
                   ],
                  },
                  position: (222, 43),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "hello",
                    position: (222, 87),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "storePathAppendix",
                 position: (223, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (223, 29),
               },
               arguments: [
                String {
                 parts: [
                  Interpolation {
                   expression: Variable {
                    identifier: "goodPath",
                    position: (224, 14),
                   },
                  },
                  Raw {
                   content: "/bin/python",
                   position: (224, 23),
                  },
                 ],
                 position: (224, 11),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAbsolute",
                 position: (225, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (225, 23),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "concatStrings",
                   position: (225, 36),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "tail",
                      position: (225, 51),
                     },
                     arguments: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "stringToCharacters",
                         position: (225, 57),
                        },
                        arguments: [
                         Variable {
                          identifier: "goodPath",
                          position: (225, 76),
                         },
                        ],
                       },
                       position: (225, 56),
                      },
                     ],
                    },
                    position: (225, 50),
                   },
                  ],
                 },
                 position: (225, 35),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "asPath",
                 position: (226, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (226, 18),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: Addition,
                  operands: [
                   Path {
                    parts: [
                     Raw {
                      content: "/.",
                      position: (226, 31),
                     },
                    ],
                    position: (226, 31),
                   },
                   Variable {
                    identifier: "goodPath",
                    position: (226, 36),
                   },
                  ],
                  position: (226, 34),
                 },
                 position: (226, 30),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "otherPath",
                 position: (227, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (227, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "/something/else",
                   position: (227, 34),
                  },
                 ],
                 position: (227, 33),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "otherVals",
                 position: (228, 9),
                },
               ],
              },
              to: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "attrset",
                    position: (229, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "isStorePath",
                   position: (229, 21),
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (229, 33),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "list",
                    position: (230, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "isStorePath",
                   position: (230, 18),
                  },
                  arguments: [
                   List {
                    elements: [],
                    position: (230, 30),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "int",
                    position: (231, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "isStorePath",
                   position: (231, 17),
                  },
                  arguments: [
                   Int {
                    value: 42,
                    position: (231, 29),
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (228, 21),
              },
             },
            ],
            recursive: false,
            position: (220, 10),
           },
           position: (218, 7),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (234, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "storePath",
                position: (235, 7),
               },
              ],
             },
             to: Variable {
              identifier: "true",
              position: (235, 19),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "storePathDerivation",
                position: (236, 7),
               },
              ],
             },
             to: Variable {
              identifier: "true",
              position: (236, 29),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "storePathAppendix",
                position: (237, 7),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (237, 27),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "nonAbsolute",
                position: (238, 7),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (238, 21),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "asPath",
                position: (239, 7),
               },
              ],
             },
             to: Variable {
              identifier: "true",
              position: (239, 16),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "otherPath",
                position: (240, 7),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (240, 19),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "otherVals",
                position: (241, 7),
               },
              ],
             },
             to: Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "attrset",
                   position: (242, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "false",
                 position: (242, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "list",
                   position: (243, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "false",
                 position: (243, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "int",
                   position: (244, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "false",
                 position: (244, 15),
                },
               },
              ],
              recursive: false,
              position: (241, 19),
             },
            },
           ],
           recursive: false,
           position: (234, 16),
          },
         },
        ],
        recursive: false,
        position: (216, 22),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testEscapeXML",
          position: (249, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (250, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "escapeXML",
            position: (250, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\"test\" 'test' < & >",
               position: (250, 24),
              },
             ],
             position: (250, 22),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (251, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "&quot;test&quot; &apos;test&apos; &lt; &amp; &gt;",
             position: (251, 17),
            },
           ],
           position: (251, 16),
          },
         },
        ],
        recursive: false,
        position: (249, 19),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFilter",
          position: (256, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (257, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "filter",
            position: (257, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                Variable {
                 identifier: "x",
                 position: (257, 23),
                },
                String {
                 parts: [
                  Raw {
                   content: "a",
                   position: (257, 29),
                  },
                 ],
                 position: (257, 28),
                },
               ],
               position: (257, 25),
              },
              position: (257, 20),
             },
             position: (257, 19),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (257, 35),
                },
               ],
               position: (257, 34),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (257, 39),
                },
               ],
               position: (257, 38),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (257, 43),
                },
               ],
               position: (257, 42),
              },
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (257, 47),
                },
               ],
               position: (257, 46),
              },
             ],
             position: (257, 33),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (258, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "b",
               position: (258, 18),
              },
             ],
             position: (258, 17),
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (258, 22),
              },
             ],
             position: (258, 21),
            },
           ],
           position: (258, 16),
          },
         },
        ],
        recursive: false,
        position: (256, 16),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFold",
          position: (261, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "f",
             position: (263, 7),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "op",
           },
           definition: Function {
            argument: Simple {
             identifier: "fold",
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "fold",
              position: (263, 21),
             },
             arguments: [
              Variable {
               identifier: "op",
               position: (263, 26),
              },
              Int {
               value: 0,
               position: (263, 29),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "range",
                 position: (263, 32),
                },
                arguments: [
                 Int {
                  value: 0,
                  position: (263, 38),
                 },
                 Int {
                  value: 100,
                  position: (263, 40),
                 },
                ],
               },
               position: (263, 31),
              },
             ],
            },
            position: (263, 15),
           },
           position: (263, 11),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "assoc",
             position: (265, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (265, 15),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (265, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "add",
                position: (265, 26),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "nonAssoc",
             position: (267, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (267, 18),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (267, 20),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "sub",
                position: (267, 29),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (269, 7),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "assocRight",
                 position: (270, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "assoc",
                position: (270, 22),
               },
               arguments: [
                Variable {
                 identifier: "foldr",
                 position: (270, 28),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "assocRightIsLeft",
                 position: (272, 9),
                },
               ],
              },
              to: BinaryOperation {
               operator: EqualTo,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assoc",
                  position: (272, 28),
                 },
                 arguments: [
                  Variable {
                   identifier: "foldr",
                   position: (272, 34),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "assoc",
                  position: (272, 43),
                 },
                 arguments: [
                  Variable {
                   identifier: "foldl",
                   position: (272, 49),
                  },
                 ],
                },
               ],
               position: (272, 40),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocRight",
                 position: (273, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "nonAssoc",
                position: (273, 25),
               },
               arguments: [
                Variable {
                 identifier: "foldr",
                 position: (273, 34),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocLeft",
                 position: (274, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "nonAssoc",
                position: (274, 24),
               },
               arguments: [
                Variable {
                 identifier: "foldl",
                 position: (274, 33),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocRightIsNotLeft",
                 position: (276, 9),
                },
               ],
              },
              to: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "nonAssoc",
                  position: (276, 34),
                 },
                 arguments: [
                  Variable {
                   identifier: "foldl",
                   position: (276, 43),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "nonAssoc",
                  position: (276, 52),
                 },
                 arguments: [
                  Variable {
                   identifier: "foldr",
                   position: (276, 61),
                  },
                 ],
                },
               ],
               position: (276, 49),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "foldIsRight",
                 position: (278, 9),
                },
               ],
              },
              to: BinaryOperation {
               operator: EqualTo,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "nonAssoc",
                  position: (278, 23),
                 },
                 arguments: [
                  Variable {
                   identifier: "fold",
                   position: (278, 32),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "nonAssoc",
                  position: (278, 40),
                 },
                 arguments: [
                  Variable {
                   identifier: "foldr",
                   position: (278, 49),
                  },
                 ],
                },
               ],
               position: (278, 37),
              },
             },
            ],
            recursive: false,
            position: (269, 14),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (280, 7),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "assocRight",
                 position: (281, 9),
                },
               ],
              },
              to: Int {
               value: 5050,
               position: (281, 22),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "assocRightIsLeft",
                 position: (282, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (282, 28),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocRight",
                 position: (283, 9),
                },
               ],
              },
              to: Int {
               value: 50,
               position: (283, 25),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocLeft",
                 position: (284, 9),
                },
               ],
              },
              to: Parentheses {
               expression: UnaryOperation {
                operator: Negate,
                operand: Int {
                 value: 5050,
                 position: (284, 26),
                },
                position: (284, 25),
               },
               position: (284, 24),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "nonAssocRightIsNotLeft",
                 position: (285, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (285, 34),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "foldIsRight",
                 position: (286, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (286, 23),
              },
             },
            ],
            recursive: false,
            position: (280, 18),
           },
          },
         ],
         recursive: false,
         position: (268, 8),
        },
        position: (262, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testTake",
          position: (290, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testAllTrue",
         position: (290, 14),
        },
        arguments: [
         List {
          elements: [
           Parentheses {
            expression: BinaryOperation {
             operator: EqualTo,
             operands: [
              List {
               elements: [],
               position: (291, 6),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "take",
                 position: (291, 13),
                },
                arguments: [
                 Int {
                  value: 0,
                  position: (291, 18),
                 },
                 List {
                  elements: [
                   Int {
                    value: 1,
                    position: (291, 23),
                   },
                   Int {
                    value: 2,
                    position: (291, 25),
                   },
                   Int {
                    value: 3,
                    position: (291, 27),
                   },
                  ],
                  position: (291, 20),
                 },
                ],
               },
               position: (291, 12),
              },
             ],
             position: (291, 9),
            },
            position: (291, 5),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: EqualTo,
             operands: [
              List {
               elements: [
                Int {
                 value: 1,
                 position: (292, 7),
                },
               ],
               position: (292, 6),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "take",
                 position: (292, 14),
                },
                arguments: [
                 Int {
                  value: 1,
                  position: (292, 19),
                 },
                 List {
                  elements: [
                   Int {
                    value: 1,
                    position: (292, 24),
                   },
                   Int {
                    value: 2,
                    position: (292, 26),
                   },
                   Int {
                    value: 3,
                    position: (292, 28),
                   },
                  ],
                  position: (292, 21),
                 },
                ],
               },
               position: (292, 13),
              },
             ],
             position: (292, 10),
            },
            position: (292, 5),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: EqualTo,
             operands: [
              List {
               elements: [
                Int {
                 value: 1,
                 position: (293, 8),
                },
                Int {
                 value: 2,
                 position: (293, 10),
                },
               ],
               position: (293, 6),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "take",
                 position: (293, 18),
                },
                arguments: [
                 Int {
                  value: 2,
                  position: (293, 23),
                 },
                 List {
                  elements: [
                   Int {
                    value: 1,
                    position: (293, 28),
                   },
                   Int {
                    value: 2,
                    position: (293, 30),
                   },
                   Int {
                    value: 3,
                    position: (293, 32),
                   },
                  ],
                  position: (293, 25),
                 },
                ],
               },
               position: (293, 17),
              },
             ],
             position: (293, 14),
            },
            position: (293, 5),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: EqualTo,
             operands: [
              List {
               elements: [
                Int {
                 value: 1,
                 position: (294, 8),
                },
                Int {
                 value: 2,
                 position: (294, 10),
                },
                Int {
                 value: 3,
                 position: (294, 12),
                },
               ],
               position: (294, 6),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "take",
                 position: (294, 20),
                },
                arguments: [
                 Int {
                  value: 3,
                  position: (294, 25),
                 },
                 List {
                  elements: [
                   Int {
                    value: 1,
                    position: (294, 30),
                   },
                   Int {
                    value: 2,
                    position: (294, 32),
                   },
                   Int {
                    value: 3,
                    position: (294, 34),
                   },
                  ],
                  position: (294, 27),
                 },
                ],
               },
               position: (294, 19),
              },
             ],
             position: (294, 16),
            },
            position: (294, 5),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: EqualTo,
             operands: [
              List {
               elements: [
                Int {
                 value: 1,
                 position: (295, 8),
                },
                Int {
                 value: 2,
                 position: (295, 10),
                },
                Int {
                 value: 3,
                 position: (295, 12),
                },
               ],
               position: (295, 6),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "take",
                 position: (295, 20),
                },
                arguments: [
                 Int {
                  value: 4,
                  position: (295, 25),
                 },
                 List {
                  elements: [
                   Int {
                    value: 1,
                    position: (295, 30),
                   },
                   Int {
                    value: 2,
                    position: (295, 32),
                   },
                   Int {
                    value: 3,
                    position: (295, 34),
                   },
                  ],
                  position: (295, 27),
                 },
                ],
               },
               position: (295, 19),
              },
             ],
             position: (295, 16),
            },
            position: (295, 5),
           },
          ],
          position: (290, 26),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFoldAttrs",
          position: (298, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (299, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "foldAttrs",
            position: (299, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "n",
              },
              definition: Function {
               argument: Simple {
                identifier: "a",
               },
               definition: BinaryOperation {
                operator: Concatenation,
                operands: [
                 List {
                  elements: [
                   Variable {
                    identifier: "n",
                    position: (299, 30),
                   },
                  ],
                  position: (299, 29),
                 },
                 Variable {
                  identifier: "a",
                  position: (299, 36),
                 },
                ],
                position: (299, 33),
               },
               position: (299, 26),
              },
              position: (299, 23),
             },
             position: (299, 22),
            },
            List {
             elements: [],
             position: (299, 39),
            },
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "a",
                    position: (300, 7),
                   },
                  ],
                 },
                 to: Int {
                  value: 2,
                  position: (300, 11),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "b",
                    position: (300, 14),
                   },
                  ],
                 },
                 to: Int {
                  value: 7,
                  position: (300, 18),
                 },
                },
               ],
               recursive: false,
               position: (300, 5),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "a",
                    position: (301, 7),
                   },
                  ],
                 },
                 to: Int {
                  value: 3,
                  position: (301, 11),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "c",
                    position: (301, 21),
                   },
                  ],
                 },
                 to: Int {
                  value: 8,
                  position: (301, 25),
                 },
                },
               ],
               recursive: false,
               position: (301, 5),
              },
             ],
             position: (299, 42),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (303, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (303, 18),
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 2,
                position: (303, 24),
               },
               Int {
                value: 3,
                position: (303, 26),
               },
              ],
              position: (303, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "b",
                position: (303, 31),
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 7,
                position: (303, 36),
               },
              ],
              position: (303, 35),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "c",
                position: (303, 40),
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 8,
                position: (303, 45),
               },
              ],
              position: (303, 44),
             },
            },
           ],
           recursive: false,
           position: (303, 16),
          },
         },
        ],
        recursive: false,
        position: (298, 19),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSort",
          position: (306, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (307, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "sort",
            position: (307, 12),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (307, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "lessThan",
                position: (307, 26),
               },
              ],
             },
             default: None,
            },
            List {
             elements: [
              Int {
               value: 40,
               position: (307, 37),
              },
              Int {
               value: 2,
               position: (307, 40),
              },
              Int {
               value: 30,
               position: (307, 42),
              },
              Int {
               value: 42,
               position: (307, 45),
              },
             ],
             position: (307, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (308, 5),
            },
           ],
          },
          to: List {
           elements: [
            Int {
             value: 2,
             position: (308, 17),
            },
            Int {
             value: 30,
             position: (308, 19),
            },
            Int {
             value: 40,
             position: (308, 22),
            },
            Int {
             value: 42,
             position: (308, 25),
            },
           ],
           position: (308, 16),
          },
         },
        ],
        recursive: false,
        position: (306, 14),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToIntShouldConvertStringToInt",
          position: (311, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (312, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "toInt",
            position: (312, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "27",
               position: (312, 19),
              },
             ],
             position: (312, 18),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (313, 5),
            },
           ],
          },
          to: Int {
           value: 27,
           position: (313, 16),
          },
         },
        ],
        recursive: false,
        position: (311, 39),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToIntShouldThrowErrorIfItCouldNotConvertToInt",
          position: (316, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (317, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (317, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "tryEval",
               position: (317, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "toInt",
               position: (317, 30),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "\"foo\"",
                  position: (317, 37),
                 },
                ],
                position: (317, 36),
               },
              ],
             },
             position: (317, 29),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (318, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "success",
                position: (318, 18),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (318, 28),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "value",
                position: (318, 35),
               },
              ],
             },
             to: Variable {
              identifier: "false",
              position: (318, 43),
             },
            },
           ],
           recursive: false,
           position: (318, 16),
          },
         },
        ],
        recursive: false,
        position: (316, 55),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testHasAttrByPathTrue",
          position: (321, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (322, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "hasAttrByPath",
            position: (322, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (322, 28),
                },
               ],
               position: (322, 27),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (322, 32),
                },
               ],
               position: (322, 31),
              },
             ],
             position: (322, 26),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (322, 38),
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "b",
                     position: (322, 44),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "yey",
                     position: (322, 49),
                    },
                   ],
                   position: (322, 48),
                  },
                 },
                ],
                recursive: false,
                position: (322, 42),
               },
              },
             ],
             recursive: false,
             position: (322, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (323, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (323, 16),
          },
         },
        ],
        recursive: false,
        position: (321, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testHasAttrByPathFalse",
          position: (326, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (327, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "hasAttrByPath",
            position: (327, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (327, 28),
                },
               ],
               position: (327, 27),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (327, 32),
                },
               ],
               position: (327, 31),
              },
             ],
             position: (327, 26),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (327, 38),
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "c",
                     position: (327, 44),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "yey",
                     position: (327, 49),
                    },
                   ],
                   position: (327, 48),
                  },
                 },
                ],
                recursive: false,
                position: (327, 42),
               },
              },
             ],
             recursive: false,
             position: (327, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (328, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (328, 16),
          },
         },
        ],
        recursive: false,
        position: (326, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testRecursiveUpdateUntil",
          position: (335, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (336, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "recursiveUpdateUntil",
            position: (336, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "path",
              },
              definition: Function {
               argument: Simple {
                identifier: "l",
               },
               definition: Function {
                argument: Simple {
                 identifier: "r",
                },
                definition: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  Variable {
                   identifier: "path",
                   position: (336, 46),
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "foo",
                       position: (336, 56),
                      },
                     ],
                     position: (336, 55),
                    },
                   ],
                   position: (336, 54),
                  },
                 ],
                 position: (336, 51),
                },
                position: (336, 43),
               },
               position: (336, 40),
              },
              position: (336, 34),
             },
             position: (336, 33),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (338, 7),
                 },
                 Raw {
                  content: "bar",
                  position: (338, 11),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (338, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (339, 7),
                 },
                 Raw {
                  content: "baz",
                  position: (339, 11),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (339, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "bar",
                  position: (340, 7),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (340, 13),
               },
              },
             ],
             recursive: false,
             position: (336, 63),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (343, 7),
                 },
                 Raw {
                  content: "bar",
                  position: (343, 11),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (343, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (344, 7),
                 },
                 Raw {
                  content: "quz",
                  position: (344, 11),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (344, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "baz",
                  position: (345, 7),
                 },
                ],
               },
               to: Int {
                value: 4,
                position: (345, 13),
               },
              },
             ],
             recursive: false,
             position: (341, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (347, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "foo",
                position: (348, 7),
               },
               Raw {
                content: "bar",
                position: (348, 11),
               },
              ],
             },
             to: Int {
              value: 1,
              position: (348, 17),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "foo",
                position: (349, 7),
               },
               Raw {
                content: "quz",
                position: (349, 11),
               },
              ],
             },
             to: Int {
              value: 2,
              position: (349, 17),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "bar",
                position: (350, 7),
               },
              ],
             },
             to: Int {
              value: 3,
              position: (350, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "baz",
                position: (351, 7),
               },
              ],
             },
             to: Int {
              value: 4,
              position: (351, 13),
             },
            },
           ],
           recursive: false,
           position: (347, 16),
          },
         },
        ],
        recursive: false,
        position: (335, 30),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testOverrideExistingEmpty",
          position: (355, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (356, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (356, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (356, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (356, 34),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (356, 38),
               },
              },
             ],
             recursive: false,
             position: (356, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (357, 5),
            },
           ],
          },
          to: Map {
           bindings: [],
           recursive: false,
           position: (357, 16),
          },
         },
        ],
        recursive: false,
        position: (355, 31),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testOverrideExistingDisjoint",
          position: (360, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (361, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (361, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (361, 31),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (361, 35),
               },
              },
             ],
             recursive: false,
             position: (361, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (361, 42),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (361, 46),
               },
              },
             ],
             recursive: false,
             position: (361, 40),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (362, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "b",
                position: (362, 18),
               },
              ],
             },
             to: Int {
              value: 2,
              position: (362, 22),
             },
            },
           ],
           recursive: false,
           position: (362, 16),
          },
         },
        ],
        recursive: false,
        position: (360, 34),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testOverrideExistingOverride",
          position: (365, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (366, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (366, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (366, 31),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (366, 35),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (366, 38),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (366, 42),
               },
              },
             ],
             recursive: false,
             position: (366, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (366, 49),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (366, 53),
               },
              },
             ],
             recursive: false,
             position: (366, 47),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (367, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (367, 18),
               },
              ],
             },
             to: Int {
              value: 1,
              position: (367, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "b",
                position: (367, 25),
               },
              ],
             },
             to: Int {
              value: 2,
              position: (367, 29),
             },
            },
           ],
           recursive: false,
           position: (367, 16),
          },
         },
        ],
        recursive: false,
        position: (365, 34),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testMkKeyValueDefault",
          position: (374, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (375, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (375, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "mkKeyValueDefault",
               position: (375, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (375, 41),
            },
            String {
             parts: [
              Raw {
               content: ":",
               position: (375, 45),
              },
             ],
             position: (375, 44),
            },
            String {
             parts: [
              Raw {
               content: "f:oo",
               position: (375, 49),
              },
             ],
             position: (375, 48),
            },
            String {
             parts: [
              Raw {
               content: "bar",
               position: (375, 56),
              },
             ],
             position: (375, 55),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (376, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "f\\:oo:bar",
             position: (376, 18),
            },
           ],
           position: (376, 16),
          },
         },
        ],
        recursive: false,
        position: (374, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testMkValueString",
          position: (379, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (380, 5),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "vals",
                position: (381, 7),
               },
              ],
             },
             to: Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "int",
                   position: (382, 9),
                  },
                 ],
                },
                to: Int {
                 value: 42,
                 position: (382, 15),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "string",
                   position: (383, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "fo\"o",
                   position: (383, 20),
                  },
                 ],
                 position: (383, 18),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (384, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (384, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "bool2",
                   position: (385, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "false",
                 position: (385, 17),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "null",
                   position: (386, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "null",
                 position: (386, 16),
                },
               },
              ],
              recursive: false,
              position: (381, 14),
             },
            },
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (389, 10),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "const",
                position: (390, 10),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "generators",
                    position: (390, 17),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "mkValueStringDefault",
                      position: (390, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (390, 49),
                   },
                  ],
                 },
                 position: (390, 16),
                },
               ],
              },
              position: (390, 9),
             },
             Variable {
              identifier: "vals",
              position: (391, 9),
             },
            ],
           },
           position: (380, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (392, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "int",
                position: (393, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "42",
                position: (393, 14),
               },
              ],
              position: (393, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "string",
                position: (394, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "fo\"o",
                position: (394, 18),
               },
              ],
              position: (394, 16),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "bool",
                position: (395, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "true",
                position: (395, 15),
               },
              ],
              position: (395, 14),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "bool2",
                position: (396, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "false",
                position: (396, 16),
               },
              ],
              position: (396, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "null",
                position: (397, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "null",
                position: (397, 15),
               },
              ],
              position: (397, 14),
             },
            },
           ],
           recursive: false,
           position: (392, 16),
          },
         },
        ],
        recursive: false,
        position: (379, 23),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToKeyValue",
          position: (402, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (403, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (403, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toKeyValue",
               position: (403, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (403, 34),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "key",
                  position: (404, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "value",
                  position: (404, 14),
                 },
                ],
                position: (404, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Expression {
                  ast: String {
                   parts: [
                    Raw {
                     content: "other=key",
                     position: (405, 8),
                    },
                   ],
                   position: (405, 7),
                  },
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "baz",
                  position: (405, 22),
                 },
                ],
                position: (405, 21),
               },
              },
             ],
             recursive: false,
             position: (403, 37),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (407, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "key=value\nother\\=key=baz\n",
             position: (408, 1),
            },
           ],
           position: (407, 16),
          },
         },
        ],
        recursive: false,
        position: (402, 20),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToINIEmpty",
          position: (413, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (414, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (414, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toINI",
               position: (414, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (414, 29),
            },
            Map {
             bindings: [],
             recursive: false,
             position: (414, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (415, 5),
            },
           ],
          },
          to: String {
           parts: [],
           position: (415, 16),
          },
         },
        ],
        recursive: false,
        position: (413, 20),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToINIEmptySection",
          position: (418, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (419, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (419, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toINI",
               position: (419, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (419, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (419, 34),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (419, 40),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "bar",
                  position: (419, 44),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (419, 50),
               },
              },
             ],
             recursive: false,
             position: (419, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (420, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "[bar]\n\n[foo]\n",
             position: (421, 1),
            },
           ],
           position: (420, 16),
          },
         },
        ],
        recursive: false,
        position: (418, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToINIDuplicateKeys",
          position: (427, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (428, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (428, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toINI",
               position: (428, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "listsAsDuplicateKeys",
                  position: (428, 31),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (428, 54),
               },
              },
             ],
             recursive: false,
             position: (428, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "foo",
                  position: (428, 64),
                 },
                 Raw {
                  content: "bar",
                  position: (428, 68),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (428, 74),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "baz",
                  position: (428, 80),
                 },
                 Raw {
                  content: "qux",
                  position: (428, 84),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 1,
                  position: (428, 92),
                 },
                 Variable {
                  identifier: "false",
                  position: (428, 94),
                 },
                ],
                position: (428, 90),
               },
              },
             ],
             recursive: false,
             position: (428, 62),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (429, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "[baz]\nqux=1\nqux=false\n\n[foo]\nbar=true\n",
             position: (430, 1),
            },
           ],
           position: (429, 16),
          },
         },
        ],
        recursive: false,
        position: (427, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToINIDefaultEscapes",
          position: (439, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (440, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (440, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toINI",
               position: (440, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (440, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Expression {
                  ast: String {
                   parts: [
                    Raw {
                     content: "no [ and ] allowed unescaped",
                     position: (441, 8),
                    },
                   ],
                   position: (441, 7),
                  },
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Expression {
                     ast: String {
                      parts: [
                       Raw {
                        content: "and also no = in keys",
                        position: (442, 10),
                       },
                      ],
                      position: (442, 9),
                     },
                    },
                   ],
                  },
                  to: Int {
                   value: 42,
                   position: (442, 35),
                  },
                 },
                ],
                recursive: false,
                position: (441, 40),
               },
              },
             ],
             recursive: false,
             position: (440, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (445, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "[no \\[ and \\] allowed unescaped]\nand also no \\= in keys=42\n",
             position: (446, 1),
            },
           ],
           position: (445, 16),
          },
         },
        ],
        recursive: false,
        position: (439, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToINIDefaultFull",
          position: (451, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (452, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (452, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toINI",
               position: (452, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (452, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Expression {
                  ast: String {
                   parts: [
                    Raw {
                     content: "section 1",
                     position: (453, 8),
                    },
                   ],
                   position: (453, 7),
                  },
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "attribute1",
                     position: (454, 9),
                    },
                   ],
                  },
                  to: Int {
                   value: 5,
                   position: (454, 22),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "x",
                     position: (455, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Me-se JarJar Binx",
                     position: (455, 14),
                    },
                   ],
                   position: (455, 13),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "boolean",
                     position: (457, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "false",
                   position: (457, 19),
                  },
                 },
                ],
                recursive: false,
                position: (453, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Expression {
                  ast: String {
                   parts: [
                    Raw {
                     content: "foo[]",
                     position: (459, 8),
                    },
                   ],
                   position: (459, 7),
                  },
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Expression {
                     ast: String {
                      parts: [
                       Raw {
                        content: "he\\h=he",
                        position: (460, 10),
                       },
                      ],
                      position: (460, 9),
                     },
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "this is okay",
                     position: (460, 23),
                    },
                   ],
                   position: (460, 22),
                  },
                 },
                ],
                recursive: false,
                position: (459, 17),
               },
              },
             ],
             recursive: false,
             position: (452, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (463, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "[foo\\[\\]]\nhe\\h\\=he=this is okay\n\n[section 1]\nattribute1=5\nboolean=false\nx=Me-se JarJar Binx\n",
             position: (464, 1),
            },
           ],
           position: (463, 16),
          },
         },
        ],
        recursive: false,
        position: (451, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToJSONSimple",
          position: (475, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "val",
             position: (476, 9),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "foobar",
                position: (477, 7),
               },
              ],
             },
             to: List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "baz",
                  position: (477, 19),
                 },
                ],
                position: (477, 18),
               },
               Int {
                value: 1,
                position: (477, 24),
               },
               Int {
                value: 2,
                position: (477, 26),
               },
               Int {
                value: 3,
                position: (477, 28),
               },
              ],
              position: (477, 16),
             },
            },
           ],
           recursive: false,
           position: (476, 15),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (480, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (480, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toJSON",
                position: (480, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (480, 32),
             },
             Variable {
              identifier: "val",
              position: (480, 35),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (482, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (482, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toJSON",
                position: (482, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (482, 34),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (479, 8),
        },
        position: (476, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToYAMLSimple",
          position: (486, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "val",
             position: (487, 9),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "list",
                position: (488, 7),
               },
              ],
             },
             to: List {
              elements: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "one",
                     position: (488, 18),
                    },
                   ],
                  },
                  to: Int {
                   value: 1,
                   position: (488, 24),
                  },
                 },
                ],
                recursive: false,
                position: (488, 16),
               },
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "two",
                     position: (488, 31),
                    },
                   ],
                  },
                  to: Int {
                   value: 2,
                   position: (488, 37),
                  },
                 },
                ],
                recursive: false,
                position: (488, 29),
               },
              ],
              position: (488, 14),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "all",
                position: (489, 7),
               },
              ],
             },
             to: Int {
              value: 42,
              position: (489, 13),
             },
            },
           ],
           recursive: false,
           position: (487, 15),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (492, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (492, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toYAML",
                position: (492, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (492, 32),
             },
             Variable {
              identifier: "val",
              position: (492, 35),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (494, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (494, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toJSON",
                position: (494, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (494, 34),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (491, 8),
        },
        position: (487, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToPretty",
          position: (497, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "deriv",
             position: (499, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "derivation",
            position: (499, 15),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "name",
                  position: (499, 28),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "test",
                  position: (499, 36),
                 },
                ],
                position: (499, 35),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "builder",
                  position: (499, 43),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "/bin/sh",
                  position: (499, 54),
                 },
                ],
                position: (499, 53),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "system",
                  position: (499, 64),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "aarch64-linux",
                  position: (499, 74),
                 },
                ],
                position: (499, 73),
               },
              },
             ],
             recursive: false,
             position: (499, 26),
            },
           ],
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (501, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (501, 12),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "const",
                position: (501, 22),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "generators",
                    position: (501, 29),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "toPretty",
                      position: (501, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "multiline",
                         position: (501, 51),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "false",
                       position: (501, 63),
                      },
                     },
                    ],
                    recursive: false,
                    position: (501, 49),
                   },
                  ],
                 },
                 position: (501, 28),
                },
               ],
              },
              position: (501, 21),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "int",
                   position: (502, 7),
                  },
                 ],
                },
                to: Int {
                 value: 42,
                 position: (502, 13),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "float",
                   position: (503, 7),
                  },
                 ],
                },
                to: Float {
                 value: 0.1337,
                 position: (503, 15),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (504, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (504, 14),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "emptystring",
                   position: (505, 7),
                  },
                 ],
                },
                to: String {
                 parts: [],
                 position: (505, 21),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "string",
                   position: (506, 7),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "fno\"rd",
                   position: (506, 18),
                  },
                 ],
                 position: (506, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "newlinestring",
                   position: (507, 7),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "\n",
                   position: (507, 24),
                  },
                 ],
                 position: (507, 23),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "path",
                   position: (508, 7),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  Path {
                   parts: [
                    Raw {
                     content: "/.",
                     position: (508, 14),
                    },
                   ],
                   position: (508, 14),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/foo",
                     position: (508, 20),
                    },
                   ],
                   position: (508, 19),
                  },
                 ],
                 position: (508, 17),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "null_",
                   position: (509, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "null",
                 position: (509, 15),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "function",
                   position: (510, 7),
                  },
                 ],
                },
                to: Function {
                 argument: Simple {
                  identifier: "x",
                 },
                 definition: Variable {
                  identifier: "x",
                  position: (510, 21),
                 },
                 position: (510, 18),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "functionArgs",
                   position: (511, 7),
                  },
                 ],
                },
                to: Function {
                 argument: Destructured {
                  identifier: None,
                  arguments: [
                   DestructuredArgument {
                    identifier: "arg",
                    default: Some(
                     Int {
                      value: 4,
                      position: (511, 30),
                     },
                    ),
                   },
                   DestructuredArgument {
                    identifier: "foo",
                    default: None,
                   },
                  ],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "arg",
                  position: (511, 40),
                 },
                 position: (511, 22),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "list",
                   position: (512, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  Int {
                   value: 3,
                   position: (512, 16),
                  },
                  Int {
                   value: 4,
                   position: (512, 18),
                  },
                  Variable {
                   identifier: "function",
                   position: (512, 20),
                  },
                  List {
                   elements: [
                    Variable {
                     identifier: "false",
                     position: (512, 31),
                    },
                   ],
                   position: (512, 29),
                  },
                 ],
                 position: (512, 14),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "emptylist",
                   position: (513, 7),
                  },
                 ],
                },
                to: List {
                 elements: [],
                 position: (513, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "attrs",
                   position: (514, 7),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "foo",
                      position: (514, 17),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "null",
                    position: (514, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Expression {
                      ast: String {
                       parts: [
                        Raw {
                         content: "foo bar",
                         position: (514, 30),
                        },
                       ],
                       position: (514, 29),
                      },
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "baz",
                      position: (514, 42),
                     },
                    ],
                    position: (514, 41),
                   },
                  },
                 ],
                 recursive: false,
                 position: (514, 15),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "emptyattrs",
                   position: (515, 7),
                  },
                 ],
                },
                to: Map {
                 bindings: [],
                 recursive: false,
                 position: (515, 20),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "drv",
                   position: (516, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "deriv",
                 position: (516, 13),
                },
               },
              ],
              recursive: true,
              position: (501, 74),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (518, 5),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "int",
                 position: (519, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "42",
                 position: (519, 14),
                },
               ],
               position: (519, 13),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "float",
                 position: (520, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "~0.133700",
                 position: (520, 16),
                },
               ],
               position: (520, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "bool",
                 position: (521, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "true",
                 position: (521, 15),
                },
               ],
               position: (521, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "emptystring",
                 position: (522, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "\"\"",
                 position: (522, 23),
                },
               ],
               position: (522, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "string",
                 position: (523, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "\"fno\\\"rd\"",
                 position: (523, 18),
                },
               ],
               position: (523, 16),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "newlinestring",
                 position: (524, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "\"\\n\"",
                 position: (524, 24),
                },
               ],
               position: (524, 23),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (525, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "/foo",
                 position: (525, 15),
                },
               ],
               position: (525, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "null_",
                 position: (526, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "null",
                 position: (526, 16),
                },
               ],
               position: (526, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "function",
                 position: (527, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "<function>",
                 position: (527, 19),
                },
               ],
               position: (527, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "functionArgs",
                 position: (528, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "<function, args: {arg?, foo}>",
                 position: (528, 23),
                },
               ],
               position: (528, 22),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "list",
                 position: (529, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "[ 3 4 ",
                 position: (529, 15),
                },
                Interpolation {
                 expression: Variable {
                  identifier: "function",
                  position: (529, 23),
                 },
                },
                Raw {
                 content: " [ false ] ]",
                 position: (529, 32),
                },
               ],
               position: (529, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "emptylist",
                 position: (530, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "[ ]",
                 position: (530, 20),
                },
               ],
               position: (530, 19),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "attrs",
                 position: (531, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "{ foo = null; \"foo bar\" = \"baz\"; }",
                 position: (531, 16),
                },
               ],
               position: (531, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "emptyattrs",
                 position: (532, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "{ }",
                 position: (532, 21),
                },
               ],
               position: (532, 20),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "drv",
                 position: (533, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "<derivation ",
                 position: (533, 14),
                },
                Interpolation {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "deriv",
                   position: (533, 28),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "drvPath",
                     position: (533, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: ">",
                 position: (533, 42),
                },
               ],
               position: (533, 13),
              },
             },
            ],
            recursive: true,
            position: (518, 16),
           },
          },
         ],
         recursive: false,
         position: (500, 8),
        },
        position: (498, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToPrettyLimit",
          position: (537, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "a",
             position: (539, 7),
            },
            Raw {
             content: "b",
             position: (539, 9),
            },
           ],
          },
          to: Int {
           value: 1,
           position: (539, 13),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "a",
             position: (540, 7),
            },
            Raw {
             content: "c",
             position: (540, 9),
            },
           ],
          },
          to: Variable {
           identifier: "a",
           position: (540, 13),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (542, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (542, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toPretty",
                position: (542, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (542, 34),
             },
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "generators",
                 position: (542, 39),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "withRecursion",
                   position: (542, 50),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "throwOnDepthLimit",
                      position: (542, 66),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "false",
                    position: (542, 86),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "depthLimit",
                      position: (542, 93),
                     },
                    ],
                   },
                   to: Int {
                    value: 2,
                    position: (542, 106),
                   },
                  },
                 ],
                 recursive: false,
                 position: (542, 64),
                },
                Variable {
                 identifier: "a",
                 position: (542, 111),
                },
               ],
              },
              position: (542, 38),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (543, 7),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "{\n  b = 1;\n  c = {\n    b = \"<unevaluated>\";\n    c = {\n      b = \"<unevaluated>\";\n      c = \"<unevaluated>\";\n    };\n  };\n}",
              position: (543, 19),
             },
            ],
            position: (543, 18),
           },
          },
         ],
         recursive: false,
         position: (541, 8),
        },
        position: (538, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToPrettyLimitThrow",
          position: (546, 3),
         },
        ],
       },
       to: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "a",
             position: (548, 7),
            },
            Raw {
             content: "b",
             position: (548, 9),
            },
           ],
          },
          to: Int {
           value: 1,
           position: (548, 13),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "a",
             position: (549, 7),
            },
            Raw {
             content: "c",
             position: (549, 9),
            },
           ],
          },
          to: Variable {
           identifier: "a",
           position: (549, 13),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expr",
              position: (551, 7),
             },
            ],
           },
           to: PropertyAccess {
            expression: Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (551, 15),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "tryEval",
                  position: (551, 24),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "generators",
                   position: (552, 10),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "toPretty",
                     position: (552, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [],
                   recursive: false,
                   position: (552, 30),
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "generators",
                      position: (552, 35),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "withRecursion",
                        position: (552, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "depthLimit",
                           position: (552, 62),
                          },
                         ],
                        },
                        to: Int {
                         value: 2,
                         position: (552, 75),
                        },
                       },
                      ],
                      recursive: false,
                      position: (552, 60),
                     },
                     Variable {
                      identifier: "a",
                      position: (552, 80),
                     },
                    ],
                   },
                   position: (552, 34),
                  },
                 ],
                },
                position: (552, 9),
               },
              ],
             },
             position: (551, 14),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "success",
               position: (552, 85),
              },
             ],
            },
            default: None,
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "expected",
              position: (553, 7),
             },
            ],
           },
           to: Variable {
            identifier: "false",
            position: (553, 18),
           },
          },
         ],
         recursive: false,
         position: (550, 8),
        },
        position: (547, 5),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToPrettyMultiline",
          position: (556, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (557, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (557, 12),
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "const",
               position: (557, 22),
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "generators",
                   position: (557, 29),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "toPretty",
                     position: (557, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [],
                   recursive: false,
                   position: (557, 49),
                  },
                 ],
                },
                position: (557, 28),
               },
              ],
             },
             position: (557, 21),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "list",
                  position: (558, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 3,
                  position: (558, 16),
                 },
                 Int {
                  value: 4,
                  position: (558, 18),
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "false",
                    position: (558, 22),
                   },
                  ],
                  position: (558, 20),
                 },
                ],
                position: (558, 14),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "attrs",
                  position: (559, 7),
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "foo",
                     position: (559, 17),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "null",
                   position: (559, 23),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "bar",
                     position: (559, 29),
                    },
                    Raw {
                     content: "foo",
                     position: (559, 33),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "baz",
                     position: (559, 40),
                    },
                   ],
                   position: (559, 39),
                  },
                 },
                ],
                recursive: false,
                position: (559, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "newlinestring",
                  position: (560, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "\n",
                  position: (560, 24),
                 },
                ],
                position: (560, 23),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "multilinestring",
                  position: (561, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "hello\nthere\ntest\n",
                  position: (562, 1),
                 },
                ],
                position: (561, 25),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "multilinestring'",
                  position: (566, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "        hello\nthere\ntest",
                  position: (567, 1),
                 },
                ],
                position: (566, 26),
               },
              },
             ],
             recursive: true,
             position: (557, 55),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (571, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "list",
                position: (572, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "        [\n  3\n  4\n  [\n    false\n  ]\n]",
                position: (573, 1),
               },
              ],
              position: (572, 14),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "attrs",
                position: (580, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "        {\n  bar = {\n    foo = \"baz\";\n  };\n  foo = null;\n}",
                position: (581, 1),
               },
              ],
              position: (580, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "newlinestring",
                position: (587, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "''\n  \n''",
                position: (587, 24),
               },
              ],
              position: (587, 23),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "multilinestring",
                position: (588, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "        ",
                position: (589, 1),
               },
               Raw {
                content: "''",
                position: (589, 9),
               },
               Raw {
                content: "\n  hello\n  there\n  test\n",
                position: (589, 12),
               },
               Raw {
                content: "''",
                position: (593, 9),
               },
              ],
              position: (588, 25),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "multilinestring'",
                position: (594, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "        ",
                position: (595, 1),
               },
               Raw {
                content: "''",
                position: (595, 9),
               },
               Raw {
                content: "\n  hello\n  there\n  test",
                position: (595, 12),
               },
               Raw {
                content: "''",
                position: (598, 15),
               },
              ],
              position: (594, 26),
             },
            },
           ],
           recursive: true,
           position: (571, 16),
          },
         },
        ],
        recursive: false,
        position: (556, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToPrettyAllowPrettyValues",
          position: (603, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (604, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (604, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toPretty",
               position: (604, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "allowPrettyValues",
                  position: (604, 34),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (604, 54),
               },
              },
             ],
             recursive: false,
             position: (604, 32),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "__pretty",
                  position: (605, 16),
                 },
                ],
               },
               to: Function {
                argument: Simple {
                 identifier: "v",
                },
                definition: BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    String {
                     parts: [
                      Raw {
                       content: "«",
                       position: (605, 31),
                      },
                     ],
                     position: (605, 30),
                    },
                    Variable {
                     identifier: "v",
                     position: (605, 36),
                    },
                   ],
                   position: (605, 34),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "»",
                     position: (605, 41),
                    },
                   ],
                   position: (605, 40),
                  },
                 ],
                 position: (605, 38),
                },
                position: (605, 27),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "val",
                  position: (605, 45),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "foo",
                  position: (605, 52),
                 },
                ],
                position: (605, 51),
               },
              },
             ],
             recursive: false,
             position: (605, 14),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (606, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "«foo»",
             position: (606, 18),
            },
           ],
           position: (606, 17),
          },
         },
        ],
        recursive: false,
        position: (603, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToGNUCommandLine",
          position: (612, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (613, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (613, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toGNUCommandLine",
               position: (613, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (613, 33),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "data",
                  position: (614, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (614, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "toJSON",
                    position: (614, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "id",
                       position: (614, 32),
                      },
                     ],
                    },
                    to: Int {
                     value: 0,
                     position: (614, 37),
                    },
                   },
                  ],
                  recursive: false,
                  position: (614, 30),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "X",
                  position: (615, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "PUT",
                  position: (615, 12),
                 },
                ],
                position: (615, 11),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "retry",
                  position: (616, 7),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (616, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "retry-delay",
                  position: (617, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (617, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "url",
                  position: (618, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                    position: (618, 16),
                   },
                  ],
                  position: (618, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                    position: (618, 42),
                   },
                  ],
                  position: (618, 41),
                 },
                ],
                position: (618, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "silent",
                  position: (619, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "false",
                position: (619, 16),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "verbose",
                  position: (620, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (620, 17),
               },
              },
             ],
             recursive: false,
             position: (613, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (623, 5),
            },
           ],
          },
          to: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "-X",
               position: (624, 8),
              },
             ],
             position: (624, 7),
            },
            String {
             parts: [
              Raw {
               content: "PUT",
               position: (624, 13),
              },
             ],
             position: (624, 12),
            },
            String {
             parts: [
              Raw {
               content: "--data",
               position: (625, 8),
              },
             ],
             position: (625, 7),
            },
            String {
             parts: [
              Raw {
               content: "{\"id\":0}",
               position: (625, 17),
              },
             ],
             position: (625, 16),
            },
            String {
             parts: [
              Raw {
               content: "--retry",
               position: (626, 8),
              },
             ],
             position: (626, 7),
            },
            String {
             parts: [
              Raw {
               content: "3",
               position: (626, 18),
              },
             ],
             position: (626, 17),
            },
            String {
             parts: [
              Raw {
               content: "--url",
               position: (627, 8),
              },
             ],
             position: (627, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/foo",
               position: (627, 16),
              },
             ],
             position: (627, 15),
            },
            String {
             parts: [
              Raw {
               content: "--url",
               position: (628, 8),
              },
             ],
             position: (628, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/bar",
               position: (628, 16),
              },
             ],
             position: (628, 15),
            },
            String {
             parts: [
              Raw {
               content: "--verbose",
               position: (629, 8),
              },
             ],
             position: (629, 7),
            },
           ],
           position: (623, 16),
          },
         },
        ],
        recursive: false,
        position: (612, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testToGNUCommandLineShell",
          position: (633, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (634, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (634, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "toGNUCommandLineShell",
               position: (634, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (634, 38),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "data",
                  position: (635, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (635, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "toJSON",
                    position: (635, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "id",
                       position: (635, 32),
                      },
                     ],
                    },
                    to: Int {
                     value: 0,
                     position: (635, 37),
                    },
                   },
                  ],
                  recursive: false,
                  position: (635, 30),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "X",
                  position: (636, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "PUT",
                  position: (636, 12),
                 },
                ],
                position: (636, 11),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "retry",
                  position: (637, 7),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (637, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "retry-delay",
                  position: (638, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (638, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "url",
                  position: (639, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                    position: (639, 16),
                   },
                  ],
                  position: (639, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                    position: (639, 42),
                   },
                  ],
                  position: (639, 41),
                 },
                ],
                position: (639, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "silent",
                  position: (640, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "false",
                position: (640, 16),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "verbose",
                  position: (641, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (641, 17),
               },
              },
             ],
             recursive: false,
             position: (634, 41),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (644, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "'-X' 'PUT' '--data' '{\"id\":0}' '--retry' '3' '--url' 'https://example.com/foo' '--url' 'https://example.com/bar' '--verbose'",
             position: (644, 17),
            },
           ],
           position: (644, 16),
          },
         },
        ],
        recursive: false,
        position: (633, 31),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameLeadingDots",
          position: (647, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (647, 43),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (648, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "..foo",
               position: (648, 13),
              },
             ],
             position: (648, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (649, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "foo",
               position: (649, 17),
              },
             ],
             position: (649, 16),
            },
           },
          ],
          recursive: false,
          position: (647, 70),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameUnicode",
          position: (652, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (652, 39),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (653, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "fö",
               position: (653, 13),
              },
             ],
             position: (653, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (654, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "f-",
               position: (654, 17),
              },
             ],
             position: (654, 16),
            },
           },
          ],
          recursive: false,
          position: (652, 66),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameAscii",
          position: (657, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (657, 37),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (658, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
               position: (658, 13),
              },
             ],
             position: (658, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (659, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "-+--.-0123456789-=-?-ABCDEFGHIJKLMNOPQRSTUVWXYZ-_-abcdefghijklmnopqrstuvwxyz-",
               position: (659, 17),
              },
             ],
             position: (659, 16),
            },
           },
          ],
          recursive: false,
          position: (657, 64),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameTooLong",
          position: (662, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (662, 39),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (663, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "This string is loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
               position: (663, 13),
              },
             ],
             position: (663, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (664, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
               position: (664, 17),
              },
             ],
             position: (664, 16),
            },
           },
          ],
          recursive: false,
          position: (662, 66),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameTooLongWithInvalid",
          position: (667, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (667, 50),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (668, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "Hello there aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&&&&&&&",
               position: (668, 13),
              },
             ],
             position: (668, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (669, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "there-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-",
               position: (669, 17),
              },
             ],
             position: (669, 16),
            },
           },
          ],
          recursive: false,
          position: (667, 77),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testSanitizeDerivationNameEmpty",
          position: (672, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (672, 37),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (673, 5),
              },
             ],
            },
            to: String {
             parts: [],
             position: (673, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "expected",
               position: (674, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "unknown",
               position: (674, 17),
              },
             ],
             position: (674, 16),
            },
           },
          ],
          recursive: false,
          position: (672, 64),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testFreeformOptions",
          position: (677, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (678, 5),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "submodule",
                position: (680, 9),
               },
              ],
             },
             to: Function {
              argument: Destructured {
               identifier: None,
               arguments: [
                DestructuredArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "freeformType",
                    position: (681, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (681, 26),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "types",
                      position: (681, 30),
                     },
                     Raw {
                      content: "attrsOf",
                      position: (681, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "lib",
                       position: (681, 45),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "types",
                         position: (681, 49),
                        },
                        Raw {
                         content: "submodule",
                         position: (681, 55),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "options",
                            position: (682, 13),
                           },
                           Raw {
                            content: "bar",
                            position: (682, 21),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "lib",
                            position: (682, 27),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "mkOption",
                              position: (682, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           Map {
                            bindings: [],
                            recursive: false,
                            position: (682, 40),
                           },
                          ],
                         },
                        },
                       ],
                       recursive: false,
                       position: (681, 65),
                      },
                     ],
                    },
                    position: (681, 44),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "options",
                    position: (684, 11),
                   },
                   Raw {
                    content: "bar",
                    position: (684, 19),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (684, 25),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "mkOption",
                      position: (684, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (684, 38),
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (680, 35),
              },
              position: (680, 21),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "module",
                position: (687, 9),
               },
              ],
             },
             to: Function {
              argument: Destructured {
               identifier: None,
               arguments: [
                DestructuredArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "options",
                    position: (688, 11),
                   },
                   Raw {
                    content: "foo",
                    position: (688, 19),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (688, 25),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "mkOption",
                      position: (688, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "type",
                         position: (689, 13),
                        },
                       ],
                      },
                      to: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (689, 20),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "types",
                           position: (689, 24),
                          },
                          Raw {
                           content: "submodule",
                           position: (689, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "submodule",
                         position: (689, 40),
                        },
                       ],
                      },
                     },
                    ],
                    recursive: false,
                    position: (688, 38),
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (687, 32),
              },
              position: (687, 18),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (693, 9),
               },
              ],
             },
             to: PropertyAccess {
              expression: Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "evalModules",
                 position: (693, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "modules",
                       position: (694, 11),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      Variable {
                       identifier: "module",
                       position: (694, 23),
                      },
                     ],
                     position: (694, 21),
                    },
                   },
                  ],
                  recursive: false,
                  position: (693, 32),
                 },
                ],
               },
               position: (693, 19),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (695, 12),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "locs",
                position: (697, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (697, 16),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "o",
                 },
                 definition: UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "o",
                    position: (697, 29),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "internal",
                      position: (697, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (697, 27),
                 },
                 position: (697, 24),
                },
                position: (697, 23),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionAttrSetToDocList",
                  position: (697, 42),
                 },
                 arguments: [
                  Variable {
                   identifier: "options",
                   position: (697, 65),
                  },
                 ],
                },
                position: (697, 41),
               },
              ],
             },
            },
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (698, 10),
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "o",
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "o",
                 position: (698, 18),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "loc",
                   position: (698, 20),
                  },
                 ],
                },
                default: None,
               },
               position: (698, 15),
              },
              position: (698, 14),
             },
             Variable {
              identifier: "locs",
              position: (698, 25),
             },
            ],
           },
           position: (679, 7),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (699, 5),
            },
           ],
          },
          to: List {
           elements: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "_module",
                 position: (699, 21),
                },
               ],
               position: (699, 20),
              },
              String {
               parts: [
                Raw {
                 content: "args",
                 position: (699, 31),
                },
               ],
               position: (699, 30),
              },
             ],
             position: (699, 18),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (699, 42),
                },
               ],
               position: (699, 41),
              },
             ],
             position: (699, 39),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (699, 52),
                },
               ],
               position: (699, 51),
              },
              String {
               parts: [
                Raw {
                 content: "<name>",
                 position: (699, 58),
                },
               ],
               position: (699, 57),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                 position: (699, 67),
                },
               ],
               position: (699, 66),
              },
             ],
             position: (699, 49),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (699, 77),
                },
               ],
               position: (699, 76),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                 position: (699, 83),
                },
               ],
               position: (699, 82),
              },
             ],
             position: (699, 74),
            },
           ],
           position: (699, 16),
          },
         },
        ],
        recursive: false,
        position: (677, 25),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCartesianProductOfEmptySet",
          position: (702, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (703, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (703, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (703, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (704, 5),
            },
           ],
          },
          to: List {
           elements: [
            Map {
             bindings: [],
             recursive: false,
             position: (704, 18),
            },
           ],
           position: (704, 16),
          },
         },
        ],
        recursive: false,
        position: (702, 36),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCartesianProductOfOneSet",
          position: (707, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (708, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (708, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (708, 37),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 1,
                  position: (708, 43),
                 },
                 Int {
                  value: 2,
                  position: (708, 45),
                 },
                 Int {
                  value: 3,
                  position: (708, 47),
                 },
                ],
                position: (708, 41),
               },
              },
             ],
             recursive: false,
             position: (708, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (709, 5),
            },
           ],
          },
          to: List {
           elements: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (709, 20),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (709, 24),
               },
              },
             ],
             recursive: false,
             position: (709, 18),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (709, 31),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (709, 35),
               },
              },
             ],
             recursive: false,
             position: (709, 29),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (709, 42),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (709, 46),
               },
              },
             ],
             recursive: false,
             position: (709, 40),
            },
           ],
           position: (709, 16),
          },
         },
        ],
        recursive: false,
        position: (707, 34),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCartesianProductOfTwoSets",
          position: (712, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (713, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (713, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (713, 37),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 1,
                  position: (713, 43),
                 },
                ],
                position: (713, 41),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (713, 48),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 10,
                  position: (713, 54),
                 },
                 Int {
                  value: 20,
                  position: (713, 57),
                 },
                ],
                position: (713, 52),
               },
              },
             ],
             recursive: false,
             position: (713, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (714, 5),
            },
           ],
          },
          to: List {
           elements: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (715, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (715, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (715, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (715, 20),
               },
              },
             ],
             recursive: false,
             position: (715, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (716, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (716, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (716, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (716, 20),
               },
              },
             ],
             recursive: false,
             position: (716, 7),
            },
           ],
           position: (714, 16),
          },
         },
        ],
        recursive: false,
        position: (712, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCartesianProductOfTwoSetsWithOneEmpty",
          position: (720, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (721, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (721, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (721, 37),
                 },
                ],
               },
               to: List {
                elements: [],
                position: (721, 41),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (721, 46),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 10,
                  position: (721, 52),
                 },
                 Int {
                  value: 20,
                  position: (721, 55),
                 },
                ],
                position: (721, 50),
               },
              },
             ],
             recursive: false,
             position: (721, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (722, 5),
            },
           ],
          },
          to: List {
           elements: [],
           position: (722, 16),
          },
         },
        ],
        recursive: false,
        position: (720, 47),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCartesianProductOfThreeSets",
          position: (725, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (726, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (726, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (727, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 1,
                  position: (727, 15),
                 },
                 Int {
                  value: 2,
                  position: (727, 19),
                 },
                 Int {
                  value: 3,
                  position: (727, 23),
                 },
                ],
                position: (727, 11),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (728, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 10,
                  position: (728, 14),
                 },
                 Int {
                  value: 20,
                  position: (728, 18),
                 },
                 Int {
                  value: 30,
                  position: (728, 22),
                 },
                ],
                position: (728, 11),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (729, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 Int {
                  value: 100,
                  position: (729, 13),
                 },
                 Int {
                  value: 200,
                  position: (729, 17),
                 },
                 Int {
                  value: 300,
                  position: (729, 21),
                 },
                ],
                position: (729, 11),
               },
              },
             ],
             recursive: false,
             position: (726, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (731, 5),
            },
           ],
          },
          to: List {
           elements: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (732, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (732, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (732, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (732, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (732, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (732, 28),
               },
              },
             ],
             recursive: false,
             position: (732, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (733, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (733, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (733, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (733, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (733, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (733, 28),
               },
              },
             ],
             recursive: false,
             position: (733, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (734, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (734, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (734, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (734, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (734, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (734, 28),
               },
              },
             ],
             recursive: false,
             position: (734, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (736, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (736, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (736, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (736, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (736, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (736, 28),
               },
              },
             ],
             recursive: false,
             position: (736, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (737, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (737, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (737, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (737, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (737, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (737, 28),
               },
              },
             ],
             recursive: false,
             position: (737, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (738, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (738, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (738, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (738, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (738, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (738, 28),
               },
              },
             ],
             recursive: false,
             position: (738, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (740, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (740, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (740, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (740, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (740, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (740, 28),
               },
              },
             ],
             recursive: false,
             position: (740, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (741, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (741, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (741, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (741, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (741, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (741, 28),
               },
              },
             ],
             recursive: false,
             position: (741, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (742, 9),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (742, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (742, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (742, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (742, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (742, 28),
               },
              },
             ],
             recursive: false,
             position: (742, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (744, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (744, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (744, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (744, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (744, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (744, 28),
               },
              },
             ],
             recursive: false,
             position: (744, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (745, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (745, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (745, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (745, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (745, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (745, 28),
               },
              },
             ],
             recursive: false,
             position: (745, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (746, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (746, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (746, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (746, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (746, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (746, 28),
               },
              },
             ],
             recursive: false,
             position: (746, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (748, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (748, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (748, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (748, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (748, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (748, 28),
               },
              },
             ],
             recursive: false,
             position: (748, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (749, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (749, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (749, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (749, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (749, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (749, 28),
               },
              },
             ],
             recursive: false,
             position: (749, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (750, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (750, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (750, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (750, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (750, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (750, 28),
               },
              },
             ],
             recursive: false,
             position: (750, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (752, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (752, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (752, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (752, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (752, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (752, 28),
               },
              },
             ],
             recursive: false,
             position: (752, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (753, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (753, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (753, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (753, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (753, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (753, 28),
               },
              },
             ],
             recursive: false,
             position: (753, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (754, 9),
                 },
                ],
               },
               to: Int {
                value: 2,
                position: (754, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (754, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (754, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (754, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (754, 28),
               },
              },
             ],
             recursive: false,
             position: (754, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (756, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (756, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (756, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (756, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (756, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (756, 28),
               },
              },
             ],
             recursive: false,
             position: (756, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (757, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (757, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (757, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (757, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (757, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (757, 28),
               },
              },
             ],
             recursive: false,
             position: (757, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (758, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (758, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (758, 16),
                 },
                ],
               },
               to: Int {
                value: 10,
                position: (758, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (758, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (758, 28),
               },
              },
             ],
             recursive: false,
             position: (758, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (760, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (760, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (760, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (760, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (760, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (760, 28),
               },
              },
             ],
             recursive: false,
             position: (760, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (761, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (761, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (761, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (761, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (761, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (761, 28),
               },
              },
             ],
             recursive: false,
             position: (761, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (762, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (762, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (762, 16),
                 },
                ],
               },
               to: Int {
                value: 20,
                position: (762, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (762, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (762, 28),
               },
              },
             ],
             recursive: false,
             position: (762, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (764, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (764, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (764, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (764, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (764, 24),
                 },
                ],
               },
               to: Int {
                value: 100,
                position: (764, 28),
               },
              },
             ],
             recursive: false,
             position: (764, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (765, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (765, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (765, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (765, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (765, 24),
                 },
                ],
               },
               to: Int {
                value: 200,
                position: (765, 28),
               },
              },
             ],
             recursive: false,
             position: (765, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (766, 9),
                 },
                ],
               },
               to: Int {
                value: 3,
                position: (766, 13),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "b",
                  position: (766, 16),
                 },
                ],
               },
               to: Int {
                value: 30,
                position: (766, 20),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (766, 24),
                 },
                ],
               },
               to: Int {
                value: 300,
                position: (766, 28),
               },
              },
             ],
             recursive: false,
             position: (766, 7),
            },
           ],
           position: (731, 16),
          },
         },
        ],
        recursive: false,
        position: (725, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testShowAttrPathExample",
          position: (771, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (772, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (772, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (772, 28),
                },
               ],
               position: (772, 27),
              },
              String {
               parts: [
                Raw {
                 content: "10",
                 position: (772, 34),
                },
               ],
               position: (772, 33),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                 position: (772, 39),
                },
               ],
               position: (772, 38),
              },
             ],
             position: (772, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (773, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "foo.\"10\".bar",
             position: (773, 17),
            },
           ],
           position: (773, 16),
          },
         },
        ],
        recursive: false,
        position: (771, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testShowAttrPathEmpty",
          position: (776, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (777, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (777, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (777, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (778, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "<root attribute path>",
             position: (778, 17),
            },
           ],
           position: (778, 16),
          },
         },
        ],
        recursive: false,
        position: (776, 27),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testShowAttrPathVarious",
          position: (781, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (782, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (782, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: ".",
                 position: (783, 8),
                },
               ],
               position: (783, 7),
              },
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (784, 8),
                },
               ],
               position: (784, 7),
              },
              String {
               parts: [
                Raw {
                 content: "2",
                 position: (785, 8),
                },
               ],
               position: (785, 7),
              },
              String {
               parts: [
                Raw {
                 content: "a2-b",
                 position: (786, 8),
                },
               ],
               position: (786, 7),
              },
              String {
               parts: [
                Raw {
                 content: "_bc'de",
                 position: (787, 8),
                },
               ],
               position: (787, 7),
              },
             ],
             position: (782, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (789, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "\".\".foo.\"2\".a2-b._bc'de",
             position: (789, 18),
            },
           ],
           position: (789, 16),
          },
         },
        ],
        recursive: false,
        position: (781, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testGroupBy",
          position: (792, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (793, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "groupBy",
            position: (793, 12),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "n",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (793, 24),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "mod",
                   position: (793, 34),
                  },
                  arguments: [
                   Variable {
                    identifier: "n",
                    position: (793, 38),
                   },
                   Int {
                    value: 5,
                    position: (793, 40),
                   },
                  ],
                 },
                 position: (793, 33),
                },
               ],
              },
              position: (793, 21),
             },
             position: (793, 20),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "range",
               position: (793, 45),
              },
              arguments: [
               Int {
                value: 0,
                position: (793, 51),
               },
               Int {
                value: 16,
                position: (793, 53),
               },
              ],
             },
             position: (793, 44),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (794, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Expression {
                ast: String {
                 parts: [
                  Raw {
                   content: "0",
                   position: (795, 8),
                  },
                 ],
                 position: (795, 7),
                },
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 0,
                position: (795, 15),
               },
               Int {
                value: 5,
                position: (795, 17),
               },
               Int {
                value: 10,
                position: (795, 19),
               },
               Int {
                value: 15,
                position: (795, 22),
               },
              ],
              position: (795, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Expression {
                ast: String {
                 parts: [
                  Raw {
                   content: "1",
                   position: (796, 8),
                  },
                 ],
                 position: (796, 7),
                },
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 1,
                position: (796, 15),
               },
               Int {
                value: 6,
                position: (796, 17),
               },
               Int {
                value: 11,
                position: (796, 19),
               },
               Int {
                value: 16,
                position: (796, 22),
               },
              ],
              position: (796, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Expression {
                ast: String {
                 parts: [
                  Raw {
                   content: "2",
                   position: (797, 8),
                  },
                 ],
                 position: (797, 7),
                },
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 2,
                position: (797, 15),
               },
               Int {
                value: 7,
                position: (797, 17),
               },
               Int {
                value: 12,
                position: (797, 19),
               },
              ],
              position: (797, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Expression {
                ast: String {
                 parts: [
                  Raw {
                   content: "3",
                   position: (798, 8),
                  },
                 ],
                 position: (798, 7),
                },
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 3,
                position: (798, 15),
               },
               Int {
                value: 8,
                position: (798, 17),
               },
               Int {
                value: 13,
                position: (798, 19),
               },
              ],
              position: (798, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Expression {
                ast: String {
                 parts: [
                  Raw {
                   content: "4",
                   position: (799, 8),
                  },
                 ],
                 position: (799, 7),
                },
               },
              ],
             },
             to: List {
              elements: [
               Int {
                value: 4,
                position: (799, 15),
               },
               Int {
                value: 9,
                position: (799, 17),
               },
               Int {
                value: 14,
                position: (799, 19),
               },
              ],
              position: (799, 13),
             },
            },
           ],
           recursive: false,
           position: (794, 16),
          },
         },
        ],
        recursive: false,
        position: (792, 17),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testGroupBy'",
          position: (803, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (804, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "groupBy'",
            position: (804, 12),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (804, 21),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "add",
                position: (804, 30),
               },
              ],
             },
             default: None,
            },
            Int {
             value: 0,
             position: (804, 34),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "boolToString",
                position: (804, 40),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: GreaterThan,
                  operands: [
                   Variable {
                    identifier: "x",
                    position: (804, 54),
                   },
                   Int {
                    value: 2,
                    position: (804, 58),
                   },
                  ],
                  position: (804, 56),
                 },
                 position: (804, 53),
                },
               ],
              },
              position: (804, 37),
             },
             position: (804, 36),
            },
            List {
             elements: [
              Int {
               value: 5,
               position: (804, 64),
              },
              Int {
               value: 1,
               position: (804, 66),
              },
              Int {
               value: 2,
               position: (804, 68),
              },
              Int {
               value: 3,
               position: (804, 70),
              },
              Int {
               value: 4,
               position: (804, 72),
              },
             ],
             position: (804, 62),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (805, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "false",
                position: (805, 18),
               },
              ],
             },
             to: Int {
              value: 3,
              position: (805, 26),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "true",
                position: (805, 29),
               },
              ],
             },
             to: Int {
              value: 12,
              position: (805, 36),
             },
            },
           ],
           recursive: false,
           position: (805, 16),
          },
         },
        ],
        recursive: false,
        position: (803, 18),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathExample",
          position: (809, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (810, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (810, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (812, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                      position: (812, 19),
                     },
                    ],
                    position: (812, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                      position: (812, 23),
                     },
                    ],
                    position: (812, 22),
                   },
                  ],
                  position: (812, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (813, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "d",
                        position: (813, 25),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "old",
                       position: (813, 29),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "c",
                         position: (813, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                   ],
                   recursive: false,
                   position: (813, 23),
                  },
                  position: (813, 18),
                 },
                },
               ],
               recursive: false,
               position: (811, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (816, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                      position: (816, 19),
                     },
                    ],
                    position: (816, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                      position: (816, 23),
                     },
                    ],
                    position: (816, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                      position: (816, 27),
                     },
                    ],
                    position: (816, 26),
                   },
                  ],
                  position: (816, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (817, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (817, 23),
                    },
                    Int {
                     value: 1,
                     position: (817, 29),
                    },
                   ],
                   position: (817, 27),
                  },
                  position: (817, 18),
                 },
                },
               ],
               recursive: false,
               position: (815, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (820, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "x",
                      position: (820, 19),
                     },
                    ],
                    position: (820, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "y",
                      position: (820, 23),
                     },
                    ],
                    position: (820, 22),
                   },
                  ],
                  position: (820, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (821, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "xy",
                     position: (821, 24),
                    },
                   ],
                   position: (821, 23),
                  },
                  position: (821, 18),
                 },
                },
               ],
               recursive: false,
               position: (819, 7),
              },
             ],
             position: (810, 34),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (823, 9),
                 },
                 Raw {
                  content: "b",
                  position: (823, 11),
                 },
                 Raw {
                  content: "c",
                  position: (823, 13),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (823, 17),
               },
              },
             ],
             recursive: false,
             position: (823, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (824, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (824, 18),
               },
              ],
             },
             to: Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "b",
                   position: (824, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "d",
                      position: (824, 30),
                     },
                    ],
                   },
                   to: Int {
                    value: 1,
                    position: (824, 34),
                   },
                  },
                 ],
                 recursive: false,
                 position: (824, 28),
                },
               },
              ],
              recursive: false,
              position: (824, 22),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "x",
                position: (824, 43),
               },
              ],
             },
             to: Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "y",
                   position: (824, 49),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "xy",
                   position: (824, 54),
                  },
                 ],
                 position: (824, 53),
                },
               },
              ],
              recursive: false,
              position: (824, 47),
             },
            },
           ],
           recursive: false,
           position: (824, 16),
          },
         },
        ],
        recursive: false,
        position: (809, 38),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathNone",
          position: (828, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (829, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (829, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (829, 34),
            },
            String {
             parts: [
              Raw {
               content: "something",
               position: (829, 38),
              },
             ],
             position: (829, 37),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (830, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "something",
             position: (830, 17),
            },
           ],
           position: (830, 16),
          },
         },
        ],
        recursive: false,
        position: (828, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathSingleIncrement",
          position: (834, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (835, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (835, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (837, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (837, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (838, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (838, 23),
                    },
                    Int {
                     value: 1,
                     position: (838, 29),
                    },
                   ],
                   position: (838, 27),
                  },
                  position: (838, 18),
                 },
                },
               ],
               recursive: false,
               position: (836, 7),
              },
             ],
             position: (835, 34),
            },
            Int {
             value: 0,
             position: (840, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (841, 5),
            },
           ],
          },
          to: Int {
           value: 1,
           position: (841, 16),
          },
         },
        ],
        recursive: false,
        position: (834, 46),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathMultipleIncrements",
          position: (845, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (846, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (846, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (848, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (848, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (849, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (849, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "a",
                       position: (849, 30),
                      },
                     ],
                     position: (849, 29),
                    },
                   ],
                   position: (849, 27),
                  },
                  position: (849, 18),
                 },
                },
               ],
               recursive: false,
               position: (847, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (852, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (852, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (853, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (853, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "b",
                       position: (853, 30),
                      },
                     ],
                     position: (853, 29),
                    },
                   ],
                   position: (853, 27),
                  },
                  position: (853, 18),
                 },
                },
               ],
               recursive: false,
               position: (851, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (856, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (856, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (857, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (857, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "c",
                       position: (857, 30),
                      },
                     ],
                     position: (857, 29),
                    },
                   ],
                   position: (857, 27),
                  },
                  position: (857, 18),
                 },
                },
               ],
               recursive: false,
               position: (855, 7),
              },
             ],
             position: (846, 34),
            },
            String {
             parts: [],
             position: (859, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (860, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "abc",
             position: (860, 17),
            },
           ],
           position: (860, 16),
          },
         },
        ],
        recursive: false,
        position: (845, 49),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathLazy",
          position: (864, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (865, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (865, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (867, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (867, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (868, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (868, 23),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "throw",
                      position: (868, 29),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "nope",
                         position: (868, 36),
                        },
                       ],
                       position: (868, 35),
                      },
                     ],
                    },
                   ],
                   position: (868, 27),
                  },
                  position: (868, 18),
                 },
                },
               ],
               recursive: false,
               position: (866, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (871, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (871, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (872, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "untainted",
                     position: (872, 24),
                    },
                   ],
                   position: (872, 23),
                  },
                  position: (872, 18),
                 },
                },
               ],
               recursive: false,
               position: (870, 7),
              },
             ],
             position: (865, 34),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (874, 8),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "start",
                  position: (874, 15),
                 },
                ],
                position: (874, 14),
               },
              ],
             },
             position: (874, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (875, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "untainted",
             position: (875, 17),
            },
           ],
           position: (875, 16),
          },
         },
        ],
        recursive: false,
        position: (864, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathDeep",
          position: (879, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (880, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (880, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (882, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                      position: (882, 19),
                     },
                    ],
                    position: (882, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                      position: (882, 23),
                     },
                    ],
                    position: (882, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                      position: (882, 27),
                     },
                    ],
                    position: (882, 26),
                   },
                  ],
                  position: (882, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (883, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (883, 23),
                    },
                    Int {
                     value: 1,
                     position: (883, 29),
                    },
                   ],
                   position: (883, 27),
                  },
                  position: (883, 18),
                 },
                },
               ],
               recursive: false,
               position: (881, 7),
              },
             ],
             position: (880, 34),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (886, 7),
                 },
                 Raw {
                  content: "b",
                  position: (886, 9),
                 },
                 Raw {
                  content: "c",
                  position: (886, 11),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (886, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (888, 7),
                 },
                 Raw {
                  content: "b",
                  position: (888, 9),
                 },
                 Raw {
                  content: "z",
                  position: (888, 11),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (888, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (889, 7),
                 },
                 Raw {
                  content: "y",
                  position: (889, 9),
                 },
                 Raw {
                  content: "z",
                  position: (889, 11),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (889, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "x",
                  position: (890, 7),
                 },
                 Raw {
                  content: "y",
                  position: (890, 9),
                 },
                 Raw {
                  content: "z",
                  position: (890, 11),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (890, 15),
               },
              },
             ],
             recursive: false,
             position: (885, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (892, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (893, 7),
               },
               Raw {
                content: "b",
                position: (893, 9),
               },
               Raw {
                content: "c",
                position: (893, 11),
               },
              ],
             },
             to: Int {
              value: 1,
              position: (893, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (895, 7),
               },
               Raw {
                content: "b",
                position: (895, 9),
               },
               Raw {
                content: "z",
                position: (895, 11),
               },
              ],
             },
             to: Int {
              value: 0,
              position: (895, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (896, 7),
               },
               Raw {
                content: "y",
                position: (896, 9),
               },
               Raw {
                content: "z",
                position: (896, 11),
               },
              ],
             },
             to: Int {
              value: 0,
              position: (896, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "x",
                position: (897, 7),
               },
               Raw {
                content: "y",
                position: (897, 9),
               },
               Raw {
                content: "z",
                position: (897, 11),
               },
              ],
             },
             to: Int {
              value: 0,
              position: (897, 15),
             },
            },
           ],
           recursive: false,
           position: (892, 16),
          },
         },
        ],
        recursive: false,
        position: (879, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testUpdateManyAttrsByPathNestedBeforehand",
          position: (902, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (903, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (903, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (905, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                      position: (905, 19),
                     },
                    ],
                    position: (905, 18),
                   },
                  ],
                  position: (905, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (906, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (906, 23),
                    },
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "x",
                          position: (906, 32),
                         },
                        ],
                       },
                       to: PropertyAccess {
                        expression: Variable {
                         identifier: "old",
                         position: (906, 36),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "b",
                           position: (906, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                     ],
                     recursive: false,
                     position: (906, 30),
                    },
                   ],
                   position: (906, 27),
                  },
                  position: (906, 18),
                 },
                },
               ],
               recursive: false,
               position: (904, 7),
              },
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "path",
                    position: (909, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                      position: (909, 19),
                     },
                    ],
                    position: (909, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                      position: (909, 23),
                     },
                    ],
                    position: (909, 22),
                   },
                  ],
                  position: (909, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "update",
                    position: (910, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "old",
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (910, 23),
                    },
                    Int {
                     value: 1,
                     position: (910, 29),
                    },
                   ],
                   position: (910, 27),
                  },
                  position: (910, 18),
                 },
                },
               ],
               recursive: false,
               position: (908, 7),
              },
             ],
             position: (903, 34),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "a",
                  position: (913, 7),
                 },
                 Raw {
                  content: "b",
                  position: (913, 9),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (913, 13),
               },
              },
             ],
             recursive: false,
             position: (912, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (915, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (916, 7),
               },
               Raw {
                content: "b",
                position: (916, 9),
               },
              ],
             },
             to: Int {
              value: 1,
              position: (916, 13),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "a",
                position: (917, 7),
               },
               Raw {
                content: "x",
                position: (917, 9),
               },
              ],
             },
             to: Int {
              value: 1,
              position: (917, 13),
             },
            },
           ],
           recursive: false,
           position: (915, 16),
          },
         },
        ],
        recursive: false,
        position: (902, 47),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonPrefixLengthEmpty",
          position: (922, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (923, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (923, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonPrefixLength",
               position: (923, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (923, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (923, 43),
              },
             ],
             position: (923, 42),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (924, 5),
            },
           ],
          },
          to: Int {
           value: 0,
           position: (924, 16),
          },
         },
        ],
        recursive: false,
        position: (922, 33),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonPrefixLengthSame",
          position: (927, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (928, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (928, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonPrefixLength",
               position: (928, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
               position: (928, 40),
              },
             ],
             position: (928, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (928, 48),
              },
             ],
             position: (928, 47),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (929, 5),
            },
           ],
          },
          to: Int {
           value: 5,
           position: (929, 16),
          },
         },
        ],
        recursive: false,
        position: (927, 32),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonPrefixLengthDiffering",
          position: (932, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (933, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (933, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonPrefixLength",
               position: (933, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
               position: (933, 40),
              },
             ],
             position: (933, 39),
            },
            String {
             parts: [
              Raw {
               content: "hey",
               position: (933, 48),
              },
             ],
             position: (933, 47),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (934, 5),
            },
           ],
          },
          to: Int {
           value: 2,
           position: (934, 16),
          },
         },
        ],
        recursive: false,
        position: (932, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonSuffixLengthEmpty",
          position: (937, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (938, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (938, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonSuffixLength",
               position: (938, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (938, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (938, 43),
              },
             ],
             position: (938, 42),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (939, 5),
            },
           ],
          },
          to: Int {
           value: 0,
           position: (939, 16),
          },
         },
        ],
        recursive: false,
        position: (937, 33),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonSuffixLengthSame",
          position: (942, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (943, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (943, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonSuffixLength",
               position: (943, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
               position: (943, 40),
              },
             ],
             position: (943, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (943, 48),
              },
             ],
             position: (943, 47),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (944, 5),
            },
           ],
          },
          to: Int {
           value: 5,
           position: (944, 16),
          },
         },
        ],
        recursive: false,
        position: (942, 32),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testCommonSuffixLengthDiffering",
          position: (947, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (948, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (948, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "commonSuffixLength",
               position: (948, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "test",
               position: (948, 40),
              },
             ],
             position: (948, 39),
            },
            String {
             parts: [
              Raw {
               content: "rest",
               position: (948, 47),
              },
             ],
             position: (948, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (949, 5),
            },
           ],
          },
          to: Int {
           value: 3,
           position: (949, 16),
          },
         },
        ],
        recursive: false,
        position: (947, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinEmpty",
          position: (952, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (953, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (953, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshtein",
               position: (953, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (953, 32),
            },
            String {
             parts: [],
             position: (953, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (954, 5),
            },
           ],
          },
          to: Int {
           value: 0,
           position: (954, 16),
          },
         },
        ],
        recursive: false,
        position: (952, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinOnlyAdd",
          position: (957, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (958, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (958, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshtein",
               position: (958, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (958, 32),
            },
            String {
             parts: [
              Raw {
               content: "hello there",
               position: (958, 36),
              },
             ],
             position: (958, 35),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (959, 5),
            },
           ],
          },
          to: Int {
           value: 11,
           position: (959, 16),
          },
         },
        ],
        recursive: false,
        position: (957, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinOnlyRemove",
          position: (962, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (963, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (963, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshtein",
               position: (963, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello there",
               position: (963, 33),
              },
             ],
             position: (963, 32),
            },
            String {
             parts: [],
             position: (963, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (964, 5),
            },
           ],
          },
          to: Int {
           value: 11,
           position: (964, 16),
          },
         },
        ],
        recursive: false,
        position: (962, 31),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinOnlyTransform",
          position: (967, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (968, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (968, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshtein",
               position: (968, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (968, 33),
              },
             ],
             position: (968, 32),
            },
            String {
             parts: [
              Raw {
               content: "ghijkl",
               position: (968, 42),
              },
             ],
             position: (968, 41),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (969, 5),
            },
           ],
          },
          to: Int {
           value: 6,
           position: (969, 16),
          },
         },
        ],
        recursive: false,
        position: (967, 34),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinMixed",
          position: (972, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (973, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (973, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshtein",
               position: (973, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "kitchen",
               position: (973, 33),
              },
             ],
             position: (973, 32),
            },
            String {
             parts: [
              Raw {
               content: "sitting",
               position: (973, 43),
              },
             ],
             position: (973, 42),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (974, 5),
            },
           ],
          },
          to: Int {
           value: 5,
           position: (974, 16),
          },
         },
        ],
        recursive: false,
        position: (972, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostZeroFalse",
          position: (977, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (978, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (978, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (978, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (978, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
               position: (978, 41),
              },
             ],
             position: (978, 40),
            },
            String {
             parts: [
              Raw {
               content: "boo",
               position: (978, 47),
              },
             ],
             position: (978, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (979, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (979, 16),
          },
         },
        ],
        recursive: false,
        position: (977, 36),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostZeroTrue",
          position: (982, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (983, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (983, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (983, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (983, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
               position: (983, 41),
              },
             ],
             position: (983, 40),
            },
            String {
             parts: [
              Raw {
               content: "foo",
               position: (983, 47),
              },
             ],
             position: (983, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (984, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (984, 16),
          },
         },
        ],
        recursive: false,
        position: (982, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostOneFalse",
          position: (987, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (988, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (988, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (988, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (988, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
               position: (988, 41),
              },
             ],
             position: (988, 40),
            },
            String {
             parts: [
              Raw {
               content: "ct",
               position: (988, 47),
              },
             ],
             position: (988, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (989, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (989, 16),
          },
         },
        ],
        recursive: false,
        position: (987, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostOneTrue",
          position: (992, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (993, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (993, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (993, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (993, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
               position: (993, 41),
              },
             ],
             position: (993, 40),
            },
            String {
             parts: [
              Raw {
               content: "cr",
               position: (993, 47),
              },
             ],
             position: (993, 46),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (994, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (994, 16),
          },
         },
        ],
        recursive: false,
        position: (992, 34),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoIsEmpty",
          position: (999, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1000, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1000, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1000, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1000, 38),
            },
            String {
             parts: [],
             position: (1000, 40),
            },
            String {
             parts: [],
             position: (1000, 43),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1001, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1001, 16),
          },
         },
        ],
        recursive: false,
        position: (999, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoIsZero",
          position: (1004, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1005, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1005, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1005, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1005, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1005, 41),
              },
             ],
             position: (1005, 40),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1005, 50),
              },
             ],
             position: (1005, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1006, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1006, 16),
          },
         },
        ],
        recursive: false,
        position: (1004, 36),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoIsOne",
          position: (1009, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1010, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1010, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1010, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1010, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1010, 41),
              },
             ],
             position: (1010, 40),
            },
            String {
             parts: [
              Raw {
               content: "abddef",
               position: (1010, 50),
              },
             ],
             position: (1010, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1011, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1011, 16),
          },
         },
        ],
        recursive: false,
        position: (1009, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0False",
          position: (1014, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1015, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1015, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1015, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1015, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1015, 41),
              },
             ],
             position: (1015, 40),
            },
            String {
             parts: [
              Raw {
               content: "aczyef",
               position: (1015, 50),
              },
             ],
             position: (1015, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1016, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (1016, 16),
          },
         },
        ],
        recursive: false,
        position: (1014, 40),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0Outer",
          position: (1019, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1020, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1020, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1020, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1020, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1020, 41),
              },
             ],
             position: (1020, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcdez",
               position: (1020, 50),
              },
             ],
             position: (1020, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1021, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1021, 16),
          },
         },
        ],
        recursive: false,
        position: (1019, 40),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelLeft",
          position: (1024, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1025, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1025, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1025, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1025, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1025, 41),
              },
             ],
             position: (1025, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdefz",
               position: (1025, 50),
              },
             ],
             position: (1025, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1026, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1026, 16),
          },
         },
        ],
        recursive: false,
        position: (1024, 42),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelRight",
          position: (1029, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1030, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1030, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1030, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1030, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1030, 41),
              },
             ],
             position: (1030, 40),
            },
            String {
             parts: [
              Raw {
               content: "zabcde",
               position: (1030, 50),
              },
             ],
             position: (1030, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1031, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1031, 16),
          },
         },
        ],
        recursive: false,
        position: (1029, 43),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1False",
          position: (1034, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1035, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1035, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1035, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1035, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1035, 41),
              },
             ],
             position: (1035, 40),
            },
            String {
             parts: [
              Raw {
               content: "bddez",
               position: (1035, 50),
              },
             ],
             position: (1035, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1036, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (1036, 16),
          },
         },
        ],
        recursive: false,
        position: (1034, 40),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelLeft",
          position: (1039, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1040, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1040, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1040, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1040, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1040, 41),
              },
             ],
             position: (1040, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdez",
               position: (1040, 50),
              },
             ],
             position: (1040, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1041, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1041, 16),
          },
         },
        ],
        recursive: false,
        position: (1039, 42),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelRight",
          position: (1044, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1045, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1045, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1045, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1045, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
               position: (1045, 41),
              },
             ],
             position: (1045, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcde",
               position: (1045, 50),
              },
             ],
             position: (1045, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1046, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1046, 16),
          },
         },
        ],
        recursive: false,
        position: (1044, 43),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2False",
          position: (1049, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1050, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1050, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1050, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1050, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (1050, 41),
              },
             ],
             position: (1050, 40),
            },
            String {
             parts: [
              Raw {
               content: "hxo",
               position: (1050, 49),
              },
             ],
             position: (1050, 48),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1051, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (1051, 16),
          },
         },
        ],
        recursive: false,
        position: (1049, 40),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2True",
          position: (1054, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1055, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1055, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1055, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1055, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (1055, 41),
              },
             ],
             position: (1055, 40),
            },
            String {
             parts: [
              Raw {
               content: "heo",
               position: (1055, 49),
              },
             ],
             position: (1055, 48),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1056, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1056, 16),
          },
         },
        ],
        recursive: false,
        position: (1054, 39),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff3",
          position: (1059, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1060, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1060, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1060, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1060, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (1060, 41),
              },
             ],
             position: (1060, 40),
            },
            String {
             parts: [
              Raw {
               content: "ho",
               position: (1060, 49),
              },
             ],
             position: (1060, 48),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1061, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (1061, 16),
          },
         },
        ],
        recursive: false,
        position: (1059, 35),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostThreeFalse",
          position: (1064, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1065, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1065, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1065, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 3,
             position: (1065, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (1065, 41),
              },
             ],
             position: (1065, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla!",
               position: (1065, 49),
              },
             ],
             position: (1065, 48),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1066, 5),
            },
           ],
          },
          to: Variable {
           identifier: "false",
           position: (1066, 16),
          },
         },
        ],
        recursive: false,
        position: (1064, 37),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testLevenshteinAtMostThreeTrue",
          position: (1069, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expr",
             position: (1070, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1070, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "levenshteinAtMost",
               position: (1070, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 3,
             position: (1070, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
               position: (1070, 41),
              },
             ],
             position: (1070, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla",
               position: (1070, 49),
              },
             ],
             position: (1070, 48),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "expected",
             position: (1071, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (1071, 16),
          },
         },
        ],
        recursive: false,
        position: (1069, 36),
       },
      },
     ],
     recursive: false,
     position: (23, 10),
    },
   ],
  },
  position: (6, 1),
 },
 position: (4, 1),
}