---
LetIn {
 bindings: [
  Binding {
   from: AttributePath {
    parts: [
     Raw {
      content: "tests",
      position: (3, 5),
     },
    ],
   },
   to: List {
    elements: [
     String {
      parts: [
       Raw {
        content: "misc",
        position: (3, 16),
       },
      ],
      position: (3, 15),
     },
     String {
      parts: [
       Raw {
        content: "systems",
        position: (3, 23),
       },
      ],
      position: (3, 22),
     },
    ],
    position: (3, 13),
   },
  },
  Binding {
   from: AttributePath {
    parts: [
     Raw {
      content: "all",
      position: (4, 5),
     },
    ],
   },
   to: FunctionApplication {
    function: PropertyAccess {
     expression: Variable {
      identifier: "builtins",
      position: (4, 11),
     },
     attribute_path: AttributePath {
      parts: [
       Raw {
        content: "concatLists",
        position: (4, 20),
       },
      ],
     },
     default: None,
    },
    arguments: [
     Parentheses {
      expression: FunctionApplication {
       function: Variable {
        identifier: "map",
        position: (4, 33),
       },
       arguments: [
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "f",
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "import",
            position: (4, 41),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: Addition,
              operands: [
               Path {
                parts: [
                 Raw {
                  content: "./.",
                  position: (4, 49),
                 },
                ],
                position: (4, 49),
               },
               String {
                parts: [
                 Raw {
                  content: "/",
                  position: (4, 56),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "f",
                   position: (4, 59),
                  },
                 },
                 Raw {
                  content: ".nix",
                  position: (4, 61),
                 },
                ],
                position: (4, 55),
               },
              ],
              position: (4, 53),
             },
             position: (4, 48),
            },
           ],
          },
          position: (4, 38),
         },
         position: (4, 37),
        },
        Variable {
         identifier: "tests",
         position: (4, 69),
        },
       ],
      },
      position: (4, 32),
     },
    ],
   },
  },
 ],
 target: IfThenElse {
  predicate: BinaryOperation {
   operator: EqualTo,
   operands: [
    Variable {
     identifier: "all",
     position: (5, 7),
    },
    List {
     elements: [],
     position: (5, 14),
    },
   ],
   position: (5, 11),
  },
  then: Variable {
   identifier: "null",
   position: (6, 11),
  },
  else_: FunctionApplication {
   function: Variable {
    identifier: "throw",
    position: (7, 9),
   },
   arguments: [
    Parentheses {
     expression: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (7, 16),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "toJSON",
          position: (7, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Variable {
        identifier: "all",
        position: (7, 32),
       },
      ],
     },
     position: (7, 15),
    },
   ],
  },
  position: (5, 4),
 },
 position: (3, 1),
}