---
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, 18),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "system",
                position: (13, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "x",
                position: (13, 17),
               },
              ],
             },
            ),
           ],
           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, 21),
                     },
                    ],
                   },
                  ],
                  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: (58, 1),
            },
           ],
          },
         ),
        ],
        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, 40),
                   },
                  ],
                 },
                 else_: String {
                  parts: [
                   Raw {
                    content: "b",
                    position: (76, 49),
                   },
                  ],
                 },
                 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, 22),
               },
              ],
             },
            ),
           ],
           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, 17),
            },
           ],
          },
         ),
        ],
        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, 38),
                 },
                ],
               },
              ],
              position: (148, 35),
             },
             position: (148, 30),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (148, 44),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (148, 48),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (148, 52),
                },
               ],
              },
             ],
             position: (148, 42),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (149, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "a;b;c;",
             position: (149, 17),
            },
           ],
          },
         ),
        ],
        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, 30),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (153, 35),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (153, 39),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (153, 43),
                },
               ],
              },
             ],
             position: (153, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (154, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "a,b,c",
             position: (154, 17),
            },
           ],
          },
         ),
        ],
        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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "a.b.c.d",
               position: (158, 37),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (159, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
               position: (159, 19),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (159, 23),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (159, 27),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "d",
               position: (159, 31),
              },
             ],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "a..b",
               position: (163, 37),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (164, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a",
               position: (164, 19),
              },
             ],
            },
            String {
             parts: [],
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (164, 26),
              },
             ],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "a.b",
               position: (168, 37),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (169, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "a.b",
               position: (169, 19),
              },
             ],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (174, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "/a/b/c",
               position: (178, 37),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (179, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
            },
            String {
             parts: [
              Raw {
               content: "a",
               position: (179, 22),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "b",
               position: (179, 26),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (179, 30),
              },
             ],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "2001:db8:0:0042::8a2e:370:",
               position: (183, 37),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (184, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "2001",
               position: (184, 19),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "db8",
               position: (184, 26),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "0",
               position: (184, 32),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "0042",
               position: (184, 36),
              },
             ],
            },
            String {
             parts: [],
            },
            String {
             parts: [
              Raw {
               content: "8a2e",
               position: (184, 46),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "370",
               position: (184, 53),
              },
             ],
            },
            String {
             parts: [],
            },
           ],
           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, 33),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "A\\[{}]()^$?*+|.B",
               position: (188, 51),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (189, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "A",
               position: (189, 19),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "B",
               position: (189, 23),
              },
             ],
            },
           ],
           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, 42),
                },
               ],
              },
              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, 15),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "builder",
                      position: (195, 7),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "builder",
                      position: (195, 18),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (196, 7),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "system",
                      position: (196, 17),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (193, 57),
                },
               ],
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (198, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [],
            },
            String {
             parts: [
              Raw {
               content: "nix",
               position: (198, 21),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "store",
               position: (198, 27),
              },
             ],
            },
           ],
           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, 35),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (203, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (203, 19),
              },
             ],
            },
           ],
           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, 35),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (208, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (208, 19),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "2",
               position: (208, 23),
              },
             ],
            },
           ],
           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, 35),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (213, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1",
               position: (213, 19),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "2",
               position: (213, 23),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "3",
               position: (213, 27),
              },
             ],
            },
           ],
           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, 34),
               },
              ],
             },
            ),
           ],
           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, 69),
                        },
                       ],
                      },
                     ),
                    ],
                    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, 23),
                  },
                 ],
                },
               ],
              },
             ),
             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, 34),
                  },
                 ],
                },
               ],
              },
             ),
             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, 24),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (251, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "&quot;test&quot; &apos;test&apos; &lt; &amp; &gt;",
             position: (251, 17),
            },
           ],
          },
         ),
        ],
        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, 29),
                 },
                ],
               },
              ],
              position: (257, 25),
             },
             position: (257, 20),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (257, 35),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (257, 39),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "c",
                 position: (257, 43),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "a",
                 position: (257, 47),
                },
               ],
              },
             ],
             position: (257, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (258, 5),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "b",
               position: (258, 18),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "c",
               position: (258, 22),
              },
             ],
            },
           ],
           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, 19),
              },
             ],
            },
           ],
          },
         ),
         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, 37),
                },
               ],
              },
             ],
            },
           ],
          },
         ),
         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, 28),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (322, 32),
                },
               ],
              },
             ],
             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, 49),
                    },
                   ],
                  },
                 ),
                ],
                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, 28),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "b",
                 position: (327, 32),
                },
               ],
              },
             ],
             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, 49),
                    },
                   ],
                  },
                 ),
                ],
                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, 56),
                     },
                    ],
                   },
                  ],
                  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, 45),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "f:oo",
               position: (375, 49),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "bar",
               position: (375, 56),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (376, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "f\\:oo:bar",
             position: (376, 18),
            },
           ],
          },
         ),
        ],
        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, 20),
                  },
                 ],
                },
               ),
               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, 14),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "string",
                position: (394, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "fo\"o",
                position: (394, 18),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bool",
                position: (395, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "true",
                position: (395, 15),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bool2",
                position: (396, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "false",
                position: (396, 16),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "null",
                position: (397, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "null",
                position: (397, 15),
               },
              ],
             },
            ),
           ],
           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, 14),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: String {
                   parts: [
                    Raw {
                     content: "other=key",
                     position: (405, 8),
                    },
                   ],
                  },
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "baz",
                  position: (405, 22),
                 },
                ],
               },
              ),
             ],
             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: (408, 1),
            },
           ],
          },
         ),
        ],
        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: [],
          },
         ),
        ],
        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: (421, 1),
            },
           ],
          },
         ),
        ],
        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: (430, 1),
            },
           ],
          },
         ),
        ],
        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: String {
                   parts: [
                    Raw {
                     content: "no [ and ] allowed unescaped",
                     position: (441, 8),
                    },
                   ],
                  },
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "and also no = in keys",
                        position: (442, 10),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  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: (446, 1),
            },
           ],
          },
         ),
        ],
        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: String {
                   parts: [
                    Raw {
                     content: "section 1",
                     position: (453, 8),
                    },
                   ],
                  },
                 },
                ],
               },
               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, 14),
                    },
                   ],
                  },
                 ),
                 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: String {
                   parts: [
                    Raw {
                     content: "foo[]",
                     position: (459, 8),
                    },
                   ],
                  },
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "he\\h=he",
                        position: (460, 10),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "this is okay",
                     position: (460, 23),
                    },
                   ],
                  },
                 ),
                ],
                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: (464, 1),
            },
           ],
          },
         ),
        ],
        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, 19),
                 },
                ],
               },
               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, 36),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "builder",
                  position: (499, 43),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/bin/sh",
                  position: (499, 54),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "system",
                  position: (499, 64),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "aarch64-linux",
                  position: (499, 74),
                 },
                ],
               },
              ),
             ],
             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: [],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "string",
                   position: (506, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "fno\"rd",
                   position: (506, 18),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "newlinestring",
                   position: (507, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "\n",
                   position: (507, 24),
                  },
                 ],
                },
               ),
               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, 20),
                    },
                   ],
                  },
                 ],
                 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: String {
                       parts: [
                        Raw {
                         content: "foo bar",
                         position: (514, 30),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "baz",
                      position: (514, 42),
                     },
                    ],
                   },
                  ),
                 ],
                 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, 14),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "float",
                 position: (520, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "~0.133700",
                 position: (520, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bool",
                 position: (521, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "true",
                 position: (521, 15),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptystring",
                 position: (522, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\"",
                 position: (522, 23),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "string",
                 position: (523, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"fno\\\"rd\"",
                 position: (523, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "newlinestring",
                 position: (524, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "\"\\n\"",
                 position: (524, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (525, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/foo",
                 position: (525, 15),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "null_",
                 position: (526, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "null",
                 position: (526, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "function",
                 position: (527, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function>",
                 position: (527, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "functionArgs",
                 position: (528, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<function, args: {arg?, foo}>",
                 position: (528, 23),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "list",
                 position: (529, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ 3 4 ",
                 position: (529, 15),
                },
                Expression {
                 expression: Variable {
                  identifier: "function",
                  position: (529, 23),
                 },
                },
                Raw {
                 content: " [ false ] ]",
                 position: (529, 32),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptylist",
                 position: (530, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "[ ]",
                 position: (530, 20),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "attrs",
                 position: (531, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ foo = null; \"foo bar\" = \"baz\"; }",
                 position: (531, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "emptyattrs",
                 position: (532, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "{ }",
                 position: (532, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "drv",
                 position: (533, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<derivation ",
                 position: (533, 14),
                },
                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, 42),
                },
               ],
              },
             ),
            ],
            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, 19),
             },
            ],
           },
          ),
         ],
         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, 40),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (559, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "newlinestring",
                  position: (560, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "\n",
                  position: (560, 24),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring",
                  position: (561, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "hello\nthere\ntest\n",
                  position: (562, 1),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "multilinestring'",
                  position: (566, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "        hello\nthere\ntest",
                  position: (567, 1),
                 },
                ],
               },
              ),
             ],
             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: (573, 1),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "attrs",
                position: (580, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        {\n  bar = {\n    foo = \"baz\";\n  };\n  foo = null;\n}",
                position: (581, 1),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "newlinestring",
                position: (587, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "''\n  \n''",
                position: (587, 24),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring",
                position: (588, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
                position: (589, 1),
               },
               Raw {
                content: "''",
                position: (589, 9),
               },
               Raw {
                content: "\n  hello\n  there\n  test\n",
                position: (589, 12),
               },
               Raw {
                content: "''",
                position: (593, 9),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "multilinestring'",
                position: (594, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "        ",
                position: (595, 1),
               },
               Raw {
                content: "''",
                position: (595, 9),
               },
               Raw {
                content: "\n  hello\n  there\n  test",
                position: (595, 12),
               },
               Raw {
                content: "''",
                position: (598, 15),
               },
              ],
             },
            ),
           ],
           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, 31),
                      },
                     ],
                    },
                    Variable {
                     identifier: "v",
                     position: (605, 36),
                    },
                   ],
                   position: (605, 34),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "»",
                     position: (605, 41),
                    },
                   ],
                  },
                 ],
                 position: (605, 38),
                },
                position: (605, 27),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "val",
                  position: (605, 45),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "foo",
                  position: (605, 52),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (605, 14),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (606, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "«foo»",
             position: (606, 18),
            },
           ],
          },
         ),
        ],
        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, 12),
                 },
                ],
               },
              ),
              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, 16),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                    position: (618, 42),
                   },
                  ],
                 },
                ],
                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, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "PUT",
               position: (624, 13),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "--data",
               position: (625, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "{\"id\":0}",
               position: (625, 17),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "--retry",
               position: (626, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "3",
               position: (626, 18),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "--url",
               position: (627, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/foo",
               position: (627, 16),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "--url",
               position: (628, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "https://example.com/bar",
               position: (628, 16),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "--verbose",
               position: (629, 8),
              },
             ],
            },
           ],
           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, 12),
                 },
                ],
               },
              ),
              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, 16),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com/bar",
                    position: (639, 42),
                   },
                  ],
                 },
                ],
                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, 17),
            },
           ],
          },
         ),
        ],
        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, 13),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (649, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "foo",
               position: (649, 17),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (647, 70),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameAscii",
          position: (652, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (652, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (653, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
               position: (653, 13),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (654, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "-+--.-0123456789-=-?-ABCDEFGHIJKLMNOPQRSTUVWXYZ-_-abcdefghijklmnopqrstuvwxyz-",
               position: (654, 17),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (652, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLong",
          position: (657, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (657, 39),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (658, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "This string is loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
               position: (658, 13),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (659, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
               position: (659, 17),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (657, 66),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameTooLongWithInvalid",
          position: (662, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (662, 50),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (663, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "Hello there aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&&&&&&&",
               position: (663, 13),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (664, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "there-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-",
               position: (664, 17),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (662, 77),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testSanitizeDerivationNameEmpty",
          position: (667, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "testSanitizeDerivationName",
         position: (667, 37),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (668, 5),
              },
             ],
            },
            String {
             parts: [],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expected",
               position: (669, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "unknown",
               position: (669, 17),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (667, 64),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testFreeformOptions",
          position: (672, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (673, 5),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "submodule",
                position: (675, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "freeformType",
                    position: (676, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (676, 26),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "types",
                      position: (676, 30),
                     },
                     Raw {
                      content: "attrsOf",
                      position: (676, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (676, 45),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "types",
                        position: (676, 49),
                       },
                       Raw {
                        content: "submodule",
                        position: (676, 55),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (677, 13),
                          },
                          Raw {
                           content: "bar",
                           position: (677, 21),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (677, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (677, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (677, 40),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (676, 65),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (679, 11),
                   },
                   Raw {
                    content: "bar",
                    position: (679, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (679, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (679, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (679, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (675, 35),
              },
              position: (675, 21),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "module",
                position: (682, 9),
               },
              ],
             },
             Function {
              argument: None,
              arguments: FunctionArguments {
               arguments: [
                FunctionArgument {
                 identifier: "lib",
                 default: None,
                },
               ],
               ellipsis: true,
              },
              definition: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (683, 11),
                   },
                   Raw {
                    content: "foo",
                    position: (683, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (683, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkOption",
                      position: (683, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (684, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (684, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "types",
                           position: (684, 24),
                          },
                          Raw {
                           content: "submodule",
                           position: (684, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "submodule",
                         position: (684, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (683, 38),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (682, 32),
              },
              position: (682, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (688, 9),
               },
              ],
             },
             PropertyAccess {
              expression: FunctionApplication {
               function: Variable {
                identifier: "evalModules",
                position: (688, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "modules",
                      position: (689, 11),
                     },
                    ],
                   },
                   List {
                    elements: [
                     Variable {
                      identifier: "module",
                      position: (689, 23),
                     },
                    ],
                    position: (689, 21),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (688, 32),
                },
               ],
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (690, 12),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "locs",
                position: (692, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (692, 16),
              },
              arguments: [
               Function {
                argument: Some(
                 "o",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: UnaryOperation {
                 operator: Not,
                 operand: PropertyAccess {
                  expression: Variable {
                   identifier: "o",
                   position: (692, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "internal",
                     position: (692, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (692, 27),
                },
                position: (692, 24),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionAttrSetToDocList",
                 position: (692, 42),
                },
                arguments: [
                 Variable {
                  identifier: "options",
                  position: (692, 65),
                 },
                ],
               },
              ],
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (693, 10),
            },
            arguments: [
             Function {
              argument: Some(
               "o",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: PropertyAccess {
               expression: Variable {
                identifier: "o",
                position: (693, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "loc",
                  position: (693, 20),
                 },
                ],
               },
               default: None,
              },
              position: (693, 15),
             },
             Variable {
              identifier: "locs",
              position: (693, 25),
             },
            ],
           },
           position: (674, 7),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (694, 5),
            },
           ],
          },
          List {
           elements: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (694, 21),
                },
               ],
              },
             ],
             position: (694, 18),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (694, 31),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "<name>",
                 position: (694, 37),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                 position: (694, 46),
                },
               ],
              },
             ],
             position: (694, 28),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "foo",
                 position: (694, 56),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "bar",
                 position: (694, 62),
                },
               ],
              },
             ],
             position: (694, 53),
            },
           ],
           position: (694, 16),
          },
         ),
        ],
        recursive: false,
        position: (672, 25),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfEmptySet",
          position: (697, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (698, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (698, 12),
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (698, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (699, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [],
             recursive: false,
             position: (699, 18),
            },
           ],
           position: (699, 16),
          },
         ),
        ],
        recursive: false,
        position: (697, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfOneSet",
          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: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (703, 37),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (703, 43),
                 },
                 Int {
                  value: 2,
                  position: (703, 45),
                 },
                 Int {
                  value: 3,
                  position: (703, 47),
                 },
                ],
                position: (703, 41),
               },
              ),
             ],
             recursive: false,
             position: (703, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (704, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (704, 20),
                 },
                ],
               },
               Int {
                value: 1,
                position: (704, 24),
               },
              ),
             ],
             recursive: false,
             position: (704, 18),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (704, 31),
                 },
                ],
               },
               Int {
                value: 2,
                position: (704, 35),
               },
              ),
             ],
             recursive: false,
             position: (704, 29),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (704, 42),
                 },
                ],
               },
               Int {
                value: 3,
                position: (704, 46),
               },
              ),
             ],
             recursive: false,
             position: (704, 40),
            },
           ],
           position: (704, 16),
          },
         ),
        ],
        recursive: false,
        position: (702, 34),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSets",
          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),
                 },
                ],
                position: (708, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (708, 48),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (708, 54),
                 },
                 Int {
                  value: 20,
                  position: (708, 57),
                 },
                ],
                position: (708, 52),
               },
              ),
             ],
             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: (710, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (710, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (710, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (710, 20),
               },
              ),
             ],
             recursive: false,
             position: (710, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (711, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (711, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (711, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (711, 20),
               },
              ),
             ],
             recursive: false,
             position: (711, 7),
            },
           ],
           position: (709, 16),
          },
         ),
        ],
        recursive: false,
        position: (707, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfTwoSetsWithOneEmpty",
          position: (715, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expr",
             position: (716, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "cartesianProductOfSets",
            position: (716, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (716, 37),
                 },
                ],
               },
               List {
                elements: [],
                position: (716, 41),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (716, 46),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (716, 52),
                 },
                 Int {
                  value: 20,
                  position: (716, 55),
                 },
                ],
                position: (716, 50),
               },
              ),
             ],
             recursive: false,
             position: (716, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (717, 5),
            },
           ],
          },
          List {
           elements: [],
           position: (717, 16),
          },
         ),
        ],
        recursive: false,
        position: (715, 47),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testCartesianProductOfThreeSets",
          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: (722, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 1,
                  position: (722, 15),
                 },
                 Int {
                  value: 2,
                  position: (722, 19),
                 },
                 Int {
                  value: 3,
                  position: (722, 23),
                 },
                ],
                position: (722, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (723, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 10,
                  position: (723, 14),
                 },
                 Int {
                  value: 20,
                  position: (723, 18),
                 },
                 Int {
                  value: 30,
                  position: (723, 22),
                 },
                ],
                position: (723, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (724, 7),
                 },
                ],
               },
               List {
                elements: [
                 Int {
                  value: 100,
                  position: (724, 13),
                 },
                 Int {
                  value: 200,
                  position: (724, 17),
                 },
                 Int {
                  value: 300,
                  position: (724, 21),
                 },
                ],
                position: (724, 11),
               },
              ),
             ],
             recursive: false,
             position: (721, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "expected",
             position: (726, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (727, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (727, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (727, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (727, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (727, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (727, 28),
               },
              ),
             ],
             recursive: false,
             position: (727, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (728, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (728, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (728, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (728, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (728, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (728, 28),
               },
              ),
             ],
             recursive: false,
             position: (728, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (729, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (729, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (729, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (729, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (729, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (729, 28),
               },
              ),
             ],
             recursive: false,
             position: (729, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (731, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (731, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (731, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (731, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (731, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (731, 28),
               },
              ),
             ],
             recursive: false,
             position: (731, 7),
            },
            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: 20,
                position: (732, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (732, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 20,
                position: (733, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (733, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (733, 28),
               },
              ),
             ],
             recursive: false,
             position: (733, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (735, 9),
                 },
                ],
               },
               Int {
                value: 1,
                position: (735, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (735, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (735, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (735, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (735, 28),
               },
              ),
             ],
             recursive: false,
             position: (735, 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: 30,
                position: (736, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (736, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 30,
                position: (737, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (737, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (737, 28),
               },
              ),
             ],
             recursive: false,
             position: (737, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (739, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (739, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (739, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (739, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (739, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (739, 28),
               },
              ),
             ],
             recursive: false,
             position: (739, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (740, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (740, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (740, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (740, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (740, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (740, 28),
               },
              ),
             ],
             recursive: false,
             position: (740, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (741, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (741, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (741, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (741, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (741, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (741, 28),
               },
              ),
             ],
             recursive: false,
             position: (741, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (743, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (743, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (743, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (743, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (743, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (743, 28),
               },
              ),
             ],
             recursive: false,
             position: (743, 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: 20,
                position: (744, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (744, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 20,
                position: (745, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (745, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (745, 28),
               },
              ),
             ],
             recursive: false,
             position: (745, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (747, 9),
                 },
                ],
               },
               Int {
                value: 2,
                position: (747, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (747, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (747, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (747, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (747, 28),
               },
              ),
             ],
             recursive: false,
             position: (747, 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: 30,
                position: (748, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (748, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 30,
                position: (749, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (749, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (749, 28),
               },
              ),
             ],
             recursive: false,
             position: (749, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (751, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (751, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (751, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (751, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (751, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (751, 28),
               },
              ),
             ],
             recursive: false,
             position: (751, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (752, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (752, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (752, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (752, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (752, 24),
                 },
                ],
               },
               Int {
                value: 200,
                position: (752, 28),
               },
              ),
             ],
             recursive: false,
             position: (752, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (753, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (753, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (753, 16),
                 },
                ],
               },
               Int {
                value: 10,
                position: (753, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (753, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (753, 28),
               },
              ),
             ],
             recursive: false,
             position: (753, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (755, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (755, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (755, 16),
                 },
                ],
               },
               Int {
                value: 20,
                position: (755, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (755, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (755, 28),
               },
              ),
             ],
             recursive: false,
             position: (755, 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: 20,
                position: (756, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (756, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 20,
                position: (757, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (757, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (757, 28),
               },
              ),
             ],
             recursive: false,
             position: (757, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "a",
                  position: (759, 9),
                 },
                ],
               },
               Int {
                value: 3,
                position: (759, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "b",
                  position: (759, 16),
                 },
                ],
               },
               Int {
                value: 30,
                position: (759, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (759, 24),
                 },
                ],
               },
               Int {
                value: 100,
                position: (759, 28),
               },
              ),
             ],
             recursive: false,
             position: (759, 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: 30,
                position: (760, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (760, 24),
                 },
                ],
               },
               Int {
                value: 200,
                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: 30,
                position: (761, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "c",
                  position: (761, 24),
                 },
                ],
               },
               Int {
                value: 300,
                position: (761, 28),
               },
              ),
             ],
             recursive: false,
             position: (761, 7),
            },
           ],
           position: (726, 16),
          },
         ),
        ],
        recursive: false,
        position: (720, 37),
       },
      ),
     ],
     recursive: false,
     position: (23, 10),
    },
   ],
  },
  position: (6, 1),
 },
 position: (4, 1),
}