---
With {
 expression: FunctionApplication {
  function: Variable {
   identifier: "import",
   position: (4, 6),
  },
  arguments: [
   Path {
    parts: [
     Raw {
      content: "../default.nix",
     },
    ],
    position: (4, 13),
   },
  ],
 },
 target: LetIn {
  bindings: [
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "testSanitizeDerivationName",
       position: (8, 3),
      },
     ],
    },
    Function {
     argument: None,
     arguments: FunctionArguments {
      arguments: [
       FunctionArgument {
        identifier: "expected",
        default: None,
       },
       FunctionArgument {
        identifier: "name",
        default: None,
       },
      ],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "drv",
           position: (10, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "derivation",
          position: (10, 11),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (11, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "strings",
                position: (11, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "sanitizeDerivationName",
                  position: (11, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "name",
                position: (11, 45),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "builder",
                position: (12, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "x",
               },
              ],
              position: (12, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "system",
                position: (13, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "x",
               },
              ],
              position: (13, 16),
             },
            ),
           ],
           recursive: false,
           position: (10, 22),
          },
         ],
        },
       ),
      ],
      target: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "expr",
            position: (17, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (17, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seq",
              position: (17, 21),
             },
            ],
           },
           default: None,
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "drv",
             position: (17, 25),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "drvPath",
               position: (17, 29),
              },
             ],
            },
            default: None,
           },
           PropertyAccess {
            expression: Variable {
             identifier: "drv",
             position: (17, 37),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (17, 41),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ),
        Inherit(
         None,
         [
          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: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testId",
          position: (28, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (29, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "id",
            position: (29, 12),
           },
           arguments: [
            Int {
             value: 1,
             position: (29, 15),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (30, 5),
            },
           ],
          },
          Int {
           value: 1,
           position: (30, 16),
          },
         ),
        ],
        recursive: false,
        position: (28, 12),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testConst",
          position: (33, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (34, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "const",
            position: (34, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (34, 18),
            },
            Int {
             value: 3,
             position: (34, 20),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (35, 5),
            },
           ],
          },
          Int {
           value: 2,
           position: (35, 16),
          },
         ),
        ],
        recursive: false,
        position: (33, 15),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testPipe",
          position: (38, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (39, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "pipe",
            position: (39, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (39, 17),
            },
            List {
             elements: [
              Function {
               argument: Some(
                "x",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: Addition,
                operands: [
                 Variable {
                  identifier: "x",
                  position: (40, 11),
                 },
                 Int {
                  value: 2,
                  position: (40, 15),
                 },
                ],
                position: (40, 13),
               },
               position: (40, 8),
              },
              Function {
               argument: Some(
                "x",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: Multiplication,
                operands: [
                 Variable {
                  identifier: "x",
                  position: (41, 11),
                 },
                 Int {
                  value: 2,
                  position: (41, 15),
                 },
                ],
                position: (41, 13),
               },
               position: (41, 8),
              },
             ],
             position: (39, 19),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (43, 5),
            },
           ],
          },
          Int {
           value: 8,
           position: (43, 16),
          },
         ),
        ],
        recursive: false,
        position: (38, 14),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testPipeEmpty",
          position: (46, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (47, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "pipe",
            position: (47, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (47, 17),
            },
            List {
             elements: [],
             position: (47, 19),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (48, 5),
            },
           ],
          },
          Int {
           value: 2,
           position: (48, 16),
          },
         ),
        ],
        recursive: false,
        position: (46, 19),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testPipeStrings",
          position: (51, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (52, 5),
            },
           ],
          },
          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: [
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (53, 8),
               },
               arguments: [
                Variable {
                 identifier: "toString",
                 position: (53, 12),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (54, 8),
               },
               arguments: [
                Function {
                 argument: Some(
                  "s",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: BinaryOperation {
                  operator: Addition,
                  operands: [
                   Variable {
                    identifier: "s",
                    position: (54, 16),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "\n",
                     },
                    ],
                    position: (54, 20),
                   },
                  ],
                  position: (54, 18),
                 },
                 position: (54, 13),
                },
               ],
              },
              Variable {
               identifier: "concatStrings",
               position: (55, 7),
              },
             ],
             position: (52, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (57, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "3\n4\n",
            },
           ],
           position: (57, 16),
          },
         ),
        ],
        recursive: false,
        position: (51, 21),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testAnd",
          position: (70, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (71, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "and",
            position: (71, 12),
           },
           arguments: [
            Variable {
             identifier: "true",
             position: (71, 16),
            },
            Variable {
             identifier: "false",
             position: (71, 21),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (72, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (72, 16),
          },
         ),
        ],
        recursive: false,
        position: (70, 13),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFix",
          position: (75, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (76, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "fix",
            position: (76, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "a",
                   position: (76, 21),
                  },
                 ],
                },
                IfThenElse {
                 predicate: HasProperty {
                  expression: Variable {
                   identifier: "x",
                   position: (76, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "a",
                     position: (76, 32),
                    },
                   ],
                  },
                  position: (76, 30),
                 },
                 then: String {
                  parts: [
                   Raw {
                    content: "a",
                   },
                  ],
                  position: (76, 39),
                 },
                 else_: String {
                  parts: [
                   Raw {
                    content: "b",
                   },
                  ],
                  position: (76, 48),
                 },
                 position: (76, 25),
                },
               ),
              ],
              recursive: false,
              position: (76, 20),
             },
             position: (76, 17),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (77, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (77, 17),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "a",
               },
              ],
              position: (77, 21),
             },
            ),
           ],
           recursive: false,
           position: (77, 16),
          },
         ),
        ],
        recursive: false,
        position: (75, 13),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testComposeExtensions",
          position: (80, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (81, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "obj",
                position: (81, 16),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "makeExtensible",
               position: (81, 22),
              },
              arguments: [
               Function {
                argument: Some(
                 "self",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "foo",
                      position: (81, 46),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "self",
                     position: (81, 52),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bar",
                       position: (81, 57),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (81, 44),
                },
                position: (81, 38),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "f",
                position: (82, 16),
               },
              ],
             },
             Function {
              argument: Some(
               "self",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "super",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bar",
                     position: (82, 35),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (82, 41),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "baz",
                     position: (82, 48),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (82, 54),
                  },
                 ),
                ],
                recursive: false,
                position: (82, 33),
               },
               position: (82, 26),
              },
              position: (82, 20),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "g",
                position: (83, 16),
               },
              ],
             },
             Function {
              argument: Some(
               "self",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "super",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bar",
                     position: (83, 35),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "super",
                    position: (83, 41),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     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),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "f_o_g",
                position: (84, 16),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "composeExtensions",
               position: (84, 24),
              },
              arguments: [
               Variable {
                identifier: "f",
                position: (84, 42),
               },
               Variable {
                identifier: "g",
                position: (84, 44),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "composed",
                position: (85, 16),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "obj",
                position: (85, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 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 {
             attributes: [
              Raw {
               content: "foo",
               position: (86, 24),
              },
             ],
            },
            default: None,
           },
           position: (81, 12),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (87, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (87, 16),
          },
         ),
        ],
        recursive: false,
        position: (80, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testComposeManyExtensions0",
          position: (90, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (91, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "obj",
                position: (91, 16),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "makeExtensible",
               position: (91, 22),
              },
              arguments: [
               Function {
                argument: Some(
                 "self",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "foo",
                      position: (91, 46),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (91, 52),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (91, 44),
                },
                position: (91, 38),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "emptyComposition",
                position: (92, 16),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "composeManyExtensions",
               position: (92, 35),
              },
              arguments: [
               List {
                elements: [],
                position: (92, 57),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "composed",
                position: (93, 16),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "obj",
                position: (93, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 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 {
             attributes: [
              Raw {
               content: "foo",
               position: (94, 24),
              },
             ],
            },
            default: None,
           },
           position: (91, 12),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (95, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (95, 16),
          },
         ),
        ],
        recursive: false,
        position: (90, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testComposeManyExtensions",
          position: (98, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "f",
             position: (99, 9),
            },
           ],
          },
          Function {
           argument: Some(
            "self",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "super",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bar",
                  position: (99, 28),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (99, 34),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "baz",
                  position: (99, 41),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (99, 47),
               },
              ),
             ],
             recursive: false,
             position: (99, 26),
            },
            position: (99, 19),
           },
           position: (99, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "g",
             position: (100, 9),
            },
           ],
          },
          Function {
           argument: Some(
            "self",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "super",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bar",
                  position: (100, 28),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "super",
                 position: (100, 34),
                },
                attribute_path: AttributePath {
                 attributes: [
                  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),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "h",
             position: (101, 9),
            },
           ],
          },
          Function {
           argument: Some(
            "self",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "super",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "qux",
                  position: (101, 28),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "super",
                 position: (101, 34),
                },
                attribute_path: AttributePath {
                 attributes: [
                  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),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "obj",
             position: (102, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "makeExtensible",
            position: (102, 15),
           },
           arguments: [
            Function {
             argument: Some(
              "self",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "foo",
                   position: (102, 39),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "self",
                  position: (102, 45),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "qux",
                    position: (102, 50),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (102, 37),
             },
             position: (102, 31),
            },
           ],
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (104, 5),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "composition",
                 position: (104, 16),
                },
               ],
              },
              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),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "composed",
                 position: (105, 16),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "obj",
                 position: (105, 27),
                },
                attribute_path: AttributePath {
                 attributes: [
                  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 {
              attributes: [
               Raw {
                content: "foo",
                position: (106, 24),
               },
              ],
             },
             default: None,
            },
            position: (104, 12),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (107, 5),
             },
            ],
           },
           PropertyAccess {
            expression: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "obj",
               position: (107, 17),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "extend",
                 position: (107, 21),
                },
               ],
              },
              default: None,
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "composeExtensions",
                position: (107, 29),
               },
               arguments: [
                Variable {
                 identifier: "f",
                 position: (107, 47),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "composeExtensions",
                  position: (107, 50),
                 },
                 arguments: [
                  Variable {
                   identifier: "g",
                   position: (107, 68),
                  },
                  Variable {
                   identifier: "h",
                   position: (107, 70),
                  },
                 ],
                },
               ],
              },
             ],
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "foo",
               position: (107, 75),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         recursive: false,
         position: (103, 8),
        },
        position: (99, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testBitAnd",
          position: (110, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (111, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "bitAnd",
            position: (111, 13),
           },
           arguments: [
            Int {
             value: 3,
             position: (111, 20),
            },
            Int {
             value: 10,
             position: (111, 22),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (112, 5),
            },
           ],
          },
          Int {
           value: 2,
           position: (112, 16),
          },
         ),
        ],
        recursive: false,
        position: (110, 16),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testBitOr",
          position: (115, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (116, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "bitOr",
            position: (116, 13),
           },
           arguments: [
            Int {
             value: 3,
             position: (116, 19),
            },
            Int {
             value: 10,
             position: (116, 21),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (117, 5),
            },
           ],
          },
          Int {
           value: 11,
           position: (117, 16),
          },
         ),
        ],
        recursive: false,
        position: (115, 15),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testBitXor",
          position: (120, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (121, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "bitXor",
            position: (121, 13),
           },
           arguments: [
            Int {
             value: 3,
             position: (121, 20),
            },
            Int {
             value: 10,
             position: (121, 22),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (122, 5),
            },
           ],
          },
          Int {
           value: 9,
           position: (122, 16),
          },
         ),
        ],
        recursive: false,
        position: (120, 16),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToHexString",
          position: (125, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (126, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "toHexString",
            position: (126, 12),
           },
           arguments: [
            Int {
             value: 250,
             position: (126, 24),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (127, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "FA",
            },
           ],
           position: (127, 16),
          },
         ),
        ],
        recursive: false,
        position: (125, 21),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToBaseDigits",
          position: (130, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (131, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "toBaseDigits",
            position: (131, 12),
           },
           arguments: [
            Int {
             value: 2,
             position: (131, 25),
            },
            Int {
             value: 6,
             position: (131, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (132, 5),
            },
           ],
          },
          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),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFunctionArgsFunctor",
          position: (135, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (136, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "functionArgs",
            position: (136, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "__functor",
                  position: (136, 27),
                 },
                ],
               },
               Function {
                argument: Some(
                 "self",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: None,
                 arguments: FunctionArguments {
                  arguments: [
                   FunctionArgument {
                    identifier: "b",
                    default: None,
                   },
                   FunctionArgument {
                    identifier: "a",
                    default: None,
                   },
                  ],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "null",
                  position: (136, 55),
                 },
                 position: (136, 45),
                },
                position: (136, 39),
               },
              ),
             ],
             recursive: false,
             position: (136, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (137, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (137, 18),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (137, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "b",
                position: (137, 29),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (137, 33),
             },
            ),
           ],
           recursive: false,
           position: (137, 16),
          },
         ),
        ],
        recursive: false,
        position: (135, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFunctionArgsSetFunctionArgs",
          position: (140, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (141, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "functionArgs",
            position: (141, 12),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "setFunctionArgs",
              position: (141, 26),
             },
             arguments: [
              Function {
               argument: Some(
                "args",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "args",
                 position: (141, 49),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "x",
                   position: (141, 54),
                  },
                 ],
                },
                default: None,
               },
               position: (141, 43),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "x",
                    position: (141, 59),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (141, 63),
                 },
                ),
               ],
               recursive: false,
               position: (141, 57),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (142, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "x",
                position: (142, 18),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (142, 22),
             },
            ),
           ],
           recursive: false,
           position: (142, 16),
          },
         ),
        ],
        recursive: false,
        position: (140, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testConcatMapStrings",
          position: (147, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (148, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMapStrings",
            position: (148, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "x",
                position: (148, 33),
               },
               String {
                parts: [
                 Raw {
                  content: ";",
                 },
                ],
                position: (148, 37),
               },
              ],
              position: (148, 35),
             },
             position: (148, 30),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (148, 43),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                },
               ],
               position: (148, 47),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                },
               ],
               position: (148, 51),
              },
             ],
             position: (148, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (149, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "a;b;c;",
            },
           ],
           position: (149, 16),
          },
         ),
        ],
        recursive: false,
        position: (147, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testConcatStringsSep",
          position: (152, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (153, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (153, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",",
              },
             ],
             position: (153, 29),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (153, 34),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                },
               ],
               position: (153, 38),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                },
               ],
               position: (153, 42),
              },
             ],
             position: (153, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (154, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "a,b,c",
            },
           ],
           position: (154, 16),
          },
         ),
        ],
        recursive: false,
        position: (152, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsSimple",
          position: (157, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (158, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (158, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (158, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
              },
             ],
             position: (158, 32),
            },
            String {
             parts: [
              Raw {
               content: "a.b.c.d",
              },
             ],
             position: (158, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (159, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
              },
             ],
             position: (159, 18),
            },
            String {
             parts: [
              Raw {
               content: "b",
              },
             ],
             position: (159, 22),
            },
            String {
             parts: [
              Raw {
               content: "c",
              },
             ],
             position: (159, 26),
            },
            String {
             parts: [
              Raw {
               content: "d",
              },
             ],
             position: (159, 30),
            },
           ],
           position: (159, 16),
          },
         ),
        ],
        recursive: false,
        position: (157, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsEmpty",
          position: (162, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (163, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (163, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (163, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
              },
             ],
             position: (163, 32),
            },
            String {
             parts: [
              Raw {
               content: "a..b",
              },
             ],
             position: (163, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (164, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
              },
             ],
             position: (164, 18),
            },
            String {
             parts: [],
             position: (164, 22),
            },
            String {
             parts: [
              Raw {
               content: "b",
              },
             ],
             position: (164, 25),
            },
           ],
           position: (164, 16),
          },
         ),
        ],
        recursive: false,
        position: (162, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsOne",
          position: (167, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (168, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (168, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (168, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ":",
              },
             ],
             position: (168, 32),
            },
            String {
             parts: [
              Raw {
               content: "a.b",
              },
             ],
             position: (168, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (169, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a.b",
              },
             ],
             position: (169, 18),
            },
           ],
           position: (169, 16),
          },
         ),
        ],
        recursive: false,
        position: (167, 25),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsNone",
          position: (172, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (173, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (173, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (173, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ".",
              },
             ],
             position: (173, 32),
            },
            String {
             parts: [],
             position: (173, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (174, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
             position: (174, 18),
            },
           ],
           position: (174, 16),
          },
         ),
        ],
        recursive: false,
        position: (172, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsFirstEmpty",
          position: (177, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (178, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (178, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (178, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "/",
              },
             ],
             position: (178, 32),
            },
            String {
             parts: [
              Raw {
               content: "/a/b/c",
              },
             ],
             position: (178, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (179, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
             position: (179, 18),
            },
            String {
             parts: [
              Raw {
               content: "a",
              },
             ],
             position: (179, 21),
            },
            String {
             parts: [
              Raw {
               content: "b",
              },
             ],
             position: (179, 25),
            },
            String {
             parts: [
              Raw {
               content: "c",
              },
             ],
             position: (179, 29),
            },
           ],
           position: (179, 16),
          },
         ),
        ],
        recursive: false,
        position: (177, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsLastEmpty",
          position: (182, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (183, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (183, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (183, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ":",
              },
             ],
             position: (183, 32),
            },
            String {
             parts: [
              Raw {
               content: "2001:db8:0:0042::8a2e:370:",
              },
             ],
             position: (183, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (184, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "2001",
              },
             ],
             position: (184, 18),
            },
            String {
             parts: [
              Raw {
               content: "db8",
              },
             ],
             position: (184, 25),
            },
            String {
             parts: [
              Raw {
               content: "0",
              },
             ],
             position: (184, 31),
            },
            String {
             parts: [
              Raw {
               content: "0042",
              },
             ],
             position: (184, 35),
            },
            String {
             parts: [],
             position: (184, 42),
            },
            String {
             parts: [
              Raw {
               content: "8a2e",
              },
             ],
             position: (184, 45),
            },
            String {
             parts: [
              Raw {
               content: "370",
              },
             ],
             position: (184, 52),
            },
            String {
             parts: [],
             position: (184, 58),
            },
           ],
           position: (184, 16),
          },
         ),
        ],
        recursive: false,
        position: (182, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsRegex",
          position: (187, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (188, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (188, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitString",
               position: (188, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\\[{}]()^$?*+|.",
              },
             ],
             position: (188, 32),
            },
            String {
             parts: [
              Raw {
               content: "A\\[{}]()^$?*+|.B",
              },
             ],
             position: (188, 50),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (189, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "A",
              },
             ],
             position: (189, 18),
            },
            String {
             parts: [
              Raw {
               content: "B",
              },
             ],
             position: (189, 22),
            },
           ],
           position: (189, 16),
          },
         ),
        ],
        recursive: false,
        position: (187, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitStringsDerivation",
          position: (192, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (193, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "take",
            position: (193, 12),
           },
           arguments: [
            Int {
             value: 3,
             position: (193, 17),
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "strings",
               position: (193, 21),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "splitString",
                 position: (193, 29),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "/",
                },
               ],
               position: (193, 41),
              },
              FunctionApplication {
               function: Variable {
                identifier: "derivation",
                position: (193, 46),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "name",
                      position: (194, 7),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "name",
                     },
                    ],
                    position: (194, 14),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "builder",
                      position: (195, 7),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "builder",
                     },
                    ],
                    position: (195, 17),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (196, 7),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "system",
                     },
                    ],
                    position: (196, 16),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (193, 57),
                },
               ],
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (198, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
             position: (198, 17),
            },
            String {
             parts: [
              Raw {
               content: "nix",
              },
             ],
             position: (198, 20),
            },
            String {
             parts: [
              Raw {
               content: "store",
              },
             ],
             position: (198, 26),
            },
           ],
           position: (198, 16),
          },
         ),
        ],
        recursive: false,
        position: (192, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitVersionSingle",
          position: (201, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (202, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (202, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitVersion",
               position: (202, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1",
              },
             ],
             position: (202, 34),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (203, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
              },
             ],
             position: (203, 18),
            },
           ],
           position: (203, 16),
          },
         ),
        ],
        recursive: false,
        position: (201, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitVersionDouble",
          position: (206, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (207, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (207, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitVersion",
               position: (207, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1.2",
              },
             ],
             position: (207, 34),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (208, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
              },
             ],
             position: (208, 18),
            },
            String {
             parts: [
              Raw {
               content: "2",
              },
             ],
             position: (208, 22),
            },
           ],
           position: (208, 16),
          },
         ),
        ],
        recursive: false,
        position: (206, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSplitVersionTriple",
          position: (211, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (212, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "versions",
             position: (212, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "splitVersion",
               position: (212, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "1.2.3",
              },
             ],
             position: (212, 34),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (213, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
              },
             ],
             position: (213, 18),
            },
            String {
             parts: [
              Raw {
               content: "2",
              },
             ],
             position: (213, 22),
            },
            String {
             parts: [
              Raw {
               content: "3",
              },
             ],
             position: (213, 26),
            },
           ],
           position: (213, 16),
          },
         ),
        ],
        recursive: false,
        position: (211, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testIsStorePath",
          position: (216, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (217, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "goodPath",
                position: (218, 11),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (219, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "storeDir",
                    position: (219, 25),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11",
               },
              ],
              position: (219, 13),
             },
            ),
           ],
           target: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "storePath",
                 position: (221, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (221, 21),
               },
               arguments: [
                Variable {
                 identifier: "goodPath",
                 position: (221, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "storePathDerivation",
                 position: (222, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (222, 31),
               },
               arguments: [
                PropertyAccess {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "import",
                   position: (222, 44),
                  },
                  arguments: [
                   Path {
                    parts: [
                     Raw {
                      content: "../..",
                     },
                    ],
                    position: (222, 51),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "system",
                         position: (222, 59),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "x86_64-linux",
                        },
                       ],
                       position: (222, 68),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (222, 57),
                   },
                  ],
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "hello",
                    position: (222, 87),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "storePathAppendix",
                 position: (223, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (223, 29),
               },
               arguments: [
                String {
                 parts: [
                  Expression {
                   expression: Variable {
                    identifier: "goodPath",
                    position: (224, 14),
                   },
                  },
                  Raw {
                   content: "/bin/python",
                  },
                 ],
                 position: (224, 11),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAbsolute",
                 position: (225, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (225, 23),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "concatStrings",
                  position: (225, 36),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "tail",
                    position: (225, 51),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "stringToCharacters",
                      position: (225, 57),
                     },
                     arguments: [
                      Variable {
                       identifier: "goodPath",
                       position: (225, 76),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "asPath",
                 position: (226, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (226, 18),
               },
               arguments: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  Path {
                   parts: [
                    Raw {
                     content: "/.",
                    },
                   ],
                   position: (226, 31),
                  },
                  Variable {
                   identifier: "goodPath",
                   position: (226, 36),
                  },
                 ],
                 position: (226, 34),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "otherPath",
                 position: (227, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "isStorePath",
                position: (227, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "/something/else",
                  },
                 ],
                 position: (227, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "otherVals",
                 position: (228, 9),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "attrset",
                    position: (229, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "isStorePath",
                   position: (229, 21),
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (229, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "list",
                    position: (230, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "isStorePath",
                   position: (230, 18),
                  },
                  arguments: [
                   List {
                    elements: [],
                    position: (230, 30),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "int",
                    position: (231, 11),
                   },
                  ],
                 },
                 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),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (234, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "storePath",
                position: (235, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (235, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "storePathDerivation",
                position: (236, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (236, 29),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "storePathAppendix",
                position: (237, 7),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (237, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "nonAbsolute",
                position: (238, 7),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (238, 21),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "asPath",
                position: (239, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (239, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "otherPath",
                position: (240, 7),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (240, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "otherVals",
                position: (241, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "attrset",
                   position: (242, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (242, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "list",
                   position: (243, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (243, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (244, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (244, 15),
                },
               ),
              ],
              recursive: false,
              position: (241, 19),
             },
            ),
           ],
           recursive: false,
           position: (234, 16),
          },
         ),
        ],
        recursive: false,
        position: (216, 22),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testEscapeXML",
          position: (249, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (250, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "escapeXML",
            position: (250, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\"test\" 'test' < & >",
              },
             ],
             position: (250, 22),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (251, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "&quot;test&quot; &apos;test&apos; &lt; &amp; &gt;",
            },
           ],
           position: (251, 16),
          },
         ),
        ],
        recursive: false,
        position: (249, 19),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFilter",
          position: (256, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (257, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "filter",
            position: (257, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "x",
                position: (257, 23),
               },
               String {
                parts: [
                 Raw {
                  content: "a",
                 },
                ],
                position: (257, 28),
               },
              ],
              position: (257, 25),
             },
             position: (257, 20),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (257, 34),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                },
               ],
               position: (257, 38),
              },
              String {
               parts: [
                Raw {
                 content: "c",
                },
               ],
               position: (257, 42),
              },
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (257, 46),
              },
             ],
             position: (257, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (258, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "b",
              },
             ],
             position: (258, 17),
            },
            String {
             parts: [
              Raw {
               content: "c",
              },
             ],
             position: (258, 21),
            },
           ],
           position: (258, 16),
          },
         ),
        ],
        recursive: false,
        position: (256, 16),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFold",
          position: (261, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "f",
             position: (263, 7),
            },
           ],
          },
          Function {
           argument: Some(
            "op",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "fold",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "fold",
              position: (263, 21),
             },
             arguments: [
              Variable {
               identifier: "op",
               position: (263, 26),
              },
              Int {
               value: 0,
               position: (263, 29),
              },
              FunctionApplication {
               function: Variable {
                identifier: "range",
                position: (263, 32),
               },
               arguments: [
                Int {
                 value: 0,
                 position: (263, 38),
                },
                Int {
                 value: 100,
                 position: (263, 40),
                },
               ],
              },
             ],
            },
            position: (263, 15),
           },
           position: (263, 11),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assoc",
             position: (265, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (265, 15),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (265, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "add",
                position: (265, 26),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "nonAssoc",
             position: (267, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (267, 18),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (267, 20),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "sub",
                position: (267, 29),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (269, 7),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assocRight",
                 position: (270, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "assoc",
                position: (270, 22),
               },
               arguments: [
                Variable {
                 identifier: "foldr",
                 position: (270, 28),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assocRightIsLeft",
                 position: (272, 9),
                },
               ],
              },
              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),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocRight",
                 position: (273, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "nonAssoc",
                position: (273, 25),
               },
               arguments: [
                Variable {
                 identifier: "foldr",
                 position: (273, 34),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocLeft",
                 position: (274, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "nonAssoc",
                position: (274, 24),
               },
               arguments: [
                Variable {
                 identifier: "foldl",
                 position: (274, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocRightIsNotLeft",
                 position: (276, 9),
                },
               ],
              },
              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),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "foldIsRight",
                 position: (278, 9),
                },
               ],
              },
              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),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (280, 7),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assocRight",
                 position: (281, 9),
                },
               ],
              },
              Int {
               value: 5050,
               position: (281, 22),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assocRightIsLeft",
                 position: (282, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (282, 28),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocRight",
                 position: (283, 9),
                },
               ],
              },
              Int {
               value: 50,
               position: (283, 25),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocLeft",
                 position: (284, 9),
                },
               ],
              },
              UnaryOperation {
               operator: Negate,
               operand: Int {
                value: 5050,
                position: (284, 26),
               },
               position: (284, 25),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nonAssocRightIsNotLeft",
                 position: (285, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (285, 34),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "foldIsRight",
                 position: (286, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (286, 23),
              },
             ),
            ],
            recursive: false,
            position: (280, 18),
           },
          ),
         ],
         recursive: false,
         position: (268, 8),
        },
        position: (262, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testTake",
          position: (290, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testAllTrue",
         position: (290, 14),
        },
        arguments: [
         List {
          elements: [
           BinaryOperation {
            operator: EqualTo,
            operands: [
             List {
              elements: [],
              position: (291, 6),
             },
             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, 9),
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             List {
              elements: [
               Int {
                value: 1,
                position: (292, 7),
               },
              ],
              position: (292, 6),
             },
             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, 10),
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             List {
              elements: [
               Int {
                value: 1,
                position: (293, 8),
               },
               Int {
                value: 2,
                position: (293, 10),
               },
              ],
              position: (293, 6),
             },
             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, 14),
           },
           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),
             },
             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, 16),
           },
           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),
             },
             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, 16),
           },
          ],
          position: (290, 26),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFoldAttrs",
          position: (298, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (299, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "foldAttrs",
            position: (299, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "n",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "a",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              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),
            },
            List {
             elements: [],
             position: (299, 39),
            },
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "a",
                    position: (300, 7),
                   },
                  ],
                 },
                 Int {
                  value: 2,
                  position: (300, 11),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "b",
                    position: (300, 14),
                   },
                  ],
                 },
                 Int {
                  value: 7,
                  position: (300, 18),
                 },
                ),
               ],
               recursive: false,
               position: (300, 5),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "a",
                    position: (301, 7),
                   },
                  ],
                 },
                 Int {
                  value: 3,
                  position: (301, 11),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "c",
                    position: (301, 21),
                   },
                  ],
                 },
                 Int {
                  value: 8,
                  position: (301, 25),
                 },
                ),
               ],
               recursive: false,
               position: (301, 5),
              },
             ],
             position: (299, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (303, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (303, 18),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 2,
                position: (303, 24),
               },
               Int {
                value: 3,
                position: (303, 26),
               },
              ],
              position: (303, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "b",
                position: (303, 31),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 7,
                position: (303, 36),
               },
              ],
              position: (303, 35),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "c",
                position: (303, 40),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 8,
                position: (303, 45),
               },
              ],
              position: (303, 44),
             },
            ),
           ],
           recursive: false,
           position: (303, 16),
          },
         ),
        ],
        recursive: false,
        position: (298, 19),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSort",
          position: (306, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (307, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "sort",
            position: (307, 12),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (307, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               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),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (308, 5),
            },
           ],
          },
          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),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToIntShouldConvertStringToInt",
          position: (311, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (312, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "toInt",
            position: (312, 12),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "27",
              },
             ],
             position: (312, 18),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (313, 5),
            },
           ],
          },
          Int {
           value: 27,
           position: (313, 16),
          },
         ),
        ],
        recursive: false,
        position: (311, 39),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToIntShouldThrowErrorIfItCouldNotConvertToInt",
          position: (316, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (317, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (317, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "tryEval",
               position: (317, 21),
              },
             ],
            },
            default: None,
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "toInt",
              position: (317, 30),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "\"foo\"",
                },
               ],
               position: (317, 36),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (318, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "success",
                position: (318, 18),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (318, 28),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "value",
                position: (318, 35),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (318, 43),
             },
            ),
           ],
           recursive: false,
           position: (318, 16),
          },
         ),
        ],
        recursive: false,
        position: (316, 55),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testHasAttrByPathTrue",
          position: (321, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (322, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "hasAttrByPath",
            position: (322, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (322, 27),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                },
               ],
               position: (322, 31),
              },
             ],
             position: (322, 26),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (322, 38),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "b",
                     position: (322, 44),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "yey",
                    },
                   ],
                   position: (322, 48),
                  },
                 ),
                ],
                recursive: false,
                position: (322, 42),
               },
              ),
             ],
             recursive: false,
             position: (322, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (323, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (323, 16),
          },
         ),
        ],
        recursive: false,
        position: (321, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testHasAttrByPathFalse",
          position: (326, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (327, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "hasAttrByPath",
            position: (327, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                },
               ],
               position: (327, 27),
              },
              String {
               parts: [
                Raw {
                 content: "b",
                },
               ],
               position: (327, 31),
              },
             ],
             position: (327, 26),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (327, 38),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "c",
                     position: (327, 44),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "yey",
                    },
                   ],
                   position: (327, 48),
                  },
                 ),
                ],
                recursive: false,
                position: (327, 42),
               },
              ),
             ],
             recursive: false,
             position: (327, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (328, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (328, 16),
          },
         ),
        ],
        recursive: false,
        position: (326, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testRecursiveUpdateUntil",
          position: (335, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (336, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "recursiveUpdateUntil",
            position: (336, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "path",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "l",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "r",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "path",
                  position: (336, 46),
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "foo",
                     },
                    ],
                    position: (336, 55),
                   },
                  ],
                  position: (336, 54),
                 },
                ],
                position: (336, 51),
               },
               position: (336, 43),
              },
              position: (336, 40),
             },
             position: (336, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (338, 7),
                 },
                 Raw {
                  content: "bar",
                  position: (338, 11),
                 },
                ],
               },
               Int {
                value: 1,
                position: (338, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (339, 7),
                 },
                 Raw {
                  content: "baz",
                  position: (339, 11),
                 },
                ],
               },
               Int {
                value: 2,
                position: (339, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bar",
                  position: (340, 7),
                 },
                ],
               },
               Int {
                value: 3,
                position: (340, 13),
               },
              ),
             ],
             recursive: false,
             position: (336, 63),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (343, 7),
                 },
                 Raw {
                  content: "bar",
                  position: (343, 11),
                 },
                ],
               },
               Int {
                value: 1,
                position: (343, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (344, 7),
                 },
                 Raw {
                  content: "quz",
                  position: (344, 11),
                 },
                ],
               },
               Int {
                value: 2,
                position: (344, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "baz",
                  position: (345, 7),
                 },
                ],
               },
               Int {
                value: 4,
                position: (345, 13),
               },
              ),
             ],
             recursive: false,
             position: (341, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (347, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "foo",
                position: (348, 7),
               },
               Raw {
                content: "bar",
                position: (348, 11),
               },
              ],
             },
             Int {
              value: 1,
              position: (348, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "foo",
                position: (349, 7),
               },
               Raw {
                content: "quz",
                position: (349, 11),
               },
              ],
             },
             Int {
              value: 2,
              position: (349, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bar",
                position: (350, 7),
               },
              ],
             },
             Int {
              value: 3,
              position: (350, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "baz",
                position: (351, 7),
               },
              ],
             },
             Int {
              value: 4,
              position: (351, 13),
             },
            ),
           ],
           recursive: false,
           position: (347, 16),
          },
         ),
        ],
        recursive: false,
        position: (335, 30),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testOverrideExistingEmpty",
          position: (355, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (356, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (356, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (356, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (356, 34),
                 },
                ],
               },
               Int {
                value: 1,
                position: (356, 38),
               },
              ),
             ],
             recursive: false,
             position: (356, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (357, 5),
            },
           ],
          },
          Map {
           bindings: [],
           recursive: false,
           position: (357, 16),
          },
         ),
        ],
        recursive: false,
        position: (355, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testOverrideExistingDisjoint",
          position: (360, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (361, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (361, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (361, 31),
                 },
                ],
               },
               Int {
                value: 2,
                position: (361, 35),
               },
              ),
             ],
             recursive: false,
             position: (361, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (361, 42),
                 },
                ],
               },
               Int {
                value: 1,
                position: (361, 46),
               },
              ),
             ],
             recursive: false,
             position: (361, 40),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (362, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "b",
                position: (362, 18),
               },
              ],
             },
             Int {
              value: 2,
              position: (362, 22),
             },
            ),
           ],
           recursive: false,
           position: (362, 16),
          },
         ),
        ],
        recursive: false,
        position: (360, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testOverrideExistingOverride",
          position: (365, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (366, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "overrideExisting",
            position: (366, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (366, 31),
                 },
                ],
               },
               Int {
                value: 3,
                position: (366, 35),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (366, 38),
                 },
                ],
               },
               Int {
                value: 2,
                position: (366, 42),
               },
              ),
             ],
             recursive: false,
             position: (366, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (366, 49),
                 },
                ],
               },
               Int {
                value: 1,
                position: (366, 53),
               },
              ),
             ],
             recursive: false,
             position: (366, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (367, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (367, 18),
               },
              ],
             },
             Int {
              value: 1,
              position: (367, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "b",
                position: (367, 25),
               },
              ],
             },
             Int {
              value: 2,
              position: (367, 29),
             },
            ),
           ],
           recursive: false,
           position: (367, 16),
          },
         ),
        ],
        recursive: false,
        position: (365, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testMkKeyValueDefault",
          position: (374, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (375, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (375, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkKeyValueDefault",
               position: (375, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (375, 41),
            },
            String {
             parts: [
              Raw {
               content: ":",
              },
             ],
             position: (375, 44),
            },
            String {
             parts: [
              Raw {
               content: "f:oo",
              },
             ],
             position: (375, 48),
            },
            String {
             parts: [
              Raw {
               content: "bar",
              },
             ],
             position: (375, 55),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (376, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "f\\:oo:bar",
            },
           ],
           position: (376, 16),
          },
         ),
        ],
        recursive: false,
        position: (374, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testMkValueString",
          position: (379, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (380, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "vals",
                position: (381, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (382, 9),
                  },
                 ],
                },
                Int {
                 value: 42,
                 position: (382, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "string",
                   position: (383, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "fo\"o",
                  },
                 ],
                 position: (383, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bool",
                   position: (384, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (384, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bool2",
                   position: (385, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (385, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "null",
                   position: (386, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "null",
                 position: (386, 16),
                },
               ),
              ],
              recursive: false,
              position: (381, 14),
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (389, 10),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "const",
               position: (390, 10),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "generators",
                  position: (390, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "mkValueStringDefault",
                    position: (390, 28),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (390, 49),
                 },
                ],
               },
              ],
             },
             Variable {
              identifier: "vals",
              position: (391, 9),
             },
            ],
           },
           position: (380, 12),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (392, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "int",
                position: (393, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "42",
               },
              ],
              position: (393, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "string",
                position: (394, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "fo\"o",
               },
              ],
              position: (394, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bool",
                position: (395, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "true",
               },
              ],
              position: (395, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bool2",
                position: (396, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "false",
               },
              ],
              position: (396, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "null",
                position: (397, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "null",
               },
              ],
              position: (397, 14),
             },
            ),
           ],
           recursive: false,
           position: (392, 16),
          },
         ),
        ],
        recursive: false,
        position: (379, 23),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToKeyValue",
          position: (402, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (403, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (403, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toKeyValue",
               position: (403, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (403, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "key",
                  position: (404, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "value",
                 },
                ],
                position: (404, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: __StringParts(
                   [
                    Raw {
                     content: "other=key",
                    },
                   ],
                  ),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "baz",
                 },
                ],
                position: (405, 21),
               },
              ),
             ],
             recursive: false,
             position: (403, 37),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (407, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "key=value\nother\\=key=baz\n",
            },
           ],
           position: (407, 16),
          },
         ),
        ],
        recursive: false,
        position: (402, 20),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIEmpty",
          position: (413, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (414, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (414, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (414, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (414, 29),
            },
            Map {
             bindings: [],
             recursive: false,
             position: (414, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (415, 5),
            },
           ],
          },
          String {
           parts: [],
           position: (415, 16),
          },
         ),
        ],
        recursive: false,
        position: (413, 20),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIEmptySection",
          position: (418, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (419, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (419, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (419, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (419, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (419, 34),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (419, 40),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bar",
                  position: (419, 44),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (419, 50),
               },
              ),
             ],
             recursive: false,
             position: (419, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (420, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "[bar]\n\n[foo]\n",
            },
           ],
           position: (420, 16),
          },
         ),
        ],
        recursive: false,
        position: (418, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIDuplicateKeys",
          position: (427, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (428, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (428, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (428, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "listsAsDuplicateKeys",
                  position: (428, 31),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (428, 54),
               },
              ),
             ],
             recursive: false,
             position: (428, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "foo",
                  position: (428, 64),
                 },
                 Raw {
                  content: "bar",
                  position: (428, 68),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (428, 74),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "baz",
                  position: (428, 80),
                 },
                 Raw {
                  content: "qux",
                  position: (428, 84),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (428, 92),
                 },
                 Variable {
                  identifier: "false",
                  position: (428, 94),
                 },
                ],
                position: (428, 90),
               },
              ),
             ],
             recursive: false,
             position: (428, 62),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (429, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "[baz]\nqux=1\nqux=false\n\n[foo]\nbar=true\n",
            },
           ],
           position: (429, 16),
          },
         ),
        ],
        recursive: false,
        position: (427, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIDefaultEscapes",
          position: (439, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (440, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (440, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (440, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (440, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: __StringParts(
                   [
                    Raw {
                     content: "no [ and ] allowed unescaped",
                    },
                   ],
                  ),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: __StringParts(
                      [
                       Raw {
                        content: "and also no = in keys",
                       },
                      ],
                     ),
                    },
                   ],
                  },
                  Int {
                   value: 42,
                   position: (442, 35),
                  },
                 ),
                ],
                recursive: false,
                position: (441, 40),
               },
              ),
             ],
             recursive: false,
             position: (440, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (445, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "[no \\[ and \\] allowed unescaped]\nand also no \\= in keys=42\n",
            },
           ],
           position: (445, 16),
          },
         ),
        ],
        recursive: false,
        position: (439, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIDefaultFull",
          position: (451, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (452, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (452, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (452, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (452, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: __StringParts(
                   [
                    Raw {
                     content: "section 1",
                    },
                   ],
                  ),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "attribute1",
                     position: (454, 9),
                    },
                   ],
                  },
                  Int {
                   value: 5,
                   position: (454, 22),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "x",
                     position: (455, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Me-se JarJar Binx",
                    },
                   ],
                   position: (455, 13),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "boolean",
                     position: (457, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (457, 19),
                  },
                 ),
                ],
                recursive: false,
                position: (453, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: __StringParts(
                   [
                    Raw {
                     content: "foo[]",
                    },
                   ],
                  ),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: __StringParts(
                      [
                       Raw {
                        content: "he\\h=he",
                       },
                      ],
                     ),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "this is okay",
                    },
                   ],
                   position: (460, 22),
                  },
                 ),
                ],
                recursive: false,
                position: (459, 17),
               },
              ),
             ],
             recursive: false,
             position: (452, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (463, 5),
            },
           ],
          },
          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: (463, 16),
          },
         ),
        ],
        recursive: false,
        position: (451, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIWithGlobalSectionEmpty",
          position: (474, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (475, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (475, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINIWithGlobalSection",
               position: (475, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (475, 46),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "globalSection",
                  position: (476, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (476, 23),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "sections",
                  position: (478, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (478, 18),
               },
              ),
             ],
             recursive: false,
             position: (475, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (481, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "",
            },
           ],
           position: (481, 16),
          },
         ),
        ],
        recursive: false,
        position: (474, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIWithGlobalSectionGlobalEmptyIsTheSameAsToINI",
          position: (485, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sections",
             position: (487, 7),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "section 1",
                  },
                 ],
                ),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "attribute1",
                   position: (489, 11),
                  },
                 ],
                },
                Int {
                 value: 5,
                 position: (489, 24),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "x",
                   position: (490, 11),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Me-se JarJar Binx",
                  },
                 ],
                 position: (490, 15),
                },
               ),
              ],
              recursive: false,
              position: (488, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "foo",
                  },
                 ],
                ),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: __StringParts(
                    [
                     Raw {
                      content: "he\\h=he",
                     },
                    ],
                   ),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "this is okay",
                  },
                 ],
                 position: (493, 24),
                },
               ),
              ],
              recursive: false,
              position: (492, 17),
             },
            ),
           ],
           recursive: false,
           position: (487, 18),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (497, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (498, 9),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toINIWithGlobalSection",
                position: (498, 20),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (498, 43),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "globalSection",
                   position: (499, 13),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (499, 29),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "sections",
                   position: (500, 13),
                  },
                 ],
                },
                Variable {
                 identifier: "sections",
                 position: (500, 24),
                },
               ),
              ],
              recursive: false,
              position: (498, 46),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (502, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (502, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toINI",
                position: (502, 29),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (502, 35),
             },
             Variable {
              identifier: "sections",
              position: (502, 38),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (496, 8),
        },
        position: (486, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToINIWithGlobalSectionFull",
          position: (505, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (506, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (506, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINIWithGlobalSection",
               position: (506, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (506, 46),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "globalSection",
                  position: (507, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "foo",
                     position: (508, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "bar",
                    },
                   ],
                   position: (508, 15),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "test",
                     position: (509, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (509, 16),
                  },
                 ),
                ],
                recursive: false,
                position: (507, 23),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "sections",
                  position: (511, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: __StringParts(
                      [
                       Raw {
                        content: "section 1",
                       },
                      ],
                     ),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "attribute1",
                        position: (513, 11),
                       },
                      ],
                     },
                     Int {
                      value: 5,
                      position: (513, 24),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "x",
                        position: (514, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "Me-se JarJar Binx",
                       },
                      ],
                      position: (514, 15),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (512, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: __StringParts(
                      [
                       Raw {
                        content: "foo",
                       },
                      ],
                     ),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Expression {
                        expression: __StringParts(
                         [
                          Raw {
                           content: "he\\h=he",
                          },
                         ],
                        ),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "this is okay",
                       },
                      ],
                      position: (517, 24),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (516, 17),
                  },
                 ),
                ],
                recursive: false,
                position: (511, 18),
               },
              ),
             ],
             recursive: false,
             position: (506, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (521, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "foo=bar\ntest=false\n\n[foo]\nhe\\h\\=he=this is okay\n\n[section 1]\nattribute1=5\nx=Me-se JarJar Binx\n",
            },
           ],
           position: (521, 16),
          },
         ),
        ],
        recursive: false,
        position: (505, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToJSONSimple",
          position: (535, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "val",
             position: (536, 9),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "foobar",
                position: (537, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "baz",
                 },
                ],
                position: (537, 18),
               },
               Int {
                value: 1,
                position: (537, 24),
               },
               Int {
                value: 2,
                position: (537, 26),
               },
               Int {
                value: 3,
                position: (537, 28),
               },
              ],
              position: (537, 16),
             },
            ),
           ],
           recursive: false,
           position: (536, 15),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (540, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (540, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (540, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (540, 32),
             },
             Variable {
              identifier: "val",
              position: (540, 35),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (542, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (542, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (542, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (542, 34),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (539, 8),
        },
        position: (536, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToYAMLSimple",
          position: (546, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "val",
             position: (547, 9),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "list",
                position: (548, 7),
               },
              ],
             },
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "one",
                     position: (548, 18),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (548, 24),
                  },
                 ),
                ],
                recursive: false,
                position: (548, 16),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "two",
                     position: (548, 31),
                    },
                   ],
                  },
                  Int {
                   value: 2,
                   position: (548, 37),
                  },
                 ),
                ],
                recursive: false,
                position: (548, 29),
               },
              ],
              position: (548, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "all",
                position: (549, 7),
               },
              ],
             },
             Int {
              value: 42,
              position: (549, 13),
             },
            ),
           ],
           recursive: false,
           position: (547, 15),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (552, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (552, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toYAML",
                position: (552, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (552, 32),
             },
             Variable {
              identifier: "val",
              position: (552, 35),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (554, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (554, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (554, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (554, 34),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (551, 8),
        },
        position: (547, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPretty",
          position: (557, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "deriv",
             position: (559, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "derivation",
            position: (559, 15),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (559, 28),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "test",
                 },
                ],
                position: (559, 35),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "builder",
                  position: (559, 43),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/bin/sh",
                 },
                ],
                position: (559, 53),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "system",
                  position: (559, 64),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "aarch64-linux",
                 },
                ],
                position: (559, 73),
               },
              ),
             ],
             recursive: false,
             position: (559, 26),
            },
           ],
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (561, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (561, 12),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "const",
               position: (561, 22),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "generators",
                  position: (561, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toPretty",
                    position: (561, 40),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "multiline",
                       position: (561, 51),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (561, 63),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (561, 49),
                 },
                ],
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (562, 7),
                  },
                 ],
                },
                Int {
                 value: 42,
                 position: (562, 13),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "float",
                   position: (563, 7),
                  },
                 ],
                },
                Float {
                 value: 0.1337,
                 position: (563, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bool",
                   position: (564, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (564, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptystring",
                   position: (565, 7),
                  },
                 ],
                },
                String {
                 parts: [],
                 position: (565, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "string",
                   position: (566, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "fno\"rd",
                  },
                 ],
                 position: (566, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "newlinestring",
                   position: (567, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "\n",
                  },
                 ],
                 position: (567, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (568, 7),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  Path {
                   parts: [
                    Raw {
                     content: "/.",
                    },
                   ],
                   position: (568, 14),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/foo",
                    },
                   ],
                   position: (568, 19),
                  },
                 ],
                 position: (568, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "null_",
                   position: (569, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "null",
                 position: (569, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "function",
                   position: (570, 7),
                  },
                 ],
                },
                Function {
                 argument: Some(
                  "x",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "x",
                  position: (570, 21),
                 },
                 position: (570, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "functionArgs",
                   position: (571, 7),
                  },
                 ],
                },
                Function {
                 argument: None,
                 arguments: FunctionArguments {
                  arguments: [
                   FunctionArgument {
                    identifier: "foo",
                    default: None,
                   },
                   FunctionArgument {
                    identifier: "arg",
                    default: Some(
                     Int {
                      value: 4,
                      position: (571, 30),
                     },
                    ),
                   },
                  ],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "arg",
                  position: (571, 40),
                 },
                 position: (571, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "list",
                   position: (572, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Int {
                   value: 3,
                   position: (572, 16),
                  },
                  Int {
                   value: 4,
                   position: (572, 18),
                  },
                  Variable {
                   identifier: "function",
                   position: (572, 20),
                  },
                  List {
                   elements: [
                    Variable {
                     identifier: "false",
                     position: (572, 31),
                    },
                   ],
                   position: (572, 29),
                  },
                 ],
                 position: (572, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptylist",
                   position: (573, 7),
                  },
                 ],
                },
                List {
                 elements: [],
                 position: (573, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "attrs",
                   position: (574, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "foo",
                      position: (574, 17),
                     },
                    ],
                   },
                   Variable {
                    identifier: "null",
                    position: (574, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Expression {
                      expression: __StringParts(
                       [
                        Raw {
                         content: "foo bar",
                        },
                       ],
                      ),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "baz",
                     },
                    ],
                    position: (574, 41),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (574, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptyattrs",
                   position: (575, 7),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (575, 20),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "drv",
                   position: (576, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "deriv",
                 position: (576, 13),
                },
               ),
              ],
              recursive: true,
              position: (561, 74),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (578, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (579, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "42",
                },
               ],
               position: (579, 13),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "float",
                 position: (580, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "~0.133700",
                },
               ],
               position: (580, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (581, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "true",
                },
               ],
               position: (581, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptystring",
                 position: (582, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\"",
                },
               ],
               position: (582, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "string",
                 position: (583, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"fno\\\"rd\"",
                },
               ],
               position: (583, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "newlinestring",
                 position: (584, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\\n\"",
                },
               ],
               position: (584, 23),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (585, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/foo",
                },
               ],
               position: (585, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "null_",
                 position: (586, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "null",
                },
               ],
               position: (586, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "function",
                 position: (587, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function>",
                },
               ],
               position: (587, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "functionArgs",
                 position: (588, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function, args: {arg?, foo}>",
                },
               ],
               position: (588, 22),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "list",
                 position: (589, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ 3 4 ",
                },
                Expression {
                 expression: Variable {
                  identifier: "function",
                  position: (589, 23),
                 },
                },
                Raw {
                 content: " [ false ] ]",
                },
               ],
               position: (589, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptylist",
                 position: (590, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ ]",
                },
               ],
               position: (590, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "attrs",
                 position: (591, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ foo = null; \"foo bar\" = \"baz\"; }",
                },
               ],
               position: (591, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptyattrs",
                 position: (592, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ }",
                },
               ],
               position: (592, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "drv",
                 position: (593, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<derivation ",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "deriv",
                   position: (593, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "drvPath",
                     position: (593, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: ">",
                },
               ],
               position: (593, 13),
              },
             ),
            ],
            recursive: true,
            position: (578, 16),
           },
          ),
         ],
         recursive: false,
         position: (560, 8),
        },
        position: (558, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyLimit",
          position: (597, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (599, 7),
            },
            Raw {
             content: "b",
             position: (599, 9),
            },
           ],
          },
          Int {
           value: 1,
           position: (599, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (600, 7),
            },
            Raw {
             content: "c",
             position: (600, 9),
            },
           ],
          },
          Variable {
           identifier: "a",
           position: (600, 13),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (602, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (602, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toPretty",
                position: (602, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (602, 34),
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "generators",
                position: (602, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "withRecursion",
                  position: (602, 50),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "throwOnDepthLimit",
                     position: (602, 66),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (602, 86),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "depthLimit",
                     position: (602, 93),
                    },
                   ],
                  },
                  Int {
                   value: 2,
                   position: (602, 106),
                  },
                 ),
                ],
                recursive: false,
                position: (602, 64),
               },
               Variable {
                identifier: "a",
                position: (602, 111),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (603, 7),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "{\n  b = 1;\n  c = {\n    b = \"<unevaluated>\";\n    c = {\n      b = \"<unevaluated>\";\n      c = \"<unevaluated>\";\n    };\n  };\n}",
             },
            ],
            position: (603, 18),
           },
          ),
         ],
         recursive: false,
         position: (601, 8),
        },
        position: (598, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyLimitThrow",
          position: (606, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (608, 7),
            },
            Raw {
             content: "b",
             position: (608, 9),
            },
           ],
          },
          Int {
           value: 1,
           position: (608, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (609, 7),
            },
            Raw {
             content: "c",
             position: (609, 9),
            },
           ],
          },
          Variable {
           identifier: "a",
           position: (609, 13),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (611, 7),
             },
            ],
           },
           PropertyAccess {
            expression: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (611, 15),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "tryEval",
                 position: (611, 24),
                },
               ],
              },
              default: None,
             },
             arguments: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "generators",
                 position: (612, 10),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toPretty",
                   position: (612, 21),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [],
                 recursive: false,
                 position: (612, 30),
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "generators",
                   position: (612, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "withRecursion",
                     position: (612, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "depthLimit",
                        position: (612, 62),
                       },
                      ],
                     },
                     Int {
                      value: 2,
                      position: (612, 75),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (612, 60),
                  },
                  Variable {
                   identifier: "a",
                   position: (612, 80),
                  },
                 ],
                },
               ],
              },
             ],
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "success",
               position: (612, 85),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (613, 7),
             },
            ],
           },
           Variable {
            identifier: "false",
            position: (613, 18),
           },
          ),
         ],
         recursive: false,
         position: (610, 8),
        },
        position: (607, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyMultiline",
          position: (616, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (617, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (617, 12),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "const",
              position: (617, 22),
             },
             arguments: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "generators",
                 position: (617, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toPretty",
                   position: (617, 40),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [],
                 recursive: false,
                 position: (617, 49),
                },
               ],
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "list",
                  position: (618, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 3,
                  position: (618, 16),
                 },
                 Int {
                  value: 4,
                  position: (618, 18),
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "false",
                    position: (618, 22),
                   },
                  ],
                  position: (618, 20),
                 },
                ],
                position: (618, 14),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "attrs",
                  position: (619, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "foo",
                     position: (619, 17),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (619, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bar",
                     position: (619, 29),
                    },
                    Raw {
                     content: "foo",
                     position: (619, 33),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "baz",
                    },
                   ],
                   position: (619, 39),
                  },
                 ),
                ],
                recursive: false,
                position: (619, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "newlinestring",
                  position: (620, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "\n",
                 },
                ],
                position: (620, 23),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring",
                  position: (621, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "hello\nthere\ntest\n",
                 },
                ],
                position: (621, 25),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring'",
                  position: (626, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "        hello\nthere\ntest",
                 },
                ],
                position: (626, 26),
               },
              ),
             ],
             recursive: true,
             position: (617, 55),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (631, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "list",
                position: (632, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        [\n  3\n  4\n  [\n    false\n  ]\n]",
               },
              ],
              position: (632, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "attrs",
                position: (640, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        {\n  bar = {\n    foo = \"baz\";\n  };\n  foo = null;\n}",
               },
              ],
              position: (640, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "newlinestring",
                position: (647, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "''\n  \n''",
               },
              ],
              position: (647, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring",
                position: (648, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
               },
               Raw {
                content: "''",
               },
               Raw {
                content: "\n  hello\n  there\n  test\n",
               },
               Raw {
                content: "''",
               },
              ],
              position: (648, 25),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring'",
                position: (654, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
               },
               Raw {
                content: "''",
               },
               Raw {
                content: "\n  hello\n  there\n  test",
               },
               Raw {
                content: "''",
               },
              ],
              position: (654, 26),
             },
            ),
           ],
           recursive: true,
           position: (631, 16),
          },
         ),
        ],
        recursive: false,
        position: (616, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyAllowPrettyValues",
          position: (663, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (664, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (664, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toPretty",
               position: (664, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "allowPrettyValues",
                  position: (664, 34),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (664, 54),
               },
              ),
             ],
             recursive: false,
             position: (664, 32),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "__pretty",
                  position: (665, 16),
                 },
                ],
               },
               Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    String {
                     parts: [
                      Raw {
                       content: "«",
                      },
                     ],
                     position: (665, 30),
                    },
                    Variable {
                     identifier: "v",
                     position: (665, 36),
                    },
                   ],
                   position: (665, 34),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "»",
                    },
                   ],
                   position: (665, 40),
                  },
                 ],
                 position: (665, 38),
                },
                position: (665, 27),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "val",
                  position: (665, 45),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "foo",
                 },
                ],
                position: (665, 51),
               },
              ),
             ],
             recursive: false,
             position: (665, 14),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (666, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "«foo»",
            },
           ],
           position: (666, 17),
          },
         ),
        ],
        recursive: false,
        position: (663, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToGNUCommandLine",
          position: (672, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (673, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (673, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toGNUCommandLine",
               position: (673, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (673, 33),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "data",
                  position: (674, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (674, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (674, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "id",
                       position: (674, 32),
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (674, 37),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (674, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "X",
                  position: (675, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "PUT",
                 },
                ],
                position: (675, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry",
                  position: (676, 7),
                 },
                ],
               },
               Int {
                value: 3,
                position: (676, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry-delay",
                  position: (677, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (677, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "url",
                  position: (678, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                   },
                  ],
                  position: (678, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                   },
                  ],
                  position: (678, 41),
                 },
                ],
                position: (678, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "silent",
                  position: (679, 7),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (679, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "verbose",
                  position: (680, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (680, 17),
               },
              ),
             ],
             recursive: false,
             position: (673, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (683, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "-X",
              },
             ],
             position: (684, 7),
            },
            String {
             parts: [
              Raw {
               content: "PUT",
              },
             ],
             position: (684, 12),
            },
            String {
             parts: [
              Raw {
               content: "--data",
              },
             ],
             position: (685, 7),
            },
            String {
             parts: [
              Raw {
               content: "{\"id\":0}",
              },
             ],
             position: (685, 16),
            },
            String {
             parts: [
              Raw {
               content: "--retry",
              },
             ],
             position: (686, 7),
            },
            String {
             parts: [
              Raw {
               content: "3",
              },
             ],
             position: (686, 17),
            },
            String {
             parts: [
              Raw {
               content: "--url",
              },
             ],
             position: (687, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/foo",
              },
             ],
             position: (687, 15),
            },
            String {
             parts: [
              Raw {
               content: "--url",
              },
             ],
             position: (688, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/bar",
              },
             ],
             position: (688, 15),
            },
            String {
             parts: [
              Raw {
               content: "--verbose",
              },
             ],
             position: (689, 7),
            },
           ],
           position: (683, 16),
          },
         ),
        ],
        recursive: false,
        position: (672, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToGNUCommandLineShell",
          position: (693, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (694, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (694, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toGNUCommandLineShell",
               position: (694, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (694, 38),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "data",
                  position: (695, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (695, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (695, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "id",
                       position: (695, 32),
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (695, 37),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (695, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "X",
                  position: (696, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "PUT",
                 },
                ],
                position: (696, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry",
                  position: (697, 7),
                 },
                ],
               },
               Int {
                value: 3,
                position: (697, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry-delay",
                  position: (698, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (698, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "url",
                  position: (699, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                   },
                  ],
                  position: (699, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                   },
                  ],
                  position: (699, 41),
                 },
                ],
                position: (699, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "silent",
                  position: (700, 7),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (700, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "verbose",
                  position: (701, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (701, 17),
               },
              ),
             ],
             recursive: false,
             position: (694, 41),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (704, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "'-X' 'PUT' '--data' '{\"id\":0}' '--retry' '3' '--url' 'https://example.com/foo' '--url' 'https://example.com/bar' '--verbose'",
            },
           ],
           position: (704, 16),
          },
         ),
        ],
        recursive: false,
        position: (693, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameLeadingDots",
          position: (707, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (707, 43),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (708, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "..foo",
              },
             ],
             position: (708, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (709, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (709, 16),
            },
           ),
          ],
          recursive: false,
          position: (707, 70),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameUnicode",
          position: (712, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (712, 39),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (713, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "fö",
              },
             ],
             position: (713, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (714, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "f-",
              },
             ],
             position: (714, 16),
            },
           ),
          ],
          recursive: false,
          position: (712, 66),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameAscii",
          position: (717, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (717, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (718, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
              },
             ],
             position: (718, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (719, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "-+--.-0123456789-=-?-ABCDEFGHIJKLMNOPQRSTUVWXYZ-_-abcdefghijklmnopqrstuvwxyz-",
              },
             ],
             position: (719, 16),
            },
           ),
          ],
          recursive: false,
          position: (717, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLong",
          position: (722, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (722, 39),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (723, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "This string is loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
              },
             ],
             position: (723, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (724, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
              },
             ],
             position: (724, 16),
            },
           ),
          ],
          recursive: false,
          position: (722, 66),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLongWithInvalid",
          position: (727, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (727, 50),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (728, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "Hello there aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&&&&&&&",
              },
             ],
             position: (728, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (729, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "there-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-",
              },
             ],
             position: (729, 16),
            },
           ),
          ],
          recursive: false,
          position: (727, 77),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameEmpty",
          position: (732, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (732, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (733, 5),
              },
             ],
            },
            String {
             parts: [],
             position: (733, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (734, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "unknown",
              },
             ],
             position: (734, 16),
            },
           ),
          ],
          recursive: false,
          position: (732, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFreeformOptions",
          position: (737, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (738, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "submodule",
                position: (740, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "freeformType",
                    position: (741, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (741, 26),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "types",
                      position: (741, 30),
                     },
                     Raw {
                      content: "attrsOf",
                      position: (741, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (741, 45),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "types",
                        position: (741, 49),
                       },
                       Raw {
                        content: "submodule",
                        position: (741, 55),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (742, 13),
                          },
                          Raw {
                           content: "bar",
                           position: (742, 21),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (742, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (742, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (742, 40),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (741, 65),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (744, 11),
                   },
                   Raw {
                    content: "bar",
                    position: (744, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (744, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (744, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (744, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (740, 35),
              },
              position: (740, 21),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "module",
                position: (747, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (748, 11),
                   },
                   Raw {
                    content: "foo",
                    position: (748, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (748, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (748, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (749, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (749, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "types",
                           position: (749, 24),
                          },
                          Raw {
                           content: "submodule",
                           position: (749, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "submodule",
                         position: (749, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (748, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (747, 32),
              },
              position: (747, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (753, 9),
               },
              ],
             },
             PropertyAccess {
              expression: FunctionApplication {
               function: Variable {
                identifier: "evalModules",
                position: (753, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "modules",
                      position: (754, 11),
                     },
                    ],
                   },
                   List {
                    elements: [
                     Variable {
                      identifier: "module",
                      position: (754, 23),
                     },
                    ],
                    position: (754, 21),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (753, 32),
                },
               ],
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (755, 12),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "locs",
                position: (757, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (757, 16),
              },
              arguments: [
               Function {
                argument: Some(
                 "o",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: UnaryOperation {
                 operator: Not,
                 operand: PropertyAccess {
                  expression: Variable {
                   identifier: "o",
                   position: (757, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "internal",
                     position: (757, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (757, 27),
                },
                position: (757, 24),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionAttrSetToDocList",
                 position: (757, 42),
                },
                arguments: [
                 Variable {
                  identifier: "options",
                  position: (757, 65),
                 },
                ],
               },
              ],
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (758, 10),
            },
            arguments: [
             Function {
              argument: Some(
               "o",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: PropertyAccess {
               expression: Variable {
                identifier: "o",
                position: (758, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "loc",
                  position: (758, 20),
                 },
                ],
               },
               default: None,
              },
              position: (758, 15),
             },
             Variable {
              identifier: "locs",
              position: (758, 25),
             },
            ],
           },
           position: (739, 7),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (759, 5),
            },
           ],
          },
          List {
           elements: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "_module",
                },
               ],
               position: (759, 20),
              },
              String {
               parts: [
                Raw {
                 content: "args",
                },
               ],
               position: (759, 30),
              },
             ],
             position: (759, 18),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (759, 41),
              },
             ],
             position: (759, 39),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (759, 51),
              },
              String {
               parts: [
                Raw {
                 content: "<name>",
                },
               ],
               position: (759, 57),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (759, 66),
              },
             ],
             position: (759, 49),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (759, 76),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (759, 82),
              },
             ],
             position: (759, 74),
            },
           ],
           position: (759, 16),
          },
         ),
        ],
        recursive: false,
        position: (737, 25),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfEmptySet",
          position: (762, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (763, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (763, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (763, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (764, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [],
             recursive: false,
             position: (764, 18),
            },
           ],
           position: (764, 16),
          },
         ),
        ],
        recursive: false,
        position: (762, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfOneSet",
          position: (767, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (768, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (768, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (768, 37),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (768, 43),
                 },
                 Int {
                  value: 2,
                  position: (768, 45),
                 },
                 Int {
                  value: 3,
                  position: (768, 47),
                 },
                ],
                position: (768, 41),
               },
              ),
             ],
             recursive: false,
             position: (768, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (769, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (769, 20),
                 },
                ],
               },
               Int {
                value: 1,
                position: (769, 24),
               },
              ),
             ],
             recursive: false,
             position: (769, 18),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (769, 31),
                 },
                ],
               },
               Int {
                value: 2,
                position: (769, 35),
               },
              ),
             ],
             recursive: false,
             position: (769, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (769, 42),
                 },
                ],
               },
               Int {
                value: 3,
                position: (769, 46),
               },
              ),
             ],
             recursive: false,
             position: (769, 40),
            },
           ],
           position: (769, 16),
          },
         ),
        ],
        recursive: false,
        position: (767, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSets",
          position: (772, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (773, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (773, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (773, 37),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (773, 43),
                 },
                ],
                position: (773, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (773, 48),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (773, 54),
                 },
                 Int {
                  value: 20,
                  position: (773, 57),
                 },
                ],
                position: (773, 52),
               },
              ),
             ],
             recursive: false,
             position: (773, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (774, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (775, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (775, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (775, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (775, 20),
               },
              ),
             ],
             recursive: false,
             position: (775, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (776, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (776, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (776, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (776, 20),
               },
              ),
             ],
             recursive: false,
             position: (776, 7),
            },
           ],
           position: (774, 16),
          },
         ),
        ],
        recursive: false,
        position: (772, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSetsWithOneEmpty",
          position: (780, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (781, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (781, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (781, 37),
                 },
                ],
               },
               List {
                elements: [],
                position: (781, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (781, 46),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (781, 52),
                 },
                 Int {
                  value: 20,
                  position: (781, 55),
                 },
                ],
                position: (781, 50),
               },
              ),
             ],
             recursive: false,
             position: (781, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (782, 5),
            },
           ],
          },
          List {
           elements: [],
           position: (782, 16),
          },
         ),
        ],
        recursive: false,
        position: (780, 47),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfThreeSets",
          position: (785, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (786, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (786, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (787, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (787, 15),
                 },
                 Int {
                  value: 2,
                  position: (787, 19),
                 },
                 Int {
                  value: 3,
                  position: (787, 23),
                 },
                ],
                position: (787, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (788, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (788, 14),
                 },
                 Int {
                  value: 20,
                  position: (788, 18),
                 },
                 Int {
                  value: 30,
                  position: (788, 22),
                 },
                ],
                position: (788, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (789, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 100,
                  position: (789, 13),
                 },
                 Int {
                  value: 200,
                  position: (789, 17),
                 },
                 Int {
                  value: 300,
                  position: (789, 21),
                 },
                ],
                position: (789, 11),
               },
              ),
             ],
             recursive: false,
             position: (786, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (791, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (792, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (792, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (792, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (792, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (792, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (792, 28),
               },
              ),
             ],
             recursive: false,
             position: (792, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (793, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (793, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (793, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (793, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (793, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (793, 28),
               },
              ),
             ],
             recursive: false,
             position: (793, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (794, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (794, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (794, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (794, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (794, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (794, 28),
               },
              ),
             ],
             recursive: false,
             position: (794, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (796, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (796, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (796, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (796, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (796, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (796, 28),
               },
              ),
             ],
             recursive: false,
             position: (796, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (797, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (797, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (797, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (797, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (797, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (797, 28),
               },
              ),
             ],
             recursive: false,
             position: (797, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (798, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (798, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (798, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (798, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (798, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (798, 28),
               },
              ),
             ],
             recursive: false,
             position: (798, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (800, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (800, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (800, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (800, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (800, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (800, 28),
               },
              ),
             ],
             recursive: false,
             position: (800, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (801, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (801, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (801, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (801, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (801, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (801, 28),
               },
              ),
             ],
             recursive: false,
             position: (801, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (802, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (802, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (802, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (802, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (802, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (802, 28),
               },
              ),
             ],
             recursive: false,
             position: (802, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (804, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (804, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (804, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (804, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (804, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (804, 28),
               },
              ),
             ],
             recursive: false,
             position: (804, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (805, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (805, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (805, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (805, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (805, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (805, 28),
               },
              ),
             ],
             recursive: false,
             position: (805, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (806, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (806, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (806, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (806, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (806, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (806, 28),
               },
              ),
             ],
             recursive: false,
             position: (806, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (808, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (808, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (808, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (808, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (808, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (808, 28),
               },
              ),
             ],
             recursive: false,
             position: (808, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (809, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (809, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (809, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (809, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (809, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (809, 28),
               },
              ),
             ],
             recursive: false,
             position: (809, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (810, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (810, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (810, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (810, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (810, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (810, 28),
               },
              ),
             ],
             recursive: false,
             position: (810, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (812, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (812, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (812, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (812, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (812, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (812, 28),
               },
              ),
             ],
             recursive: false,
             position: (812, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (813, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (813, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (813, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (813, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (813, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (813, 28),
               },
              ),
             ],
             recursive: false,
             position: (813, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (814, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (814, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (814, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (814, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (814, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (814, 28),
               },
              ),
             ],
             recursive: false,
             position: (814, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (816, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (816, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (816, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (816, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (816, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (816, 28),
               },
              ),
             ],
             recursive: false,
             position: (816, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (817, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (817, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (817, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (817, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (817, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (817, 28),
               },
              ),
             ],
             recursive: false,
             position: (817, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (818, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (818, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (818, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (818, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (818, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (818, 28),
               },
              ),
             ],
             recursive: false,
             position: (818, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (820, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (820, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (820, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (820, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (820, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (820, 28),
               },
              ),
             ],
             recursive: false,
             position: (820, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (821, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (821, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (821, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (821, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (821, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (821, 28),
               },
              ),
             ],
             recursive: false,
             position: (821, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (822, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (822, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (822, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (822, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (822, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (822, 28),
               },
              ),
             ],
             recursive: false,
             position: (822, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (824, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (824, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (824, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (824, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (824, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (824, 28),
               },
              ),
             ],
             recursive: false,
             position: (824, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (825, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (825, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (825, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (825, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (825, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (825, 28),
               },
              ),
             ],
             recursive: false,
             position: (825, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (826, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (826, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (826, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (826, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (826, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (826, 28),
               },
              ),
             ],
             recursive: false,
             position: (826, 7),
            },
           ],
           position: (791, 16),
          },
         ),
        ],
        recursive: false,
        position: (785, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathExample",
          position: (831, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (832, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (832, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (832, 27),
              },
              String {
               parts: [
                Raw {
                 content: "10",
                },
               ],
               position: (832, 33),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (832, 38),
              },
             ],
             position: (832, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (833, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "foo.\"10\".bar",
            },
           ],
           position: (833, 16),
          },
         ),
        ],
        recursive: false,
        position: (831, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathEmpty",
          position: (836, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (837, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (837, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (837, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (838, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "<root attribute path>",
            },
           ],
           position: (838, 16),
          },
         ),
        ],
        recursive: false,
        position: (836, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathVarious",
          position: (841, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (842, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (842, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: ".",
                },
               ],
               position: (843, 7),
              },
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (844, 7),
              },
              String {
               parts: [
                Raw {
                 content: "2",
                },
               ],
               position: (845, 7),
              },
              String {
               parts: [
                Raw {
                 content: "a2-b",
                },
               ],
               position: (846, 7),
              },
              String {
               parts: [
                Raw {
                 content: "_bc'de",
                },
               ],
               position: (847, 7),
              },
             ],
             position: (842, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (849, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "\".\".foo.\"2\".a2-b._bc'de",
            },
           ],
           position: (849, 16),
          },
         ),
        ],
        recursive: false,
        position: (841, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testGroupBy",
          position: (852, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (853, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "groupBy",
            position: (853, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "n",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (853, 24),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mod",
                 position: (853, 34),
                },
                arguments: [
                 Variable {
                  identifier: "n",
                  position: (853, 38),
                 },
                 Int {
                  value: 5,
                  position: (853, 40),
                 },
                ],
               },
              ],
             },
             position: (853, 21),
            },
            FunctionApplication {
             function: Variable {
              identifier: "range",
              position: (853, 45),
             },
             arguments: [
              Int {
               value: 0,
               position: (853, 51),
              },
              Int {
               value: 16,
               position: (853, 53),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (854, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "0",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 0,
                position: (855, 15),
               },
               Int {
                value: 5,
                position: (855, 17),
               },
               Int {
                value: 10,
                position: (855, 19),
               },
               Int {
                value: 15,
                position: (855, 22),
               },
              ],
              position: (855, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "1",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 1,
                position: (856, 15),
               },
               Int {
                value: 6,
                position: (856, 17),
               },
               Int {
                value: 11,
                position: (856, 19),
               },
               Int {
                value: 16,
                position: (856, 22),
               },
              ],
              position: (856, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "2",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 2,
                position: (857, 15),
               },
               Int {
                value: 7,
                position: (857, 17),
               },
               Int {
                value: 12,
                position: (857, 19),
               },
              ],
              position: (857, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "3",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 3,
                position: (858, 15),
               },
               Int {
                value: 8,
                position: (858, 17),
               },
               Int {
                value: 13,
                position: (858, 19),
               },
              ],
              position: (858, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "4",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 4,
                position: (859, 15),
               },
               Int {
                value: 9,
                position: (859, 17),
               },
               Int {
                value: 14,
                position: (859, 19),
               },
              ],
              position: (859, 13),
             },
            ),
           ],
           recursive: false,
           position: (854, 16),
          },
         ),
        ],
        recursive: false,
        position: (852, 17),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testGroupBy'",
          position: (863, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (864, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "groupBy'",
            position: (864, 12),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (864, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "add",
                position: (864, 30),
               },
              ],
             },
             default: None,
            },
            Int {
             value: 0,
             position: (864, 34),
            },
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "boolToString",
               position: (864, 40),
              },
              arguments: [
               BinaryOperation {
                operator: GreaterThan,
                operands: [
                 Variable {
                  identifier: "x",
                  position: (864, 54),
                 },
                 Int {
                  value: 2,
                  position: (864, 58),
                 },
                ],
                position: (864, 56),
               },
              ],
             },
             position: (864, 37),
            },
            List {
             elements: [
              Int {
               value: 5,
               position: (864, 64),
              },
              Int {
               value: 1,
               position: (864, 66),
              },
              Int {
               value: 2,
               position: (864, 68),
              },
              Int {
               value: 3,
               position: (864, 70),
              },
              Int {
               value: 4,
               position: (864, 72),
              },
             ],
             position: (864, 62),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (865, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "false",
                position: (865, 18),
               },
              ],
             },
             Int {
              value: 3,
              position: (865, 26),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "true",
                position: (865, 29),
               },
              ],
             },
             Int {
              value: 12,
              position: (865, 36),
             },
            ),
           ],
           recursive: false,
           position: (865, 16),
          },
         ),
        ],
        recursive: false,
        position: (863, 18),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathExample",
          position: (869, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (870, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (870, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (872, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (872, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (872, 22),
                   },
                  ],
                  position: (872, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (873, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "d",
                        position: (873, 25),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "old",
                       position: (873, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "c",
                         position: (873, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (873, 23),
                  },
                  position: (873, 18),
                 },
                ),
               ],
               recursive: false,
               position: (871, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (876, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (876, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (876, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                     },
                    ],
                    position: (876, 26),
                   },
                  ],
                  position: (876, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (877, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (877, 23),
                    },
                    Int {
                     value: 1,
                     position: (877, 29),
                    },
                   ],
                   position: (877, 27),
                  },
                  position: (877, 18),
                 },
                ),
               ],
               recursive: false,
               position: (875, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (880, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "x",
                     },
                    ],
                    position: (880, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "y",
                     },
                    ],
                    position: (880, 22),
                   },
                  ],
                  position: (880, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (881, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "xy",
                    },
                   ],
                   position: (881, 23),
                  },
                  position: (881, 18),
                 },
                ),
               ],
               recursive: false,
               position: (879, 7),
              },
             ],
             position: (870, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (883, 9),
                 },
                 Raw {
                  content: "b",
                  position: (883, 11),
                 },
                 Raw {
                  content: "c",
                  position: (883, 13),
                 },
                ],
               },
               Int {
                value: 0,
                position: (883, 17),
               },
              ),
             ],
             recursive: false,
             position: (883, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (884, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (884, 18),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "b",
                   position: (884, 24),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "d",
                      position: (884, 30),
                     },
                    ],
                   },
                   Int {
                    value: 1,
                    position: (884, 34),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (884, 28),
                },
               ),
              ],
              recursive: false,
              position: (884, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "x",
                position: (884, 43),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "y",
                   position: (884, 49),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "xy",
                  },
                 ],
                 position: (884, 53),
                },
               ),
              ],
              recursive: false,
              position: (884, 47),
             },
            ),
           ],
           recursive: false,
           position: (884, 16),
          },
         ),
        ],
        recursive: false,
        position: (869, 38),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathNone",
          position: (888, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (889, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (889, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (889, 34),
            },
            String {
             parts: [
              Raw {
               content: "something",
              },
             ],
             position: (889, 37),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (890, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "something",
            },
           ],
           position: (890, 16),
          },
         ),
        ],
        recursive: false,
        position: (888, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathSingleIncrement",
          position: (894, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (895, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (895, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (897, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (897, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (898, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (898, 23),
                    },
                    Int {
                     value: 1,
                     position: (898, 29),
                    },
                   ],
                   position: (898, 27),
                  },
                  position: (898, 18),
                 },
                ),
               ],
               recursive: false,
               position: (896, 7),
              },
             ],
             position: (895, 34),
            },
            Int {
             value: 0,
             position: (900, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (901, 5),
            },
           ],
          },
          Int {
           value: 1,
           position: (901, 16),
          },
         ),
        ],
        recursive: false,
        position: (894, 46),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathMultipleIncrements",
          position: (905, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (906, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (906, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (908, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (908, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (909, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (909, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "a",
                      },
                     ],
                     position: (909, 29),
                    },
                   ],
                   position: (909, 27),
                  },
                  position: (909, 18),
                 },
                ),
               ],
               recursive: false,
               position: (907, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (912, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (912, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (913, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (913, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "b",
                      },
                     ],
                     position: (913, 29),
                    },
                   ],
                   position: (913, 27),
                  },
                  position: (913, 18),
                 },
                ),
               ],
               recursive: false,
               position: (911, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (916, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (916, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (917, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (917, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "c",
                      },
                     ],
                     position: (917, 29),
                    },
                   ],
                   position: (917, 27),
                  },
                  position: (917, 18),
                 },
                ),
               ],
               recursive: false,
               position: (915, 7),
              },
             ],
             position: (906, 34),
            },
            String {
             parts: [],
             position: (919, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (920, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "abc",
            },
           ],
           position: (920, 16),
          },
         ),
        ],
        recursive: false,
        position: (905, 49),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathLazy",
          position: (924, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (925, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (925, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (927, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (927, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (928, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (928, 23),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "throw",
                      position: (928, 29),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "nope",
                        },
                       ],
                       position: (928, 35),
                      },
                     ],
                    },
                   ],
                   position: (928, 27),
                  },
                  position: (928, 18),
                 },
                ),
               ],
               recursive: false,
               position: (926, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (931, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (931, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (932, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "untainted",
                    },
                   ],
                   position: (932, 23),
                  },
                  position: (932, 18),
                 },
                ),
               ],
               recursive: false,
               position: (930, 7),
              },
             ],
             position: (925, 34),
            },
            FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (934, 8),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "start",
                },
               ],
               position: (934, 14),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (935, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "untainted",
            },
           ],
           position: (935, 16),
          },
         ),
        ],
        recursive: false,
        position: (924, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathDeep",
          position: (939, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (940, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (940, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (942, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (942, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (942, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                     },
                    ],
                    position: (942, 26),
                   },
                  ],
                  position: (942, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (943, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (943, 23),
                    },
                    Int {
                     value: 1,
                     position: (943, 29),
                    },
                   ],
                   position: (943, 27),
                  },
                  position: (943, 18),
                 },
                ),
               ],
               recursive: false,
               position: (941, 7),
              },
             ],
             position: (940, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (946, 7),
                 },
                 Raw {
                  content: "b",
                  position: (946, 9),
                 },
                 Raw {
                  content: "c",
                  position: (946, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (946, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (948, 7),
                 },
                 Raw {
                  content: "b",
                  position: (948, 9),
                 },
                 Raw {
                  content: "z",
                  position: (948, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (948, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (949, 7),
                 },
                 Raw {
                  content: "y",
                  position: (949, 9),
                 },
                 Raw {
                  content: "z",
                  position: (949, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (949, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "x",
                  position: (950, 7),
                 },
                 Raw {
                  content: "y",
                  position: (950, 9),
                 },
                 Raw {
                  content: "z",
                  position: (950, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (950, 15),
               },
              ),
             ],
             recursive: false,
             position: (945, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (952, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (953, 7),
               },
               Raw {
                content: "b",
                position: (953, 9),
               },
               Raw {
                content: "c",
                position: (953, 11),
               },
              ],
             },
             Int {
              value: 1,
              position: (953, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (955, 7),
               },
               Raw {
                content: "b",
                position: (955, 9),
               },
               Raw {
                content: "z",
                position: (955, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (955, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (956, 7),
               },
               Raw {
                content: "y",
                position: (956, 9),
               },
               Raw {
                content: "z",
                position: (956, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (956, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "x",
                position: (957, 7),
               },
               Raw {
                content: "y",
                position: (957, 9),
               },
               Raw {
                content: "z",
                position: (957, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (957, 15),
             },
            ),
           ],
           recursive: false,
           position: (952, 16),
          },
         ),
        ],
        recursive: false,
        position: (939, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathNestedBeforehand",
          position: (962, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (963, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (963, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (965, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (965, 18),
                   },
                  ],
                  position: (965, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (966, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (966, 23),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "x",
                          position: (966, 32),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "old",
                         position: (966, 36),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "b",
                           position: (966, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (966, 30),
                    },
                   ],
                   position: (966, 27),
                  },
                  position: (966, 18),
                 },
                ),
               ],
               recursive: false,
               position: (964, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (969, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (969, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (969, 22),
                   },
                  ],
                  position: (969, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (970, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (970, 23),
                    },
                    Int {
                     value: 1,
                     position: (970, 29),
                    },
                   ],
                   position: (970, 27),
                  },
                  position: (970, 18),
                 },
                ),
               ],
               recursive: false,
               position: (968, 7),
              },
             ],
             position: (963, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (973, 7),
                 },
                 Raw {
                  content: "b",
                  position: (973, 9),
                 },
                ],
               },
               Int {
                value: 0,
                position: (973, 13),
               },
              ),
             ],
             recursive: false,
             position: (972, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (975, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (976, 7),
               },
               Raw {
                content: "b",
                position: (976, 9),
               },
              ],
             },
             Int {
              value: 1,
              position: (976, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (977, 7),
               },
               Raw {
                content: "x",
                position: (977, 9),
               },
              ],
             },
             Int {
              value: 1,
              position: (977, 13),
             },
            ),
           ],
           recursive: false,
           position: (975, 16),
          },
         ),
        ],
        recursive: false,
        position: (962, 47),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthEmpty",
          position: (982, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (983, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (983, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (983, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (983, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (983, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (984, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (984, 16),
          },
         ),
        ],
        recursive: false,
        position: (982, 33),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthSame",
          position: (987, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (988, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (988, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (988, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (988, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (988, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (989, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (989, 16),
          },
         ),
        ],
        recursive: false,
        position: (987, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthDiffering",
          position: (992, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (993, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (993, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (993, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (993, 39),
            },
            String {
             parts: [
              Raw {
               content: "hey",
              },
             ],
             position: (993, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (994, 5),
            },
           ],
          },
          Int {
           value: 2,
           position: (994, 16),
          },
         ),
        ],
        recursive: false,
        position: (992, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthEmpty",
          position: (997, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (998, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (998, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (998, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (998, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (998, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (999, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (999, 16),
          },
         ),
        ],
        recursive: false,
        position: (997, 33),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthSame",
          position: (1002, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1003, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1003, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (1003, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1003, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1003, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1004, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (1004, 16),
          },
         ),
        ],
        recursive: false,
        position: (1002, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthDiffering",
          position: (1007, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1008, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1008, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (1008, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "test",
              },
             ],
             position: (1008, 39),
            },
            String {
             parts: [
              Raw {
               content: "rest",
              },
             ],
             position: (1008, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1009, 5),
            },
           ],
          },
          Int {
           value: 3,
           position: (1009, 16),
          },
         ),
        ],
        recursive: false,
        position: (1007, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinEmpty",
          position: (1012, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1013, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1013, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (1013, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (1013, 32),
            },
            String {
             parts: [],
             position: (1013, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1014, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (1014, 16),
          },
         ),
        ],
        recursive: false,
        position: (1012, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyAdd",
          position: (1017, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1018, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1018, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (1018, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (1018, 32),
            },
            String {
             parts: [
              Raw {
               content: "hello there",
              },
             ],
             position: (1018, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1019, 5),
            },
           ],
          },
          Int {
           value: 11,
           position: (1019, 16),
          },
         ),
        ],
        recursive: false,
        position: (1017, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyRemove",
          position: (1022, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1023, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1023, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (1023, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello there",
              },
             ],
             position: (1023, 32),
            },
            String {
             parts: [],
             position: (1023, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1024, 5),
            },
           ],
          },
          Int {
           value: 11,
           position: (1024, 16),
          },
         ),
        ],
        recursive: false,
        position: (1022, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyTransform",
          position: (1027, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1028, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1028, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (1028, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1028, 32),
            },
            String {
             parts: [
              Raw {
               content: "ghijkl",
              },
             ],
             position: (1028, 41),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1029, 5),
            },
           ],
          },
          Int {
           value: 6,
           position: (1029, 16),
          },
         ),
        ],
        recursive: false,
        position: (1027, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinMixed",
          position: (1032, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1033, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1033, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (1033, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "kitchen",
              },
             ],
             position: (1033, 32),
            },
            String {
             parts: [
              Raw {
               content: "sitting",
              },
             ],
             position: (1033, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1034, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (1034, 16),
          },
         ),
        ],
        recursive: false,
        position: (1032, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostZeroFalse",
          position: (1037, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1038, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1038, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1038, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (1038, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (1038, 40),
            },
            String {
             parts: [
              Raw {
               content: "boo",
              },
             ],
             position: (1038, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1039, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1039, 16),
          },
         ),
        ],
        recursive: false,
        position: (1037, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostZeroTrue",
          position: (1042, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1043, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1043, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1043, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (1043, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (1043, 40),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (1043, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1044, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1044, 16),
          },
         ),
        ],
        recursive: false,
        position: (1042, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostOneFalse",
          position: (1047, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1048, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1048, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1048, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (1048, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
              },
             ],
             position: (1048, 40),
            },
            String {
             parts: [
              Raw {
               content: "ct",
              },
             ],
             position: (1048, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1049, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1049, 16),
          },
         ),
        ],
        recursive: false,
        position: (1047, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostOneTrue",
          position: (1052, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1053, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1053, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1053, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (1053, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
              },
             ],
             position: (1053, 40),
            },
            String {
             parts: [
              Raw {
               content: "cr",
              },
             ],
             position: (1053, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1054, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1054, 16),
          },
         ),
        ],
        recursive: false,
        position: (1052, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsEmpty",
          position: (1059, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1060, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1060, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1060, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1060, 38),
            },
            String {
             parts: [],
             position: (1060, 40),
            },
            String {
             parts: [],
             position: (1060, 43),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1061, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1061, 16),
          },
         ),
        ],
        recursive: false,
        position: (1059, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsZero",
          position: (1064, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1065, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1065, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1065, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1065, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1065, 40),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1065, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1066, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1066, 16),
          },
         ),
        ],
        recursive: false,
        position: (1064, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsOne",
          position: (1069, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1070, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1070, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1070, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1070, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1070, 40),
            },
            String {
             parts: [
              Raw {
               content: "abddef",
              },
             ],
             position: (1070, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1071, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1071, 16),
          },
         ),
        ],
        recursive: false,
        position: (1069, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0False",
          position: (1074, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1075, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1075, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1075, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1075, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1075, 40),
            },
            String {
             parts: [
              Raw {
               content: "aczyef",
              },
             ],
             position: (1075, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1076, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1076, 16),
          },
         ),
        ],
        recursive: false,
        position: (1074, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0Outer",
          position: (1079, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1080, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1080, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1080, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1080, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1080, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcdez",
              },
             ],
             position: (1080, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1081, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1081, 16),
          },
         ),
        ],
        recursive: false,
        position: (1079, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelLeft",
          position: (1084, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1085, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1085, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1085, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1085, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1085, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdefz",
              },
             ],
             position: (1085, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1086, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1086, 16),
          },
         ),
        ],
        recursive: false,
        position: (1084, 42),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelRight",
          position: (1089, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1090, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1090, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1090, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1090, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1090, 40),
            },
            String {
             parts: [
              Raw {
               content: "zabcde",
              },
             ],
             position: (1090, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1091, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1091, 16),
          },
         ),
        ],
        recursive: false,
        position: (1089, 43),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1False",
          position: (1094, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1095, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1095, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1095, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1095, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1095, 40),
            },
            String {
             parts: [
              Raw {
               content: "bddez",
              },
             ],
             position: (1095, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1096, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1096, 16),
          },
         ),
        ],
        recursive: false,
        position: (1094, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelLeft",
          position: (1099, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1100, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1100, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1100, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1100, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1100, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdez",
              },
             ],
             position: (1100, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1101, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1101, 16),
          },
         ),
        ],
        recursive: false,
        position: (1099, 42),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelRight",
          position: (1104, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1105, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1105, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1105, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1105, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1105, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcde",
              },
             ],
             position: (1105, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1106, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1106, 16),
          },
         ),
        ],
        recursive: false,
        position: (1104, 43),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2False",
          position: (1109, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1110, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1110, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1110, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1110, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1110, 40),
            },
            String {
             parts: [
              Raw {
               content: "hxo",
              },
             ],
             position: (1110, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1111, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1111, 16),
          },
         ),
        ],
        recursive: false,
        position: (1109, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2True",
          position: (1114, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1115, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1115, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1115, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1115, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1115, 40),
            },
            String {
             parts: [
              Raw {
               content: "heo",
              },
             ],
             position: (1115, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1116, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1116, 16),
          },
         ),
        ],
        recursive: false,
        position: (1114, 39),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff3",
          position: (1119, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1120, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1120, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1120, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1120, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1120, 40),
            },
            String {
             parts: [
              Raw {
               content: "ho",
              },
             ],
             position: (1120, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1121, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1121, 16),
          },
         ),
        ],
        recursive: false,
        position: (1119, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostThreeFalse",
          position: (1124, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1125, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1125, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1125, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 3,
             position: (1125, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1125, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla!",
              },
             ],
             position: (1125, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1126, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1126, 16),
          },
         ),
        ],
        recursive: false,
        position: (1124, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostThreeTrue",
          position: (1129, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1130, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1130, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1130, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 3,
             position: (1130, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1130, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla",
              },
             ],
             position: (1130, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1131, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1131, 16),
          },
         ),
        ],
        recursive: false,
        position: (1129, 36),
       },
      ),
     ],
     recursive: false,
     position: (23, 10),
    },
   ],
  },
  position: (6, 1),
 },
 position: (4, 1),
}