---
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: "testToJSONSimple",
          position: (475, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "val",
             position: (476, 9),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "foobar",
                position: (477, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "baz",
                 },
                ],
                position: (477, 18),
               },
               Int {
                value: 1,
                position: (477, 24),
               },
               Int {
                value: 2,
                position: (477, 26),
               },
               Int {
                value: 3,
                position: (477, 28),
               },
              ],
              position: (477, 16),
             },
            ),
           ],
           recursive: false,
           position: (476, 15),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (480, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (480, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (480, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (480, 32),
             },
             Variable {
              identifier: "val",
              position: (480, 35),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (482, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (482, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (482, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (482, 34),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (479, 8),
        },
        position: (476, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToYAMLSimple",
          position: (486, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "val",
             position: (487, 9),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "list",
                position: (488, 7),
               },
              ],
             },
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "one",
                     position: (488, 18),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (488, 24),
                  },
                 ),
                ],
                recursive: false,
                position: (488, 16),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "two",
                     position: (488, 31),
                    },
                   ],
                  },
                  Int {
                   value: 2,
                   position: (488, 37),
                  },
                 ),
                ],
                recursive: false,
                position: (488, 29),
               },
              ],
              position: (488, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "all",
                position: (489, 7),
               },
              ],
             },
             Int {
              value: 42,
              position: (489, 13),
             },
            ),
           ],
           recursive: false,
           position: (487, 15),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (492, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (492, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toYAML",
                position: (492, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (492, 32),
             },
             Variable {
              identifier: "val",
              position: (492, 35),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (494, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (494, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (494, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "val",
              position: (494, 34),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (491, 8),
        },
        position: (487, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPretty",
          position: (497, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "deriv",
             position: (499, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "derivation",
            position: (499, 15),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (499, 28),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "test",
                 },
                ],
                position: (499, 35),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "builder",
                  position: (499, 43),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/bin/sh",
                 },
                ],
                position: (499, 53),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "system",
                  position: (499, 64),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "aarch64-linux",
                 },
                ],
                position: (499, 73),
               },
              ),
             ],
             recursive: false,
             position: (499, 26),
            },
           ],
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (501, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (501, 12),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "const",
               position: (501, 22),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "generators",
                  position: (501, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toPretty",
                    position: (501, 40),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "multiline",
                       position: (501, 51),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (501, 63),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (501, 49),
                 },
                ],
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (502, 7),
                  },
                 ],
                },
                Int {
                 value: 42,
                 position: (502, 13),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "float",
                   position: (503, 7),
                  },
                 ],
                },
                Float {
                 value: 0.1337,
                 position: (503, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bool",
                   position: (504, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (504, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptystring",
                   position: (505, 7),
                  },
                 ],
                },
                String {
                 parts: [],
                 position: (505, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "string",
                   position: (506, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "fno\"rd",
                  },
                 ],
                 position: (506, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "newlinestring",
                   position: (507, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "\n",
                  },
                 ],
                 position: (507, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (508, 7),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  Path {
                   parts: [
                    Raw {
                     content: "/.",
                    },
                   ],
                   position: (508, 14),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/foo",
                    },
                   ],
                   position: (508, 19),
                  },
                 ],
                 position: (508, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "null_",
                   position: (509, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "null",
                 position: (509, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "function",
                   position: (510, 7),
                  },
                 ],
                },
                Function {
                 argument: Some(
                  "x",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "x",
                  position: (510, 21),
                 },
                 position: (510, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "functionArgs",
                   position: (511, 7),
                  },
                 ],
                },
                Function {
                 argument: None,
                 arguments: FunctionArguments {
                  arguments: [
                   FunctionArgument {
                    identifier: "foo",
                    default: None,
                   },
                   FunctionArgument {
                    identifier: "arg",
                    default: Some(
                     Int {
                      value: 4,
                      position: (511, 30),
                     },
                    ),
                   },
                  ],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "arg",
                  position: (511, 40),
                 },
                 position: (511, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "list",
                   position: (512, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Int {
                   value: 3,
                   position: (512, 16),
                  },
                  Int {
                   value: 4,
                   position: (512, 18),
                  },
                  Variable {
                   identifier: "function",
                   position: (512, 20),
                  },
                  List {
                   elements: [
                    Variable {
                     identifier: "false",
                     position: (512, 31),
                    },
                   ],
                   position: (512, 29),
                  },
                 ],
                 position: (512, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptylist",
                   position: (513, 7),
                  },
                 ],
                },
                List {
                 elements: [],
                 position: (513, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "attrs",
                   position: (514, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "foo",
                      position: (514, 17),
                     },
                    ],
                   },
                   Variable {
                    identifier: "null",
                    position: (514, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Expression {
                      expression: __StringParts(
                       [
                        Raw {
                         content: "foo bar",
                        },
                       ],
                      ),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "baz",
                     },
                    ],
                    position: (514, 41),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (514, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "emptyattrs",
                   position: (515, 7),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (515, 20),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "drv",
                   position: (516, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "deriv",
                 position: (516, 13),
                },
               ),
              ],
              recursive: true,
              position: (501, 74),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (518, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (519, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "42",
                },
               ],
               position: (519, 13),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "float",
                 position: (520, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "~0.133700",
                },
               ],
               position: (520, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (521, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "true",
                },
               ],
               position: (521, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptystring",
                 position: (522, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\"",
                },
               ],
               position: (522, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "string",
                 position: (523, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"fno\\\"rd\"",
                },
               ],
               position: (523, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "newlinestring",
                 position: (524, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\\n\"",
                },
               ],
               position: (524, 23),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (525, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/foo",
                },
               ],
               position: (525, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "null_",
                 position: (526, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "null",
                },
               ],
               position: (526, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "function",
                 position: (527, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function>",
                },
               ],
               position: (527, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "functionArgs",
                 position: (528, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function, args: {arg?, foo}>",
                },
               ],
               position: (528, 22),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "list",
                 position: (529, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ 3 4 ",
                },
                Expression {
                 expression: Variable {
                  identifier: "function",
                  position: (529, 23),
                 },
                },
                Raw {
                 content: " [ false ] ]",
                },
               ],
               position: (529, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptylist",
                 position: (530, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ ]",
                },
               ],
               position: (530, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "attrs",
                 position: (531, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ foo = null; \"foo bar\" = \"baz\"; }",
                },
               ],
               position: (531, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptyattrs",
                 position: (532, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ }",
                },
               ],
               position: (532, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "drv",
                 position: (533, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<derivation ",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "deriv",
                   position: (533, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "drvPath",
                     position: (533, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: ">",
                },
               ],
               position: (533, 13),
              },
             ),
            ],
            recursive: true,
            position: (518, 16),
           },
          ),
         ],
         recursive: false,
         position: (500, 8),
        },
        position: (498, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyLimit",
          position: (537, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (539, 7),
            },
            Raw {
             content: "b",
             position: (539, 9),
            },
           ],
          },
          Int {
           value: 1,
           position: (539, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (540, 7),
            },
            Raw {
             content: "c",
             position: (540, 9),
            },
           ],
          },
          Variable {
           identifier: "a",
           position: (540, 13),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (542, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (542, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toPretty",
                position: (542, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (542, 34),
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "generators",
                position: (542, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "withRecursion",
                  position: (542, 50),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "throwOnDepthLimit",
                     position: (542, 66),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (542, 86),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "depthLimit",
                     position: (542, 93),
                    },
                   ],
                  },
                  Int {
                   value: 2,
                   position: (542, 106),
                  },
                 ),
                ],
                recursive: false,
                position: (542, 64),
               },
               Variable {
                identifier: "a",
                position: (542, 111),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (543, 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: (543, 18),
           },
          ),
         ],
         recursive: false,
         position: (541, 8),
        },
        position: (538, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyLimitThrow",
          position: (546, 3),
         },
        ],
       },
       LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (548, 7),
            },
            Raw {
             content: "b",
             position: (548, 9),
            },
           ],
          },
          Int {
           value: 1,
           position: (548, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "a",
             position: (549, 7),
            },
            Raw {
             content: "c",
             position: (549, 9),
            },
           ],
          },
          Variable {
           identifier: "a",
           position: (549, 13),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expr",
              position: (551, 7),
             },
            ],
           },
           PropertyAccess {
            expression: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (551, 15),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "tryEval",
                 position: (551, 24),
                },
               ],
              },
              default: None,
             },
             arguments: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "generators",
                 position: (552, 10),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toPretty",
                   position: (552, 21),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [],
                 recursive: false,
                 position: (552, 30),
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "generators",
                   position: (552, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "withRecursion",
                     position: (552, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "depthLimit",
                        position: (552, 62),
                       },
                      ],
                     },
                     Int {
                      value: 2,
                      position: (552, 75),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (552, 60),
                  },
                  Variable {
                   identifier: "a",
                   position: (552, 80),
                  },
                 ],
                },
               ],
              },
             ],
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "success",
               position: (552, 85),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "expected",
              position: (553, 7),
             },
            ],
           },
           Variable {
            identifier: "false",
            position: (553, 18),
           },
          ),
         ],
         recursive: false,
         position: (550, 8),
        },
        position: (547, 5),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyMultiline",
          position: (556, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (557, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (557, 12),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "const",
              position: (557, 22),
             },
             arguments: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "generators",
                 position: (557, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toPretty",
                   position: (557, 40),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [],
                 recursive: false,
                 position: (557, 49),
                },
               ],
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "list",
                  position: (558, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 3,
                  position: (558, 16),
                 },
                 Int {
                  value: 4,
                  position: (558, 18),
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "false",
                    position: (558, 22),
                   },
                  ],
                  position: (558, 20),
                 },
                ],
                position: (558, 14),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "attrs",
                  position: (559, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "foo",
                     position: (559, 17),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (559, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bar",
                     position: (559, 29),
                    },
                    Raw {
                     content: "foo",
                     position: (559, 33),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "baz",
                    },
                   ],
                   position: (559, 39),
                  },
                 ),
                ],
                recursive: false,
                position: (559, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "newlinestring",
                  position: (560, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "\n",
                 },
                ],
                position: (560, 23),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring",
                  position: (561, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "hello\nthere\ntest\n",
                 },
                ],
                position: (561, 25),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring'",
                  position: (566, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "        hello\nthere\ntest",
                 },
                ],
                position: (566, 26),
               },
              ),
             ],
             recursive: true,
             position: (557, 55),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (571, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "list",
                position: (572, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        [\n  3\n  4\n  [\n    false\n  ]\n]",
               },
              ],
              position: (572, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "attrs",
                position: (580, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        {\n  bar = {\n    foo = \"baz\";\n  };\n  foo = null;\n}",
               },
              ],
              position: (580, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "newlinestring",
                position: (587, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "''\n  \n''",
               },
              ],
              position: (587, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring",
                position: (588, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
               },
               Raw {
                content: "''",
               },
               Raw {
                content: "\n  hello\n  there\n  test\n",
               },
               Raw {
                content: "''",
               },
              ],
              position: (588, 25),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring'",
                position: (594, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
               },
               Raw {
                content: "''",
               },
               Raw {
                content: "\n  hello\n  there\n  test",
               },
               Raw {
                content: "''",
               },
              ],
              position: (594, 26),
             },
            ),
           ],
           recursive: true,
           position: (571, 16),
          },
         ),
        ],
        recursive: false,
        position: (556, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToPrettyAllowPrettyValues",
          position: (603, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (604, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (604, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toPretty",
               position: (604, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "allowPrettyValues",
                  position: (604, 34),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (604, 54),
               },
              ),
             ],
             recursive: false,
             position: (604, 32),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "__pretty",
                  position: (605, 16),
                 },
                ],
               },
               Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    String {
                     parts: [
                      Raw {
                       content: "«",
                      },
                     ],
                     position: (605, 30),
                    },
                    Variable {
                     identifier: "v",
                     position: (605, 36),
                    },
                   ],
                   position: (605, 34),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "»",
                    },
                   ],
                   position: (605, 40),
                  },
                 ],
                 position: (605, 38),
                },
                position: (605, 27),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "val",
                  position: (605, 45),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "foo",
                 },
                ],
                position: (605, 51),
               },
              ),
             ],
             recursive: false,
             position: (605, 14),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (606, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "«foo»",
            },
           ],
           position: (606, 17),
          },
         ),
        ],
        recursive: false,
        position: (603, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToGNUCommandLine",
          position: (612, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (613, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (613, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toGNUCommandLine",
               position: (613, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (613, 33),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "data",
                  position: (614, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (614, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (614, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "id",
                       position: (614, 32),
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (614, 37),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (614, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "X",
                  position: (615, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "PUT",
                 },
                ],
                position: (615, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry",
                  position: (616, 7),
                 },
                ],
               },
               Int {
                value: 3,
                position: (616, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry-delay",
                  position: (617, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (617, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "url",
                  position: (618, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                   },
                  ],
                  position: (618, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                   },
                  ],
                  position: (618, 41),
                 },
                ],
                position: (618, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "silent",
                  position: (619, 7),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (619, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "verbose",
                  position: (620, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (620, 17),
               },
              ),
             ],
             recursive: false,
             position: (613, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (623, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "-X",
              },
             ],
             position: (624, 7),
            },
            String {
             parts: [
              Raw {
               content: "PUT",
              },
             ],
             position: (624, 12),
            },
            String {
             parts: [
              Raw {
               content: "--data",
              },
             ],
             position: (625, 7),
            },
            String {
             parts: [
              Raw {
               content: "{\"id\":0}",
              },
             ],
             position: (625, 16),
            },
            String {
             parts: [
              Raw {
               content: "--retry",
              },
             ],
             position: (626, 7),
            },
            String {
             parts: [
              Raw {
               content: "3",
              },
             ],
             position: (626, 17),
            },
            String {
             parts: [
              Raw {
               content: "--url",
              },
             ],
             position: (627, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/foo",
              },
             ],
             position: (627, 15),
            },
            String {
             parts: [
              Raw {
               content: "--url",
              },
             ],
             position: (628, 7),
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/bar",
              },
             ],
             position: (628, 15),
            },
            String {
             parts: [
              Raw {
               content: "--verbose",
              },
             ],
             position: (629, 7),
            },
           ],
           position: (623, 16),
          },
         ),
        ],
        recursive: false,
        position: (612, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testToGNUCommandLineShell",
          position: (633, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (634, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "cli",
             position: (634, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toGNUCommandLineShell",
               position: (634, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (634, 38),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "data",
                  position: (635, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (635, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (635, 23),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "id",
                       position: (635, 32),
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (635, 37),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (635, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "X",
                  position: (636, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "PUT",
                 },
                ],
                position: (636, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry",
                  position: (637, 7),
                 },
                ],
               },
               Int {
                value: 3,
                position: (637, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "retry-delay",
                  position: (638, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (638, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "url",
                  position: (639, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/foo",
                   },
                  ],
                  position: (639, 15),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                   },
                  ],
                  position: (639, 41),
                 },
                ],
                position: (639, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "silent",
                  position: (640, 7),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (640, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "verbose",
                  position: (641, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (641, 17),
               },
              ),
             ],
             recursive: false,
             position: (634, 41),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (644, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "'-X' 'PUT' '--data' '{\"id\":0}' '--retry' '3' '--url' 'https://example.com/foo' '--url' 'https://example.com/bar' '--verbose'",
            },
           ],
           position: (644, 16),
          },
         ),
        ],
        recursive: false,
        position: (633, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameLeadingDots",
          position: (647, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (647, 43),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (648, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "..foo",
              },
             ],
             position: (648, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (649, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (649, 16),
            },
           ),
          ],
          recursive: false,
          position: (647, 70),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameUnicode",
          position: (652, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (652, 39),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (653, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "fö",
              },
             ],
             position: (653, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (654, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "f-",
              },
             ],
             position: (654, 16),
            },
           ),
          ],
          recursive: false,
          position: (652, 66),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameAscii",
          position: (657, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (657, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (658, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
              },
             ],
             position: (658, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (659, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "-+--.-0123456789-=-?-ABCDEFGHIJKLMNOPQRSTUVWXYZ-_-abcdefghijklmnopqrstuvwxyz-",
              },
             ],
             position: (659, 16),
            },
           ),
          ],
          recursive: false,
          position: (657, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLong",
          position: (662, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (662, 39),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (663, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "This string is loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
              },
             ],
             position: (663, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (664, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
              },
             ],
             position: (664, 16),
            },
           ),
          ],
          recursive: false,
          position: (662, 66),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLongWithInvalid",
          position: (667, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (667, 50),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (668, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "Hello there aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&&&&&&&",
              },
             ],
             position: (668, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (669, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "there-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-",
              },
             ],
             position: (669, 16),
            },
           ),
          ],
          recursive: false,
          position: (667, 77),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameEmpty",
          position: (672, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (672, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (673, 5),
              },
             ],
            },
            String {
             parts: [],
             position: (673, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (674, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "unknown",
              },
             ],
             position: (674, 16),
            },
           ),
          ],
          recursive: false,
          position: (672, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFreeformOptions",
          position: (677, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (678, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "submodule",
                position: (680, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "freeformType",
                    position: (681, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (681, 26),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "types",
                      position: (681, 30),
                     },
                     Raw {
                      content: "attrsOf",
                      position: (681, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (681, 45),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "types",
                        position: (681, 49),
                       },
                       Raw {
                        content: "submodule",
                        position: (681, 55),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (682, 13),
                          },
                          Raw {
                           content: "bar",
                           position: (682, 21),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (682, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (682, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (682, 40),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (681, 65),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (684, 11),
                   },
                   Raw {
                    content: "bar",
                    position: (684, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (684, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (684, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (684, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (680, 35),
              },
              position: (680, 21),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "module",
                position: (687, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (688, 11),
                   },
                   Raw {
                    content: "foo",
                    position: (688, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (688, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (688, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (689, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (689, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "types",
                           position: (689, 24),
                          },
                          Raw {
                           content: "submodule",
                           position: (689, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "submodule",
                         position: (689, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (688, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (687, 32),
              },
              position: (687, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (693, 9),
               },
              ],
             },
             PropertyAccess {
              expression: FunctionApplication {
               function: Variable {
                identifier: "evalModules",
                position: (693, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "modules",
                      position: (694, 11),
                     },
                    ],
                   },
                   List {
                    elements: [
                     Variable {
                      identifier: "module",
                      position: (694, 23),
                     },
                    ],
                    position: (694, 21),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (693, 32),
                },
               ],
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (695, 12),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "locs",
                position: (697, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (697, 16),
              },
              arguments: [
               Function {
                argument: Some(
                 "o",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: UnaryOperation {
                 operator: Not,
                 operand: PropertyAccess {
                  expression: Variable {
                   identifier: "o",
                   position: (697, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "internal",
                     position: (697, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (697, 27),
                },
                position: (697, 24),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionAttrSetToDocList",
                 position: (697, 42),
                },
                arguments: [
                 Variable {
                  identifier: "options",
                  position: (697, 65),
                 },
                ],
               },
              ],
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (698, 10),
            },
            arguments: [
             Function {
              argument: Some(
               "o",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: PropertyAccess {
               expression: Variable {
                identifier: "o",
                position: (698, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "loc",
                  position: (698, 20),
                 },
                ],
               },
               default: None,
              },
              position: (698, 15),
             },
             Variable {
              identifier: "locs",
              position: (698, 25),
             },
            ],
           },
           position: (679, 7),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (699, 5),
            },
           ],
          },
          List {
           elements: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "_module",
                },
               ],
               position: (699, 20),
              },
              String {
               parts: [
                Raw {
                 content: "args",
                },
               ],
               position: (699, 30),
              },
             ],
             position: (699, 18),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (699, 41),
              },
             ],
             position: (699, 39),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (699, 51),
              },
              String {
               parts: [
                Raw {
                 content: "<name>",
                },
               ],
               position: (699, 57),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (699, 66),
              },
             ],
             position: (699, 49),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (699, 76),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (699, 82),
              },
             ],
             position: (699, 74),
            },
           ],
           position: (699, 16),
          },
         ),
        ],
        recursive: false,
        position: (677, 25),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfEmptySet",
          position: (702, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (703, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (703, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (703, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (704, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [],
             recursive: false,
             position: (704, 18),
            },
           ],
           position: (704, 16),
          },
         ),
        ],
        recursive: false,
        position: (702, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfOneSet",
          position: (707, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (708, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (708, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (708, 37),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (708, 43),
                 },
                 Int {
                  value: 2,
                  position: (708, 45),
                 },
                 Int {
                  value: 3,
                  position: (708, 47),
                 },
                ],
                position: (708, 41),
               },
              ),
             ],
             recursive: false,
             position: (708, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (709, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (709, 20),
                 },
                ],
               },
               Int {
                value: 1,
                position: (709, 24),
               },
              ),
             ],
             recursive: false,
             position: (709, 18),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (709, 31),
                 },
                ],
               },
               Int {
                value: 2,
                position: (709, 35),
               },
              ),
             ],
             recursive: false,
             position: (709, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (709, 42),
                 },
                ],
               },
               Int {
                value: 3,
                position: (709, 46),
               },
              ),
             ],
             recursive: false,
             position: (709, 40),
            },
           ],
           position: (709, 16),
          },
         ),
        ],
        recursive: false,
        position: (707, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSets",
          position: (712, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (713, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (713, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (713, 37),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (713, 43),
                 },
                ],
                position: (713, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (713, 48),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (713, 54),
                 },
                 Int {
                  value: 20,
                  position: (713, 57),
                 },
                ],
                position: (713, 52),
               },
              ),
             ],
             recursive: false,
             position: (713, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (714, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (715, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (715, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (715, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (715, 20),
               },
              ),
             ],
             recursive: false,
             position: (715, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (716, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (716, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (716, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (716, 20),
               },
              ),
             ],
             recursive: false,
             position: (716, 7),
            },
           ],
           position: (714, 16),
          },
         ),
        ],
        recursive: false,
        position: (712, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSetsWithOneEmpty",
          position: (720, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (721, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (721, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (721, 37),
                 },
                ],
               },
               List {
                elements: [],
                position: (721, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (721, 46),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (721, 52),
                 },
                 Int {
                  value: 20,
                  position: (721, 55),
                 },
                ],
                position: (721, 50),
               },
              ),
             ],
             recursive: false,
             position: (721, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (722, 5),
            },
           ],
          },
          List {
           elements: [],
           position: (722, 16),
          },
         ),
        ],
        recursive: false,
        position: (720, 47),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfThreeSets",
          position: (725, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (726, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (726, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (727, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (727, 15),
                 },
                 Int {
                  value: 2,
                  position: (727, 19),
                 },
                 Int {
                  value: 3,
                  position: (727, 23),
                 },
                ],
                position: (727, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (728, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (728, 14),
                 },
                 Int {
                  value: 20,
                  position: (728, 18),
                 },
                 Int {
                  value: 30,
                  position: (728, 22),
                 },
                ],
                position: (728, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (729, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 100,
                  position: (729, 13),
                 },
                 Int {
                  value: 200,
                  position: (729, 17),
                 },
                 Int {
                  value: 300,
                  position: (729, 21),
                 },
                ],
                position: (729, 11),
               },
              ),
             ],
             recursive: false,
             position: (726, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (731, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (732, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (732, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (732, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (732, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (732, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (732, 28),
               },
              ),
             ],
             recursive: false,
             position: (732, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (733, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (733, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (733, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (733, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (733, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (733, 28),
               },
              ),
             ],
             recursive: false,
             position: (733, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (734, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (734, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (734, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (734, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (734, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (734, 28),
               },
              ),
             ],
             recursive: false,
             position: (734, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (736, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (736, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (736, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (736, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (736, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (736, 28),
               },
              ),
             ],
             recursive: false,
             position: (736, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (737, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (737, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (737, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (737, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (737, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (737, 28),
               },
              ),
             ],
             recursive: false,
             position: (737, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (738, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (738, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (738, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (738, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (738, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (738, 28),
               },
              ),
             ],
             recursive: false,
             position: (738, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (740, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (740, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (740, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (740, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (740, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (740, 28),
               },
              ),
             ],
             recursive: false,
             position: (740, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (741, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (741, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (741, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (741, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (741, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (741, 28),
               },
              ),
             ],
             recursive: false,
             position: (741, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (742, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (742, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (742, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (742, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (742, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (742, 28),
               },
              ),
             ],
             recursive: false,
             position: (742, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (744, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (744, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (744, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (744, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (744, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (744, 28),
               },
              ),
             ],
             recursive: false,
             position: (744, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (745, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (745, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (745, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (745, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (745, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (745, 28),
               },
              ),
             ],
             recursive: false,
             position: (745, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (746, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (746, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (746, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (746, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (746, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (746, 28),
               },
              ),
             ],
             recursive: false,
             position: (746, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (748, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (748, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (748, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (748, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (748, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (748, 28),
               },
              ),
             ],
             recursive: false,
             position: (748, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (749, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (749, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (749, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (749, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (749, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (749, 28),
               },
              ),
             ],
             recursive: false,
             position: (749, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (750, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (750, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (750, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (750, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (750, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (750, 28),
               },
              ),
             ],
             recursive: false,
             position: (750, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (752, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (752, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (752, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (752, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (752, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (752, 28),
               },
              ),
             ],
             recursive: false,
             position: (752, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (753, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (753, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (753, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (753, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (753, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (753, 28),
               },
              ),
             ],
             recursive: false,
             position: (753, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (754, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (754, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (754, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (754, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (754, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (754, 28),
               },
              ),
             ],
             recursive: false,
             position: (754, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (756, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (756, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (756, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (756, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (756, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (756, 28),
               },
              ),
             ],
             recursive: false,
             position: (756, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (757, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (757, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (757, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (757, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (757, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (757, 28),
               },
              ),
             ],
             recursive: false,
             position: (757, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (758, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (758, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (758, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (758, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (758, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (758, 28),
               },
              ),
             ],
             recursive: false,
             position: (758, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (760, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (760, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (760, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (760, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (760, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (760, 28),
               },
              ),
             ],
             recursive: false,
             position: (760, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (761, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (761, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (761, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (761, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (761, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (761, 28),
               },
              ),
             ],
             recursive: false,
             position: (761, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (762, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (762, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (762, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (762, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (762, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (762, 28),
               },
              ),
             ],
             recursive: false,
             position: (762, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (764, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (764, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (764, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (764, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (764, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (764, 28),
               },
              ),
             ],
             recursive: false,
             position: (764, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (765, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (765, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (765, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (765, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (765, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (765, 28),
               },
              ),
             ],
             recursive: false,
             position: (765, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (766, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (766, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (766, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (766, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (766, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (766, 28),
               },
              ),
             ],
             recursive: false,
             position: (766, 7),
            },
           ],
           position: (731, 16),
          },
         ),
        ],
        recursive: false,
        position: (725, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathExample",
          position: (771, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (772, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (772, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (772, 27),
              },
              String {
               parts: [
                Raw {
                 content: "10",
                },
               ],
               position: (772, 33),
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                },
               ],
               position: (772, 38),
              },
             ],
             position: (772, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (773, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "foo.\"10\".bar",
            },
           ],
           position: (773, 16),
          },
         ),
        ],
        recursive: false,
        position: (771, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathEmpty",
          position: (776, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (777, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (777, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (777, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (778, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "<root attribute path>",
            },
           ],
           position: (778, 16),
          },
         ),
        ],
        recursive: false,
        position: (776, 27),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testShowAttrPathVarious",
          position: (781, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (782, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "showAttrPath",
            position: (782, 12),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: ".",
                },
               ],
               position: (783, 7),
              },
              String {
               parts: [
                Raw {
                 content: "foo",
                },
               ],
               position: (784, 7),
              },
              String {
               parts: [
                Raw {
                 content: "2",
                },
               ],
               position: (785, 7),
              },
              String {
               parts: [
                Raw {
                 content: "a2-b",
                },
               ],
               position: (786, 7),
              },
              String {
               parts: [
                Raw {
                 content: "_bc'de",
                },
               ],
               position: (787, 7),
              },
             ],
             position: (782, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (789, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "\".\".foo.\"2\".a2-b._bc'de",
            },
           ],
           position: (789, 16),
          },
         ),
        ],
        recursive: false,
        position: (781, 29),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testGroupBy",
          position: (792, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (793, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "groupBy",
            position: (793, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "n",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (793, 24),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mod",
                 position: (793, 34),
                },
                arguments: [
                 Variable {
                  identifier: "n",
                  position: (793, 38),
                 },
                 Int {
                  value: 5,
                  position: (793, 40),
                 },
                ],
               },
              ],
             },
             position: (793, 21),
            },
            FunctionApplication {
             function: Variable {
              identifier: "range",
              position: (793, 45),
             },
             arguments: [
              Int {
               value: 0,
               position: (793, 51),
              },
              Int {
               value: 16,
               position: (793, 53),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (794, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "0",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 0,
                position: (795, 15),
               },
               Int {
                value: 5,
                position: (795, 17),
               },
               Int {
                value: 10,
                position: (795, 19),
               },
               Int {
                value: 15,
                position: (795, 22),
               },
              ],
              position: (795, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "1",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 1,
                position: (796, 15),
               },
               Int {
                value: 6,
                position: (796, 17),
               },
               Int {
                value: 11,
                position: (796, 19),
               },
               Int {
                value: 16,
                position: (796, 22),
               },
              ],
              position: (796, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "2",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 2,
                position: (797, 15),
               },
               Int {
                value: 7,
                position: (797, 17),
               },
               Int {
                value: 12,
                position: (797, 19),
               },
              ],
              position: (797, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "3",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 3,
                position: (798, 15),
               },
               Int {
                value: 8,
                position: (798, 17),
               },
               Int {
                value: 13,
                position: (798, 19),
               },
              ],
              position: (798, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: __StringParts(
                 [
                  Raw {
                   content: "4",
                  },
                 ],
                ),
               },
              ],
             },
             List {
              elements: [
               Int {
                value: 4,
                position: (799, 15),
               },
               Int {
                value: 9,
                position: (799, 17),
               },
               Int {
                value: 14,
                position: (799, 19),
               },
              ],
              position: (799, 13),
             },
            ),
           ],
           recursive: false,
           position: (794, 16),
          },
         ),
        ],
        recursive: false,
        position: (792, 17),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testGroupBy'",
          position: (803, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (804, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "groupBy'",
            position: (804, 12),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (804, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "add",
                position: (804, 30),
               },
              ],
             },
             default: None,
            },
            Int {
             value: 0,
             position: (804, 34),
            },
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "boolToString",
               position: (804, 40),
              },
              arguments: [
               BinaryOperation {
                operator: GreaterThan,
                operands: [
                 Variable {
                  identifier: "x",
                  position: (804, 54),
                 },
                 Int {
                  value: 2,
                  position: (804, 58),
                 },
                ],
                position: (804, 56),
               },
              ],
             },
             position: (804, 37),
            },
            List {
             elements: [
              Int {
               value: 5,
               position: (804, 64),
              },
              Int {
               value: 1,
               position: (804, 66),
              },
              Int {
               value: 2,
               position: (804, 68),
              },
              Int {
               value: 3,
               position: (804, 70),
              },
              Int {
               value: 4,
               position: (804, 72),
              },
             ],
             position: (804, 62),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (805, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "false",
                position: (805, 18),
               },
              ],
             },
             Int {
              value: 3,
              position: (805, 26),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "true",
                position: (805, 29),
               },
              ],
             },
             Int {
              value: 12,
              position: (805, 36),
             },
            ),
           ],
           recursive: false,
           position: (805, 16),
          },
         ),
        ],
        recursive: false,
        position: (803, 18),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathExample",
          position: (809, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (810, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (810, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (812, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (812, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (812, 22),
                   },
                  ],
                  position: (812, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (813, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "d",
                        position: (813, 25),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "old",
                       position: (813, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "c",
                         position: (813, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (813, 23),
                  },
                  position: (813, 18),
                 },
                ),
               ],
               recursive: false,
               position: (811, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (816, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (816, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (816, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                     },
                    ],
                    position: (816, 26),
                   },
                  ],
                  position: (816, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (817, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (817, 23),
                    },
                    Int {
                     value: 1,
                     position: (817, 29),
                    },
                   ],
                   position: (817, 27),
                  },
                  position: (817, 18),
                 },
                ),
               ],
               recursive: false,
               position: (815, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (820, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "x",
                     },
                    ],
                    position: (820, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "y",
                     },
                    ],
                    position: (820, 22),
                   },
                  ],
                  position: (820, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (821, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "xy",
                    },
                   ],
                   position: (821, 23),
                  },
                  position: (821, 18),
                 },
                ),
               ],
               recursive: false,
               position: (819, 7),
              },
             ],
             position: (810, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (823, 9),
                 },
                 Raw {
                  content: "b",
                  position: (823, 11),
                 },
                 Raw {
                  content: "c",
                  position: (823, 13),
                 },
                ],
               },
               Int {
                value: 0,
                position: (823, 17),
               },
              ),
             ],
             recursive: false,
             position: (823, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (824, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (824, 18),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "b",
                   position: (824, 24),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "d",
                      position: (824, 30),
                     },
                    ],
                   },
                   Int {
                    value: 1,
                    position: (824, 34),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (824, 28),
                },
               ),
              ],
              recursive: false,
              position: (824, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "x",
                position: (824, 43),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "y",
                   position: (824, 49),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "xy",
                  },
                 ],
                 position: (824, 53),
                },
               ),
              ],
              recursive: false,
              position: (824, 47),
             },
            ),
           ],
           recursive: false,
           position: (824, 16),
          },
         ),
        ],
        recursive: false,
        position: (809, 38),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathNone",
          position: (828, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (829, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (829, 12),
           },
           arguments: [
            List {
             elements: [],
             position: (829, 34),
            },
            String {
             parts: [
              Raw {
               content: "something",
              },
             ],
             position: (829, 37),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (830, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "something",
            },
           ],
           position: (830, 16),
          },
         ),
        ],
        recursive: false,
        position: (828, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathSingleIncrement",
          position: (834, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (835, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (835, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (837, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (837, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (838, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (838, 23),
                    },
                    Int {
                     value: 1,
                     position: (838, 29),
                    },
                   ],
                   position: (838, 27),
                  },
                  position: (838, 18),
                 },
                ),
               ],
               recursive: false,
               position: (836, 7),
              },
             ],
             position: (835, 34),
            },
            Int {
             value: 0,
             position: (840, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (841, 5),
            },
           ],
          },
          Int {
           value: 1,
           position: (841, 16),
          },
         ),
        ],
        recursive: false,
        position: (834, 46),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathMultipleIncrements",
          position: (845, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (846, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (846, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (848, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (848, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (849, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (849, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "a",
                      },
                     ],
                     position: (849, 29),
                    },
                   ],
                   position: (849, 27),
                  },
                  position: (849, 18),
                 },
                ),
               ],
               recursive: false,
               position: (847, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (852, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (852, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (853, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (853, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "b",
                      },
                     ],
                     position: (853, 29),
                    },
                   ],
                   position: (853, 27),
                  },
                  position: (853, 18),
                 },
                ),
               ],
               recursive: false,
               position: (851, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (856, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (856, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (857, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (857, 23),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "c",
                      },
                     ],
                     position: (857, 29),
                    },
                   ],
                   position: (857, 27),
                  },
                  position: (857, 18),
                 },
                ),
               ],
               recursive: false,
               position: (855, 7),
              },
             ],
             position: (846, 34),
            },
            String {
             parts: [],
             position: (859, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (860, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "abc",
            },
           ],
           position: (860, 16),
          },
         ),
        ],
        recursive: false,
        position: (845, 49),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathLazy",
          position: (864, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (865, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (865, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (867, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (867, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (868, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (868, 23),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "throw",
                      position: (868, 29),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "nope",
                        },
                       ],
                       position: (868, 35),
                      },
                     ],
                    },
                   ],
                   position: (868, 27),
                  },
                  position: (868, 18),
                 },
                ),
               ],
               recursive: false,
               position: (866, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (871, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (871, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (872, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "untainted",
                    },
                   ],
                   position: (872, 23),
                  },
                  position: (872, 18),
                 },
                ),
               ],
               recursive: false,
               position: (870, 7),
              },
             ],
             position: (865, 34),
            },
            FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (874, 8),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "start",
                },
               ],
               position: (874, 14),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (875, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "untainted",
            },
           ],
           position: (875, 16),
          },
         ),
        ],
        recursive: false,
        position: (864, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathDeep",
          position: (879, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (880, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (880, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (882, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (882, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (882, 22),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "c",
                     },
                    ],
                    position: (882, 26),
                   },
                  ],
                  position: (882, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (883, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (883, 23),
                    },
                    Int {
                     value: 1,
                     position: (883, 29),
                    },
                   ],
                   position: (883, 27),
                  },
                  position: (883, 18),
                 },
                ),
               ],
               recursive: false,
               position: (881, 7),
              },
             ],
             position: (880, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (886, 7),
                 },
                 Raw {
                  content: "b",
                  position: (886, 9),
                 },
                 Raw {
                  content: "c",
                  position: (886, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (886, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (888, 7),
                 },
                 Raw {
                  content: "b",
                  position: (888, 9),
                 },
                 Raw {
                  content: "z",
                  position: (888, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (888, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (889, 7),
                 },
                 Raw {
                  content: "y",
                  position: (889, 9),
                 },
                 Raw {
                  content: "z",
                  position: (889, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (889, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "x",
                  position: (890, 7),
                 },
                 Raw {
                  content: "y",
                  position: (890, 9),
                 },
                 Raw {
                  content: "z",
                  position: (890, 11),
                 },
                ],
               },
               Int {
                value: 0,
                position: (890, 15),
               },
              ),
             ],
             recursive: false,
             position: (885, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (892, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (893, 7),
               },
               Raw {
                content: "b",
                position: (893, 9),
               },
               Raw {
                content: "c",
                position: (893, 11),
               },
              ],
             },
             Int {
              value: 1,
              position: (893, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (895, 7),
               },
               Raw {
                content: "b",
                position: (895, 9),
               },
               Raw {
                content: "z",
                position: (895, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (895, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (896, 7),
               },
               Raw {
                content: "y",
                position: (896, 9),
               },
               Raw {
                content: "z",
                position: (896, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (896, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "x",
                position: (897, 7),
               },
               Raw {
                content: "y",
                position: (897, 9),
               },
               Raw {
                content: "z",
                position: (897, 11),
               },
              ],
             },
             Int {
              value: 0,
              position: (897, 15),
             },
            ),
           ],
           recursive: false,
           position: (892, 16),
          },
         ),
        ],
        recursive: false,
        position: (879, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testUpdateManyAttrsByPathNestedBeforehand",
          position: (902, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (903, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "updateManyAttrsByPath",
            position: (903, 12),
           },
           arguments: [
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (905, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (905, 18),
                   },
                  ],
                  position: (905, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (906, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (906, 23),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "x",
                          position: (906, 32),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "old",
                         position: (906, 36),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "b",
                           position: (906, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (906, 30),
                    },
                   ],
                   position: (906, 27),
                  },
                  position: (906, 18),
                 },
                ),
               ],
               recursive: false,
               position: (904, 7),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (909, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "a",
                     },
                    ],
                    position: (909, 18),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "b",
                     },
                    ],
                    position: (909, 22),
                   },
                  ],
                  position: (909, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "update",
                    position: (910, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "old",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Addition,
                   operands: [
                    Variable {
                     identifier: "old",
                     position: (910, 23),
                    },
                    Int {
                     value: 1,
                     position: (910, 29),
                    },
                   ],
                   position: (910, 27),
                  },
                  position: (910, 18),
                 },
                ),
               ],
               recursive: false,
               position: (908, 7),
              },
             ],
             position: (903, 34),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (913, 7),
                 },
                 Raw {
                  content: "b",
                  position: (913, 9),
                 },
                ],
               },
               Int {
                value: 0,
                position: (913, 13),
               },
              ),
             ],
             recursive: false,
             position: (912, 7),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (915, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (916, 7),
               },
               Raw {
                content: "b",
                position: (916, 9),
               },
              ],
             },
             Int {
              value: 1,
              position: (916, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "a",
                position: (917, 7),
               },
               Raw {
                content: "x",
                position: (917, 9),
               },
              ],
             },
             Int {
              value: 1,
              position: (917, 13),
             },
            ),
           ],
           recursive: false,
           position: (915, 16),
          },
         ),
        ],
        recursive: false,
        position: (902, 47),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthEmpty",
          position: (922, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (923, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (923, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (923, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (923, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (923, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (924, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (924, 16),
          },
         ),
        ],
        recursive: false,
        position: (922, 33),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthSame",
          position: (927, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (928, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (928, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (928, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (928, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (928, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (929, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (929, 16),
          },
         ),
        ],
        recursive: false,
        position: (927, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonPrefixLengthDiffering",
          position: (932, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (933, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (933, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonPrefixLength",
               position: (933, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (933, 39),
            },
            String {
             parts: [
              Raw {
               content: "hey",
              },
             ],
             position: (933, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (934, 5),
            },
           ],
          },
          Int {
           value: 2,
           position: (934, 16),
          },
         ),
        ],
        recursive: false,
        position: (932, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthEmpty",
          position: (937, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (938, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (938, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (938, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (938, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (938, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (939, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (939, 16),
          },
         ),
        ],
        recursive: false,
        position: (937, 33),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthSame",
          position: (942, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (943, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (943, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (943, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (943, 39),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (943, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (944, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (944, 16),
          },
         ),
        ],
        recursive: false,
        position: (942, 32),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCommonSuffixLengthDiffering",
          position: (947, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (948, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (948, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "commonSuffixLength",
               position: (948, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "test",
              },
             ],
             position: (948, 39),
            },
            String {
             parts: [
              Raw {
               content: "rest",
              },
             ],
             position: (948, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (949, 5),
            },
           ],
          },
          Int {
           value: 3,
           position: (949, 16),
          },
         ),
        ],
        recursive: false,
        position: (947, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinEmpty",
          position: (952, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (953, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (953, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (953, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (953, 32),
            },
            String {
             parts: [],
             position: (953, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (954, 5),
            },
           ],
          },
          Int {
           value: 0,
           position: (954, 16),
          },
         ),
        ],
        recursive: false,
        position: (952, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyAdd",
          position: (957, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (958, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (958, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (958, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [],
             position: (958, 32),
            },
            String {
             parts: [
              Raw {
               content: "hello there",
              },
             ],
             position: (958, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (959, 5),
            },
           ],
          },
          Int {
           value: 11,
           position: (959, 16),
          },
         ),
        ],
        recursive: false,
        position: (957, 28),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyRemove",
          position: (962, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (963, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (963, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (963, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "hello there",
              },
             ],
             position: (963, 32),
            },
            String {
             parts: [],
             position: (963, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (964, 5),
            },
           ],
          },
          Int {
           value: 11,
           position: (964, 16),
          },
         ),
        ],
        recursive: false,
        position: (962, 31),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinOnlyTransform",
          position: (967, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (968, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (968, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (968, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (968, 32),
            },
            String {
             parts: [
              Raw {
               content: "ghijkl",
              },
             ],
             position: (968, 41),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (969, 5),
            },
           ],
          },
          Int {
           value: 6,
           position: (969, 16),
          },
         ),
        ],
        recursive: false,
        position: (967, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinMixed",
          position: (972, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (973, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (973, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshtein",
               position: (973, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "kitchen",
              },
             ],
             position: (973, 32),
            },
            String {
             parts: [
              Raw {
               content: "sitting",
              },
             ],
             position: (973, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (974, 5),
            },
           ],
          },
          Int {
           value: 5,
           position: (974, 16),
          },
         ),
        ],
        recursive: false,
        position: (972, 26),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostZeroFalse",
          position: (977, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (978, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (978, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (978, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (978, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (978, 40),
            },
            String {
             parts: [
              Raw {
               content: "boo",
              },
             ],
             position: (978, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (979, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (979, 16),
          },
         ),
        ],
        recursive: false,
        position: (977, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostZeroTrue",
          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: "levenshteinAtMost",
               position: (983, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 0,
             position: (983, 38),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (983, 40),
            },
            String {
             parts: [
              Raw {
               content: "foo",
              },
             ],
             position: (983, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (984, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (984, 16),
          },
         ),
        ],
        recursive: false,
        position: (982, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostOneFalse",
          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: "levenshteinAtMost",
               position: (988, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (988, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
              },
             ],
             position: (988, 40),
            },
            String {
             parts: [
              Raw {
               content: "ct",
              },
             ],
             position: (988, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (989, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (989, 16),
          },
         ),
        ],
        recursive: false,
        position: (987, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostOneTrue",
          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: "levenshteinAtMost",
               position: (993, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 1,
             position: (993, 38),
            },
            String {
             parts: [
              Raw {
               content: "car",
              },
             ],
             position: (993, 40),
            },
            String {
             parts: [
              Raw {
               content: "cr",
              },
             ],
             position: (993, 46),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (994, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (994, 16),
          },
         ),
        ],
        recursive: false,
        position: (992, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsEmpty",
          position: (999, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1000, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1000, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1000, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1000, 38),
            },
            String {
             parts: [],
             position: (1000, 40),
            },
            String {
             parts: [],
             position: (1000, 43),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1001, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1001, 16),
          },
         ),
        ],
        recursive: false,
        position: (999, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsZero",
          position: (1004, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1005, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1005, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1005, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1005, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1005, 40),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1005, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1006, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1006, 16),
          },
         ),
        ],
        recursive: false,
        position: (1004, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoIsOne",
          position: (1009, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1010, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1010, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1010, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1010, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1010, 40),
            },
            String {
             parts: [
              Raw {
               content: "abddef",
              },
             ],
             position: (1010, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1011, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1011, 16),
          },
         ),
        ],
        recursive: false,
        position: (1009, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0False",
          position: (1014, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1015, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1015, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1015, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1015, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1015, 40),
            },
            String {
             parts: [
              Raw {
               content: "aczyef",
              },
             ],
             position: (1015, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1016, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1016, 16),
          },
         ),
        ],
        recursive: false,
        position: (1014, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0Outer",
          position: (1019, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1020, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1020, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1020, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1020, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1020, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcdez",
              },
             ],
             position: (1020, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1021, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1021, 16),
          },
         ),
        ],
        recursive: false,
        position: (1019, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelLeft",
          position: (1024, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1025, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1025, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1025, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1025, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1025, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdefz",
              },
             ],
             position: (1025, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1026, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1026, 16),
          },
         ),
        ],
        recursive: false,
        position: (1024, 42),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff0DelRight",
          position: (1029, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1030, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1030, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1030, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1030, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1030, 40),
            },
            String {
             parts: [
              Raw {
               content: "zabcde",
              },
             ],
             position: (1030, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1031, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1031, 16),
          },
         ),
        ],
        recursive: false,
        position: (1029, 43),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1False",
          position: (1034, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1035, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1035, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1035, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1035, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1035, 40),
            },
            String {
             parts: [
              Raw {
               content: "bddez",
              },
             ],
             position: (1035, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1036, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1036, 16),
          },
         ),
        ],
        recursive: false,
        position: (1034, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelLeft",
          position: (1039, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1040, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1040, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1040, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1040, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1040, 40),
            },
            String {
             parts: [
              Raw {
               content: "bcdez",
              },
             ],
             position: (1040, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1041, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1041, 16),
          },
         ),
        ],
        recursive: false,
        position: (1039, 42),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff1DelRight",
          position: (1044, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1045, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1045, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1045, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1045, 38),
            },
            String {
             parts: [
              Raw {
               content: "abcdef",
              },
             ],
             position: (1045, 40),
            },
            String {
             parts: [
              Raw {
               content: "zbcde",
              },
             ],
             position: (1045, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1046, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1046, 16),
          },
         ),
        ],
        recursive: false,
        position: (1044, 43),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2False",
          position: (1049, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1050, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1050, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1050, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1050, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1050, 40),
            },
            String {
             parts: [
              Raw {
               content: "hxo",
              },
             ],
             position: (1050, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1051, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1051, 16),
          },
         ),
        ],
        recursive: false,
        position: (1049, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff2True",
          position: (1054, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (1055, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "strings",
             position: (1055, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "levenshteinAtMost",
               position: (1055, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Int {
             value: 2,
             position: (1055, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1055, 40),
            },
            String {
             parts: [
              Raw {
               content: "heo",
              },
             ],
             position: (1055, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1056, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1056, 16),
          },
         ),
        ],
        recursive: false,
        position: (1054, 39),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostTwoDiff3",
          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: [
              Raw {
               content: "hello",
              },
             ],
             position: (1060, 40),
            },
            String {
             parts: [
              Raw {
               content: "ho",
              },
             ],
             position: (1060, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1061, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1061, 16),
          },
         ),
        ],
        recursive: false,
        position: (1059, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostThreeFalse",
          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: 3,
             position: (1065, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1065, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla!",
              },
             ],
             position: (1065, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1066, 5),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (1066, 16),
          },
         ),
        ],
        recursive: false,
        position: (1064, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testLevenshteinAtMostThreeTrue",
          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: 3,
             position: (1070, 38),
            },
            String {
             parts: [
              Raw {
               content: "hello",
              },
             ],
             position: (1070, 40),
            },
            String {
             parts: [
              Raw {
               content: "Holla",
              },
             ],
             position: (1070, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (1071, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (1071, 16),
          },
         ),
        ],
        recursive: false,
        position: (1069, 36),
       },
      ),
     ],
     recursive: false,
     position: (23, 10),
    },
   ],
  },
  position: (6, 1),
 },
 position: (4, 1),
}