---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "options",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "graphite",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "opt",
        position: (7, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (7, 17),
        },
        Raw {
         content: "graphite",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "writeTextOrNull",
        position: (8, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "f",
      },
      definition: Function {
       argument: Simple {
        identifier: "t",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mapNullable",
         position: (8, 27),
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "pkgs",
             position: (8, 40),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "writeTextDir",
               position: (8, 45),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (8, 58),
            },
           ],
          },
          position: (8, 39),
         },
         Variable {
          identifier: "t",
          position: (8, 61),
         },
        ],
       },
       position: (8, 24),
      },
      position: (8, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "dataDir",
        position: (10, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (10, 13),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "dataDir",
         position: (10, 17),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "staticDir",
        position: (11, 3),
       },
      ],
     },
     to: BinaryOperation {
      operator: Addition,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (11, 15),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "dataDir",
           position: (11, 19),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "/static",
          position: (11, 30),
         },
        ],
        position: (11, 29),
       },
      ],
      position: (11, 27),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "graphiteLocalSettingsDir",
        position: (13, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 30),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "runCommand",
          position: (13, 35),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite_local_settings",
          position: (13, 47),
         },
        ],
        position: (13, 46),
       },
       Map {
        bindings: [
         Inherit {
          from: None,
          attributes: [
           Raw {
            content: "graphiteLocalSettings",
            position: (14, 15),
           },
          ],
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "preferLocalBuild",
             position: (15, 7),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (15, 26),
          },
         },
        ],
        recursive: false,
        position: (13, 72),
       },
       String {
        parts: [
         Raw {
          content: "mkdir -p $out\nln -s $graphiteLocalSettings $out/graphite_local_settings.py\n",
          position: (17, 1),
         },
        ],
        position: (16, 7),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "graphiteLocalSettings",
        position: (21, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (21, 27),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (21, 32),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite_local_settings.py",
          position: (21, 43),
         },
        ],
        position: (21, 42),
       },
       Parentheses {
        expression: BinaryOperation {
         operator: Addition,
         operands: [
          BinaryOperation {
           operator: Addition,
           operands: [
            String {
             parts: [
              Raw {
               content: "STATIC_ROOT = '",
               position: (22, 6),
              },
              Interpolation {
               expression: Variable {
                identifier: "staticDir",
                position: (22, 23),
               },
              },
              Raw {
               content: "'\n",
               position: (22, 33),
              },
             ],
             position: (22, 5),
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalString",
              position: (23, 5),
             },
             arguments: [
              Parentheses {
               expression: BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (23, 21),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "time",
                     position: (23, 28),
                    },
                    Raw {
                     content: "timeZone",
                     position: (23, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "null",
                  position: (23, 45),
                 },
                ],
                position: (23, 42),
               },
               position: (23, 20),
              },
              String {
               parts: [
                Raw {
                 content: "TIME_ZONE = '",
                 position: (23, 52),
                },
                Interpolation {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (23, 67),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "time",
                     position: (23, 74),
                    },
                    Raw {
                     content: "timeZone",
                     position: (23, 79),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "'\n",
                 position: (23, 88),
                },
               ],
               position: (23, 51),
              },
             ],
            },
           ],
           position: (22, 38),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (24, 7),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "web",
              position: (24, 11),
             },
             Raw {
              content: "extraConfig",
              position: (24, 15),
             },
            ],
           },
           default: None,
          },
         ],
         position: (24, 5),
        },
        position: (21, 71),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "graphiteApiConfig",
        position: (27, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (27, 23),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (27, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite-api.yaml",
          position: (27, 39),
         },
        ],
        position: (27, 38),
       },
       String {
        parts: [
         Raw {
          content: "search_index: ",
          position: (28, 1),
         },
         Interpolation {
          expression: Variable {
           identifier: "dataDir",
           position: (28, 21),
          },
         },
         Raw {
          content: "/index\n",
          position: (28, 29),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (29, 7),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (29, 23),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "time",
                   position: (29, 30),
                  },
                  Raw {
                   content: "timeZone",
                   position: (29, 35),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (29, 47),
               },
              ],
              position: (29, 44),
             },
             position: (29, 22),
            },
            String {
             parts: [
              Raw {
               content: "time_zone: ",
               position: (29, 54),
              },
              Interpolation {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (29, 67),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "time",
                   position: (29, 74),
                  },
                  Raw {
                   content: "timeZone",
                   position: (29, 79),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
             position: (29, 53),
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (29, 90),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (30, 7),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (30, 23),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "api",
                   position: (30, 27),
                  },
                  Raw {
                   content: "finders",
                   position: (30, 31),
                  },
                 ],
                },
                default: None,
               },
               List {
                elements: [],
                position: (30, 42),
               },
              ],
              position: (30, 39),
             },
             position: (30, 22),
            },
            String {
             parts: [
              Raw {
               content: "finders:",
               position: (30, 47),
              },
             ],
             position: (30, 46),
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (30, 57),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMapStringsSep",
            position: (31, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (31, 28),
              },
             ],
             position: (31, 27),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "f",
              },
              definition: BinaryOperation {
               operator: Addition,
               operands: [
                String {
                 parts: [
                  Raw {
                   content: "  - ",
                   position: (31, 37),
                  },
                 ],
                 position: (31, 36),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "f",
                  position: (31, 45),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "moduleName",
                    position: (31, 47),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (31, 43),
              },
              position: (31, 33),
             },
             position: (31, 32),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (31, 59),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "api",
                position: (31, 63),
               },
               Raw {
                content: "finders",
                position: (31, 67),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (31, 75),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (32, 7),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (32, 23),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "api",
                   position: (32, 27),
                  },
                  Raw {
                   content: "functions",
                   position: (32, 31),
                  },
                 ],
                },
                default: None,
               },
               List {
                elements: [],
                position: (32, 44),
               },
              ],
              position: (32, 41),
             },
             position: (32, 22),
            },
            String {
             parts: [
              Raw {
               content: "functions:",
               position: (32, 49),
              },
             ],
             position: (32, 48),
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (32, 61),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMapStringsSep",
            position: (33, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (33, 28),
              },
             ],
             position: (33, 27),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "f",
              },
              definition: BinaryOperation {
               operator: Addition,
               operands: [
                String {
                 parts: [
                  Raw {
                   content: "  - ",
                   position: (33, 37),
                  },
                 ],
                 position: (33, 36),
                },
                Variable {
                 identifier: "f",
                 position: (33, 45),
                },
               ],
               position: (33, 43),
              },
              position: (33, 33),
             },
             position: (33, 32),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (33, 48),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "api",
                position: (33, 52),
               },
               Raw {
                content: "functions",
                position: (33, 56),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (33, 66),
         },
         Interpolation {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (34, 7),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "api",
              position: (34, 11),
             },
             Raw {
              content: "extraConfig",
              position: (34, 15),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (34, 27),
         },
        ],
        position: (27, 58),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "seyrenConfig",
        position: (37, 3),
       },
      ],
     },
     to: BinaryOperation {
      operator: Update,
      operands: [
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "SEYREN_URL",
             position: (38, 5),
            },
           ],
          },
          to: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (38, 18),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "seyren",
              position: (38, 22),
             },
             Raw {
              content: "seyrenUrl",
              position: (38, 29),
             },
            ],
           },
           default: None,
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "MONGO_URL",
             position: (39, 5),
            },
           ],
          },
          to: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (39, 17),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "seyren",
              position: (39, 21),
             },
             Raw {
              content: "mongoUrl",
              position: (39, 28),
             },
            ],
           },
           default: None,
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "GRAPHITE_URL",
             position: (40, 5),
            },
           ],
          },
          to: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (40, 20),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "seyren",
              position: (40, 24),
             },
             Raw {
              content: "graphiteUrl",
              position: (40, 31),
             },
            ],
           },
           default: None,
          },
         },
        ],
        recursive: false,
        position: (37, 18),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (41, 8),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "seyren",
           position: (41, 12),
          },
          Raw {
           content: "extraConfig",
           position: (41, 19),
          },
         ],
        },
        default: None,
       },
      ],
      position: (41, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "configDir",
        position: (43, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (43, 15),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "buildEnv",
          position: (43, 20),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "name",
             position: (44, 5),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "graphite-config",
             position: (44, 13),
            },
           ],
           position: (44, 12),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "paths",
             position: (45, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lists",
             position: (45, 13),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "filter",
               position: (45, 19),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "el",
              },
              definition: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                Variable {
                 identifier: "el",
                 position: (45, 31),
                },
                Variable {
                 identifier: "null",
                 position: (45, 37),
                },
               ],
               position: (45, 34),
              },
              position: (45, 27),
             },
             position: (45, 26),
            },
            List {
             elements: [
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (46, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "carbon.conf",
                    position: (46, 25),
                   },
                  ],
                  position: (46, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (46, 38),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (46, 42),
                    },
                    Raw {
                     content: "config",
                     position: (46, 49),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (46, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (47, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "storage-aggregation.conf",
                    position: (47, 25),
                   },
                  ],
                  position: (47, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (47, 51),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (47, 55),
                    },
                    Raw {
                     content: "storageAggregation",
                     position: (47, 62),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (47, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (48, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "storage-schemas.conf",
                    position: (48, 25),
                   },
                  ],
                  position: (48, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (48, 47),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (48, 51),
                    },
                    Raw {
                     content: "storageSchemas",
                     position: (48, 58),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (48, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (49, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "blacklist.conf",
                    position: (49, 25),
                   },
                  ],
                  position: (49, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (49, 41),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (49, 45),
                    },
                    Raw {
                     content: "blacklist",
                     position: (49, 52),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (49, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (50, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "whitelist.conf",
                    position: (50, 25),
                   },
                  ],
                  position: (50, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (50, 41),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (50, 45),
                    },
                    Raw {
                     content: "whitelist",
                     position: (50, 52),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (50, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (51, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "rewrite-rules.conf",
                    position: (51, 25),
                   },
                  ],
                  position: (51, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (51, 45),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (51, 49),
                    },
                    Raw {
                     content: "rewriteRules",
                     position: (51, 56),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (51, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (52, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "relay-rules.conf",
                    position: (52, 25),
                   },
                  ],
                  position: (52, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (52, 43),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (52, 47),
                    },
                    Raw {
                     content: "relayRules",
                     position: (52, 54),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (52, 7),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "writeTextOrNull",
                 position: (53, 8),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "aggregation-rules.conf",
                    position: (53, 25),
                   },
                  ],
                  position: (53, 24),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (53, 49),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "carbon",
                     position: (53, 53),
                    },
                    Raw {
                     content: "aggregationRules",
                     position: (53, 60),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (53, 7),
              },
             ],
             position: (45, 43),
            },
           ],
          },
         },
        ],
        recursive: false,
        position: (43, 29),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "carbonOpts",
        position: (57, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "name",
      },
      definition: With {
       expression: PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (57, 27),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "ids",
           position: (57, 34),
          },
         ],
        },
        default: None,
       },
       target: String {
        parts: [
         Raw {
          content: "--nodaemon --syslog --prefix=",
          position: (58, 1),
         },
         Interpolation {
          expression: Variable {
           identifier: "name",
           position: (58, 36),
          },
         },
         Raw {
          content: " --pidfile /run/",
          position: (58, 41),
         },
         Interpolation {
          expression: Variable {
           identifier: "name",
           position: (58, 59),
          },
         },
         Raw {
          content: "/",
          position: (58, 64),
         },
         Interpolation {
          expression: Variable {
           identifier: "name",
           position: (58, 67),
          },
         },
         Raw {
          content: ".pid ",
          position: (58, 72),
         },
         Interpolation {
          expression: Variable {
           identifier: "name",
           position: (58, 79),
          },
         },
         Raw {
          content: "\n",
          position: (58, 84),
         },
        ],
        position: (57, 39),
       },
       position: (57, 22),
      },
      position: (57, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "carbonEnv",
        position: (61, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "PYTHONPATH",
           position: (62, 5),
          },
         ],
        },
        to: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "cenv",
              position: (63, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (63, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "python3",
                position: (63, 19),
               },
               Raw {
                content: "buildEnv",
                position: (63, 27),
               },
               Raw {
                content: "override",
                position: (63, 36),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "extraLibs",
                   position: (64, 9),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (64, 23),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "python3Packages",
                      position: (64, 28),
                     },
                     Raw {
                      content: "carbon",
                      position: (64, 44),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (64, 21),
                },
               },
              ],
              recursive: false,
              position: (63, 45),
             },
            ],
           },
          },
         ],
         target: String {
          parts: [
           Interpolation {
            expression: Variable {
             identifier: "cenv",
             position: (66, 11),
            },
           },
           Raw {
            content: "/",
            position: (66, 16),
           },
           Interpolation {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (66, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "python3",
                position: (66, 24),
               },
               Raw {
                content: "sitePackages",
                position: (66, 32),
               },
              ],
             },
             default: None,
            },
           },
          ],
          position: (66, 8),
         },
         position: (62, 18),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "GRAPHITE_ROOT",
           position: (67, 5),
          },
         ],
        },
        to: Variable {
         identifier: "dataDir",
         position: (67, 21),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "GRAPHITE_CONF_DIR",
           position: (68, 5),
          },
         ],
        },
        to: Variable {
         identifier: "configDir",
         position: (68, 25),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "GRAPHITE_STORAGE_DIR",
           position: (69, 5),
          },
         ],
        },
        to: Variable {
         identifier: "dataDir",
         position: (69, 28),
        },
       },
      ],
      recursive: false,
      position: (61, 15),
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "imports",
         position: (74, 3),
        },
       ],
      },
      to: List {
       elements: [
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "mkRemovedOptionModule",
           position: (75, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (75, 30),
               },
              ],
              position: (75, 29),
             },
             String {
              parts: [
               Raw {
                content: "graphite",
                position: (75, 41),
               },
              ],
              position: (75, 40),
             },
             String {
              parts: [
               Raw {
                content: "pager",
                position: (75, 52),
               },
              ],
              position: (75, 51),
             },
            ],
            position: (75, 28),
           },
           String {
            parts: [],
            position: (75, 60),
           },
          ],
         },
         position: (75, 5),
        },
       ],
       position: (74, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (80, 3),
        },
        Raw {
         content: "services",
         position: (80, 11),
        },
        Raw {
         content: "graphite",
         position: (80, 20),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "dataDir",
            position: (81, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (81, 15),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (82, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (82, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "path",
                  position: (82, 20),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (83, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "/var/db/graphite",
                 position: (83, 18),
                },
               ],
               position: (83, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (84, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Data directory for graphite.\n",
                 position: (85, 1),
                },
               ],
               position: (84, 21),
              },
             },
            ],
            recursive: false,
            position: (81, 24),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "web",
            position: (89, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (90, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (90, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (91, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable graphite web frontend.",
                    position: (91, 24),
                   },
                  ],
                  position: (91, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (92, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (92, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (93, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (93, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (93, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (90, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "listenAddress",
               position: (96, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (96, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (97, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite web frontend listen address.",
                    position: (97, 24),
                   },
                  ],
                  position: (97, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (98, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "127.0.0.1",
                    position: (98, 20),
                   },
                  ],
                  position: (98, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (99, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (99, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (99, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (96, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "port",
               position: (102, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (102, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (103, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite web frontend port.",
                    position: (103, 24),
                   },
                  ],
                  position: (103, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (104, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 8080,
                  position: (104, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (105, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (105, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (105, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (102, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraConfig",
               position: (108, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (108, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (109, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (109, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (109, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (110, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [],
                  position: (110, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (111, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite webapp settings. See:\n<link xlink:href=\"http://graphite.readthedocs.io/en/latest/config-local-settings.html\"/>\n",
                    position: (112, 1),
                   },
                  ],
                  position: (111, 23),
                 },
                },
               ],
               recursive: false,
               position: (108, 30),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (89, 11),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "api",
            position: (118, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (119, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (119, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (120, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable graphite api. Graphite api is lightweight alternative\nto graphite web, with api and without dashboard. It's advised to use\ngrafana as alternative dashboard and influxdb as alternative to\ngraphite carbon.\n\nFor more information visit\n<link xlink:href=\"https://graphite-api.readthedocs.org/en/latest/\"/>\n",
                    position: (121, 1),
                   },
                  ],
                  position: (120, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (129, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (129, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (130, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (130, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (130, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (119, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "finders",
               position: (133, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (133, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (134, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "List of finder plugins to load.",
                    position: (134, 24),
                   },
                  ],
                  position: (134, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (135, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (135, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (136, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (136, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ pkgs.python3Packages.influxgraph ]",
                      position: (136, 38),
                     },
                    ],
                    position: (136, 37),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (137, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (137, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (137, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "package",
                       position: (137, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (133, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "functions",
               position: (140, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (140, 19),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (141, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "List of functions to load.",
                    position: (141, 24),
                   },
                  ],
                  position: (141, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (142, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "graphite_api.functions.SeriesFunctions",
                      position: (143, 12),
                     },
                    ],
                    position: (143, 11),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "graphite_api.functions.PieFunctions",
                      position: (144, 12),
                     },
                    ],
                    position: (144, 11),
                   },
                  ],
                  position: (142, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (146, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (146, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (146, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (146, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (140, 28),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "listenAddress",
               position: (149, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (149, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (150, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite web service listen address.",
                    position: (150, 24),
                   },
                  ],
                  position: (150, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (151, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "127.0.0.1",
                    position: (151, 20),
                   },
                  ],
                  position: (151, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (152, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (152, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (149, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "port",
               position: (155, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (155, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (156, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite api service port.",
                    position: (156, 24),
                   },
                  ],
                  position: (156, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (157, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 8080,
                  position: (157, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (158, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (158, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (155, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "package",
               position: (161, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (161, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (162, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Package to use for graphite api.",
                    position: (162, 24),
                   },
                  ],
                  position: (162, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (163, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (163, 19),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "python3Packages",
                     position: (163, 24),
                    },
                    Raw {
                     content: "graphite_api",
                     position: (163, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (164, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (164, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.python3Packages.graphite_api",
                      position: (164, 42),
                     },
                    ],
                    position: (164, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (165, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (165, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "package",
                     position: (165, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (161, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraConfig",
               position: (168, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (168, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (169, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Extra configuration for graphite api.",
                    position: (169, 24),
                   },
                  ],
                  position: (169, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (170, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "whisper:\n  directories:\n      - ",
                    position: (171, 1),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "dataDir",
                     position: (173, 21),
                    },
                   },
                   Raw {
                    content: "/whisper\n",
                    position: (173, 29),
                   },
                  ],
                  position: (170, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (175, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (175, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "",
                      position: (176, 1),
                     },
                     Raw {
                      content: "''",
                      position: (176, 11),
                     },
                     Raw {
                      content: "\n  whisper:\n    directories:\n      - ",
                      position: (176, 14),
                     },
                     Raw {
                      content: "$",
                      position: (179, 19),
                     },
                     Raw {
                      content: "{config.",
                      position: (179, 22),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (179, 32),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (179, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/whisper\n",
                      position: (179, 44),
                     },
                     Raw {
                      content: "''",
                      position: (180, 11),
                     },
                     Raw {
                      content: "\n",
                      position: (180, 14),
                     },
                    ],
                    position: (175, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (182, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "allowed_origins:\n  - dashboard.example.com\ncheat_times: true\ninfluxdb:\n  host: localhost\n  port: 8086\n  user: influxdb\n  pass: influxdb\n  db: metrics\ncache:\n  CACHE_TYPE: 'filesystem'\n  CACHE_DIR: '/tmp/graphite-api-cache'\n",
                    position: (183, 1),
                   },
                  ],
                  position: (182, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (196, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (196, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "lines",
                     position: (196, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (168, 30),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (118, 11),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "carbon",
            position: (200, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "config",
               position: (201, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (201, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (202, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Content of carbon configuration file.",
                    position: (202, 24),
                   },
                  ],
                  position: (202, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (203, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "[cache]\n# Listen on localhost by default for security reasons\nUDP_RECEIVER_INTERFACE = 127.0.0.1\nPICKLE_RECEIVER_INTERFACE = 127.0.0.1\nLINE_RECEIVER_INTERFACE = 127.0.0.1\nCACHE_QUERY_INTERFACE = 127.0.0.1\n# Do not log every update\nLOG_UPDATES = False\nLOG_CACHE_HITS = False\n",
                    position: (204, 1),
                   },
                  ],
                  position: (203, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (214, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (214, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (214, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (201, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enableCache",
               position: (217, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (217, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (218, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon cache, the graphite storage daemon.",
                    position: (218, 24),
                   },
                  ],
                  position: (218, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (219, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (219, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (220, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (220, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (220, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (217, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "storageAggregation",
               position: (223, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (223, 28),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (224, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Defines how to aggregate data to lower-precision retentions.",
                    position: (224, 24),
                   },
                  ],
                  position: (224, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (225, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (225, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (226, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (226, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (226, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (226, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (226, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (227, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "[all_min]\npattern = \\.min$\nxFilesFactor = 0.1\naggregationMethod = min\n",
                    position: (228, 1),
                   },
                  ],
                  position: (227, 19),
                 },
                },
               ],
               recursive: false,
               position: (223, 37),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "storageSchemas",
               position: (235, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (235, 24),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (236, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Defines retention rates for storing metrics.",
                    position: (236, 24),
                   },
                  ],
                  position: (236, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (237, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [],
                  position: (237, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (238, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (238, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (238, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (238, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (238, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (239, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "[apache_busyWorkers]\npattern = ^servers\\.www.*\\.workers\\.busyWorkers$\nretentions = 15s:7d,1m:21d,15m:5y\n",
                    position: (240, 1),
                   },
                  ],
                  position: (239, 19),
                 },
                },
               ],
               recursive: false,
               position: (235, 33),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "blacklist",
               position: (246, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (246, 19),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (247, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Any metrics received which match one of the experssions will be dropped.",
                    position: (247, 24),
                   },
                  ],
                  position: (247, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (248, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (248, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (249, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (249, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (249, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (249, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (249, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (250, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "^some\\.noisy\\.metric\\.prefix\\..*",
                    position: (250, 20),
                   },
                  ],
                  position: (250, 19),
                 },
                },
               ],
               recursive: false,
               position: (246, 28),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "whitelist",
               position: (253, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (253, 19),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (254, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Only metrics received which match one of the experssions will be persisted.",
                    position: (254, 24),
                   },
                  ],
                  position: (254, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (255, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (255, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (256, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (256, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (256, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (256, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (256, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (257, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: ".*",
                    position: (257, 20),
                   },
                  ],
                  position: (257, 19),
                 },
                },
               ],
               recursive: false,
               position: (253, 28),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "rewriteRules",
               position: (260, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (260, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (261, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Regular expression patterns that can be used to rewrite metric names\nin a search and replace fashion.\n",
                    position: (262, 1),
                   },
                  ],
                  position: (261, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (265, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (265, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (266, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (266, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (266, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (266, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (266, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (267, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "[post]\n_sum$ =\n_avg$ =\n",
                    position: (268, 1),
                   },
                  ],
                  position: (267, 19),
                 },
                },
               ],
               recursive: false,
               position: (260, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enableRelay",
               position: (274, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (274, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (275, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon relay, the carbon replication and sharding service.",
                    position: (275, 24),
                   },
                  ],
                  position: (275, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (276, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (276, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (277, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (277, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (277, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (274, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "relayRules",
               position: (280, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (280, 20),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (281, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Relay rules are used to send certain metrics to a certain backend.",
                    position: (281, 24),
                   },
                  ],
                  position: (281, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (282, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (282, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (283, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (283, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (283, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (283, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (283, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (284, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "[example]\npattern = ^mydata\\.foo\\..+\nservers = 10.1.2.3, 10.1.2.4:2004, myserver.mydomain.com\n",
                    position: (285, 1),
                   },
                  ],
                  position: (284, 19),
                 },
                },
               ],
               recursive: false,
               position: (280, 29),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enableAggregator",
               position: (291, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (291, 26),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (292, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon aggregator, the carbon buffering service.",
                    position: (292, 24),
                   },
                  ],
                  position: (292, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (293, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (293, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (294, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (294, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (294, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (291, 35),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "aggregationRules",
               position: (297, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (297, 26),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (298, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Defines if and how received metrics will be aggregated.",
                    position: (298, 24),
                   },
                  ],
                  position: (298, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (299, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (299, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (300, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (300, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (300, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (300, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (300, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (301, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "<env>.applications.<app>.all.requests (60) = sum <env>.applications.<app>.*.requests\n<env>.applications.<app>.all.latency (60) = avg <env>.applications.<app>.*.latency\n",
                    position: (302, 1),
                   },
                  ],
                  position: (301, 19),
                 },
                },
               ],
               recursive: false,
               position: (297, 35),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (200, 14),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "seyren",
            position: (308, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (309, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (309, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (310, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable seyren service.",
                    position: (310, 24),
                   },
                  ],
                  position: (310, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (311, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (311, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (312, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (312, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (312, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (309, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "port",
               position: (315, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (315, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (316, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Seyren listening port.",
                    position: (316, 24),
                   },
                  ],
                  position: (316, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (317, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 8081,
                  position: (317, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (318, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (318, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (318, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (315, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "seyrenUrl",
               position: (321, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (321, 19),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (322, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "http://localhost:",
                    position: (322, 20),
                   },
                   Interpolation {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (322, 39),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (322, 48),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "seyren",
                          position: (322, 52),
                         },
                         Raw {
                          content: "port",
                          position: (322, 59),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "/",
                    position: (322, 64),
                   },
                  ],
                  position: (322, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (323, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (323, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"http://localhost:",
                      position: (323, 43),
                     },
                     Raw {
                      content: "$",
                      position: (323, 61),
                     },
                     Raw {
                      content: "{toString config.",
                      position: (323, 64),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (323, 83),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "seyren",
                          position: (323, 87),
                         },
                         Raw {
                          content: "port",
                          position: (323, 94),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/\"",
                      position: (323, 99),
                     },
                    ],
                    position: (323, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (324, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Host where seyren is accessible.",
                    position: (324, 24),
                   },
                  ],
                  position: (324, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (325, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (325, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (325, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (321, 28),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "graphiteUrl",
               position: (328, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (328, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (329, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "http://",
                    position: (329, 20),
                   },
                   Interpolation {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (329, 29),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "web",
                        position: (329, 33),
                       },
                       Raw {
                        content: "listenAddress",
                        position: (329, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: ":",
                    position: (329, 51),
                   },
                   Interpolation {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (329, 54),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (329, 63),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "web",
                          position: (329, 67),
                         },
                         Raw {
                          content: "port",
                          position: (329, 71),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                  ],
                  position: (329, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (330, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (330, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"http://",
                      position: (330, 43),
                     },
                     Raw {
                      content: "$",
                      position: (330, 51),
                     },
                     Raw {
                      content: "{config.",
                      position: (330, 54),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (330, 64),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "web",
                          position: (330, 68),
                         },
                         Raw {
                          content: "listenAddress",
                          position: (330, 72),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}:",
                      position: (330, 86),
                     },
                     Raw {
                      content: "$",
                      position: (330, 88),
                     },
                     Raw {
                      content: "{toString config.",
                      position: (330, 91),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (330, 110),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "web",
                          position: (330, 114),
                         },
                         Raw {
                          content: "port",
                          position: (330, 118),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}\"",
                      position: (330, 123),
                     },
                    ],
                    position: (330, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (331, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Host where graphite service runs.",
                    position: (331, 24),
                   },
                  ],
                  position: (331, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (332, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (332, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (332, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (328, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "mongoUrl",
               position: (335, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (335, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (336, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "mongodb://",
                    position: (336, 20),
                   },
                   Interpolation {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (336, 32),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "services",
                        position: (336, 39),
                       },
                       Raw {
                        content: "mongodb",
                        position: (336, 48),
                       },
                       Raw {
                        content: "bind_ip",
                        position: (336, 56),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: ":27017/seyren",
                    position: (336, 64),
                   },
                  ],
                  position: (336, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (337, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (337, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"mongodb://",
                      position: (337, 43),
                     },
                     Raw {
                      content: "$",
                      position: (337, 54),
                     },
                     Raw {
                      content: "{config.services.mongodb.bind_ip}:27017/seyren\"",
                      position: (337, 57),
                     },
                    ],
                    position: (337, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (338, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Mongodb connection string.",
                    position: (338, 24),
                   },
                  ],
                  position: (338, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (339, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (339, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (339, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (335, 27),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraConfig",
               position: (342, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (342, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (343, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (343, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (344, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Extra seyren configuration. See\n<link xlink:href='https://github.com/scobal/seyren#config' />\n",
                    position: (345, 1),
                   },
                  ],
                  position: (344, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (348, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (348, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "attrsOf",
                      position: (348, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (348, 30),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (348, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (349, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (349, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  GRAPHITE_USERNAME = \"user\";\n  GRAPHITE_PASSWORD = \"pass\";\n}\n",
                      position: (350, 1),
                     },
                    ],
                    position: (349, 37),
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (342, 30),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (308, 14),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "beacon",
            position: (358, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (359, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (359, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "graphite beacon",
                 position: (359, 32),
                },
               ],
               position: (359, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "config",
               position: (361, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (361, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (362, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Graphite beacon configuration.",
                    position: (362, 24),
                   },
                  ],
                  position: (362, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (363, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (363, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (364, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (364, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "attrs",
                     position: (364, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               recursive: false,
               position: (361, 25),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (358, 14),
         },
        },
       ],
       recursive: false,
       position: (80, 31),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (371, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "mkMerge",
        position: (371, 12),
       },
       arguments: [
        List {
         elements: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (372, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (372, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "carbon",
                 position: (372, 15),
                },
                Raw {
                 content: "enableCache",
                 position: (372, 22),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (373, 7),
                  },
                  Raw {
                   content: "services",
                   position: (373, 15),
                  },
                  Raw {
                   content: "carbonCache",
                   position: (373, 24),
                  },
                 ],
                },
                to: LetIn {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "name",
                      position: (373, 42),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "carbon-cache",
                      position: (373, 50),
                     },
                    ],
                    position: (373, 49),
                   },
                  },
                 ],
                 target: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (374, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Graphite Data Storage Backend",
                       position: (374, 24),
                      },
                     ],
                     position: (374, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "wantedBy",
                       position: (375, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "multi-user.target",
                         position: (375, 23),
                        },
                       ],
                       position: (375, 22),
                      },
                     ],
                     position: (375, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "after",
                       position: (376, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "network.target",
                         position: (376, 20),
                        },
                       ],
                       position: (376, 19),
                      },
                     ],
                     position: (376, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "environment",
                       position: (377, 9),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "carbonEnv",
                     position: (377, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "serviceConfig",
                       position: (378, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "RuntimeDirectory",
                          position: (379, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "name",
                        position: (379, 30),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "ExecStart",
                          position: (380, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (380, 26),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3Packages",
                              position: (380, 31),
                             },
                             Raw {
                              content: "twisted",
                              position: (380, 47),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/bin/twistd ",
                          position: (380, 55),
                         },
                         Interpolation {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "carbonOpts",
                            position: (380, 69),
                           },
                           arguments: [
                            Variable {
                             identifier: "name",
                             position: (380, 80),
                            },
                           ],
                          },
                         },
                        ],
                        position: (380, 23),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "User",
                          position: (381, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (381, 19),
                         },
                        ],
                        position: (381, 18),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "Group",
                          position: (382, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (382, 20),
                         },
                        ],
                        position: (382, 19),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PermissionsStartOnly",
                          position: (383, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "true",
                        position: (383, 34),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PIDFile",
                          position: (384, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "/run/",
                          position: (384, 20),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (384, 27),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (384, 32),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (384, 35),
                          },
                         },
                         Raw {
                          content: ".pid",
                          position: (384, 40),
                         },
                        ],
                        position: (384, 19),
                       },
                      },
                     ],
                     recursive: false,
                     position: (378, 25),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "preStart",
                       position: (386, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "install -dm0700 -o graphite -g graphite ",
                       position: (387, 1),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (387, 53),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "dataDir",
                           position: (387, 57),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\ninstall -dm0700 -o graphite -g graphite ",
                       position: (387, 65),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (388, 53),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "dataDir",
                           position: (388, 57),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/whisper\n",
                       position: (388, 65),
                      },
                     ],
                     position: (386, 20),
                    },
                   },
                  ],
                  recursive: false,
                  position: (373, 68),
                 },
                 position: (373, 38),
                },
               },
              ],
              recursive: false,
              position: (372, 34),
             },
            ],
           },
           position: (372, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (393, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (393, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "carbon",
                 position: (393, 15),
                },
                Raw {
                 content: "enableAggregator",
                 position: (393, 22),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (394, 7),
                  },
                  Raw {
                   content: "services",
                   position: (394, 15),
                  },
                  Raw {
                   content: "carbonAggregator",
                   position: (394, 24),
                  },
                 ],
                },
                to: LetIn {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "name",
                      position: (394, 47),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "carbon-aggregator",
                      position: (394, 55),
                     },
                    ],
                    position: (394, 54),
                   },
                  },
                 ],
                 target: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "enable",
                       position: (395, 9),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (395, 18),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "carbon",
                        position: (395, 22),
                       },
                       Raw {
                        content: "enableAggregator",
                        position: (395, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (396, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Carbon Data Aggregator",
                       position: (396, 24),
                      },
                     ],
                     position: (396, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "wantedBy",
                       position: (397, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "multi-user.target",
                         position: (397, 23),
                        },
                       ],
                       position: (397, 22),
                      },
                     ],
                     position: (397, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "after",
                       position: (398, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "network.target",
                         position: (398, 20),
                        },
                       ],
                       position: (398, 19),
                      },
                     ],
                     position: (398, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "environment",
                       position: (399, 9),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "carbonEnv",
                     position: (399, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "serviceConfig",
                       position: (400, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "RuntimeDirectory",
                          position: (401, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "name",
                        position: (401, 30),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "ExecStart",
                          position: (402, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (402, 26),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3Packages",
                              position: (402, 31),
                             },
                             Raw {
                              content: "twisted",
                              position: (402, 47),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/bin/twistd ",
                          position: (402, 55),
                         },
                         Interpolation {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "carbonOpts",
                            position: (402, 69),
                           },
                           arguments: [
                            Variable {
                             identifier: "name",
                             position: (402, 80),
                            },
                           ],
                          },
                         },
                        ],
                        position: (402, 23),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "User",
                          position: (403, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (403, 19),
                         },
                        ],
                        position: (403, 18),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "Group",
                          position: (404, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (404, 20),
                         },
                        ],
                        position: (404, 19),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PIDFile",
                          position: (405, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "/run/",
                          position: (405, 20),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (405, 27),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (405, 32),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (405, 35),
                          },
                         },
                         Raw {
                          content: ".pid",
                          position: (405, 40),
                         },
                        ],
                        position: (405, 19),
                       },
                      },
                     ],
                     recursive: false,
                     position: (400, 25),
                    },
                   },
                  ],
                  recursive: false,
                  position: (394, 78),
                 },
                 position: (394, 43),
                },
               },
              ],
              recursive: false,
              position: (393, 39),
             },
            ],
           },
           position: (393, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (410, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (410, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "carbon",
                 position: (410, 15),
                },
                Raw {
                 content: "enableRelay",
                 position: (410, 22),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (411, 7),
                  },
                  Raw {
                   content: "services",
                   position: (411, 15),
                  },
                  Raw {
                   content: "carbonRelay",
                   position: (411, 24),
                  },
                 ],
                },
                to: LetIn {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "name",
                      position: (411, 42),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "carbon-relay",
                      position: (411, 50),
                     },
                    ],
                    position: (411, 49),
                   },
                  },
                 ],
                 target: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (412, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Carbon Data Relay",
                       position: (412, 24),
                      },
                     ],
                     position: (412, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "wantedBy",
                       position: (413, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "multi-user.target",
                         position: (413, 23),
                        },
                       ],
                       position: (413, 22),
                      },
                     ],
                     position: (413, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "after",
                       position: (414, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "network.target",
                         position: (414, 20),
                        },
                       ],
                       position: (414, 19),
                      },
                     ],
                     position: (414, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "environment",
                       position: (415, 9),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "carbonEnv",
                     position: (415, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "serviceConfig",
                       position: (416, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "RuntimeDirectory",
                          position: (417, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "name",
                        position: (417, 30),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "ExecStart",
                          position: (418, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (418, 26),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3Packages",
                              position: (418, 31),
                             },
                             Raw {
                              content: "twisted",
                              position: (418, 47),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/bin/twistd ",
                          position: (418, 55),
                         },
                         Interpolation {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "carbonOpts",
                            position: (418, 69),
                           },
                           arguments: [
                            Variable {
                             identifier: "name",
                             position: (418, 80),
                            },
                           ],
                          },
                         },
                        ],
                        position: (418, 23),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "User",
                          position: (419, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (419, 19),
                         },
                        ],
                        position: (419, 18),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "Group",
                          position: (420, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (420, 20),
                         },
                        ],
                        position: (420, 19),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PIDFile",
                          position: (421, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "/run/",
                          position: (421, 20),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (421, 27),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (421, 32),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "name",
                           position: (421, 35),
                          },
                         },
                         Raw {
                          content: ".pid",
                          position: (421, 40),
                         },
                        ],
                        position: (421, 19),
                       },
                      },
                     ],
                     recursive: false,
                     position: (416, 25),
                    },
                   },
                  ],
                  recursive: false,
                  position: (411, 68),
                 },
                 position: (411, 38),
                },
               },
              ],
              recursive: false,
              position: (410, 34),
             },
            ],
           },
           position: (410, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (426, 6),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: LogicalOr,
               operands: [
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (426, 12),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "carbon",
                      position: (426, 16),
                     },
                     Raw {
                      content: "enableCache",
                      position: (426, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (426, 38),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "carbon",
                      position: (426, 42),
                     },
                     Raw {
                      content: "enableAggregator",
                      position: (426, 49),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (426, 35),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (426, 69),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "carbon",
                    position: (426, 73),
                   },
                   Raw {
                    content: "enableRelay",
                    position: (426, 80),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (426, 66),
              },
              position: (426, 11),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "environment",
                   position: (427, 7),
                  },
                  Raw {
                   content: "systemPackages",
                   position: (427, 19),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (428, 9),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "python3Packages",
                      position: (428, 14),
                     },
                     Raw {
                      content: "carbon",
                      position: (428, 30),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (427, 36),
                },
               },
              ],
              recursive: false,
              position: (426, 93),
             },
            ],
           },
           position: (426, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (432, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (432, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "web",
                 position: (432, 15),
                },
                Raw {
                 content: "enable",
                 position: (432, 19),
                },
               ],
              },
              default: None,
             },
             Parentheses {
              expression: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "systemd",
                    position: (433, 7),
                   },
                   Raw {
                    content: "services",
                    position: (433, 15),
                   },
                   Raw {
                    content: "graphiteWeb",
                    position: (433, 24),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (434, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Graphite Web Interface",
                       position: (434, 24),
                      },
                     ],
                     position: (434, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "wantedBy",
                       position: (435, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "multi-user.target",
                         position: (435, 23),
                        },
                       ],
                       position: (435, 22),
                      },
                     ],
                     position: (435, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "after",
                       position: (436, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "network.target",
                         position: (436, 20),
                        },
                       ],
                       position: (436, 19),
                      },
                     ],
                     position: (436, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "path",
                       position: (437, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (437, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "perl",
                          position: (437, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (437, 16),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "environment",
                       position: (438, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PYTHONPATH",
                          position: (439, 11),
                         },
                        ],
                       },
                       to: LetIn {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "penv",
                             position: (440, 15),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (440, 22),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "python3",
                               position: (440, 27),
                              },
                              Raw {
                               content: "buildEnv",
                               position: (440, 35),
                              },
                              Raw {
                               content: "override",
                               position: (440, 44),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "extraLibs",
                                  position: (441, 17),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (442, 19),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "python3Packages",
                                     position: (442, 24),
                                    },
                                    Raw {
                                     content: "graphite-web",
                                     position: (442, 40),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                                position: (441, 29),
                               },
                              },
                             ],
                             recursive: false,
                             position: (440, 53),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "penvPack",
                             position: (445, 15),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: Variable {
                              identifier: "penv",
                              position: (445, 29),
                             },
                            },
                            Raw {
                             content: "/",
                             position: (445, 34),
                            },
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (445, 37),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "python3",
                                 position: (445, 42),
                                },
                                Raw {
                                 content: "sitePackages",
                                 position: (445, 50),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                           ],
                           position: (445, 26),
                          },
                         },
                        ],
                        target: FunctionApplication {
                         function: Variable {
                          identifier: "concatStringsSep",
                          position: (446, 16),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: ":",
                             position: (446, 34),
                            },
                           ],
                           position: (446, 33),
                          },
                          List {
                           elements: [
                            String {
                             parts: [
                              Interpolation {
                               expression: Variable {
                                identifier: "graphiteLocalSettingsDir",
                                position: (447, 21),
                               },
                              },
                             ],
                             position: (447, 18),
                            },
                            String {
                             parts: [
                              Interpolation {
                               expression: Variable {
                                identifier: "penvPack",
                                position: (448, 21),
                               },
                              },
                             ],
                             position: (448, 18),
                            },
                            String {
                             parts: [
                              Interpolation {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (450, 21),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "python3Packages",
                                   position: (450, 26),
                                  },
                                  Raw {
                                   content: "pycairo",
                                   position: (450, 42),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "/",
                               position: (450, 50),
                              },
                              Interpolation {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (450, 53),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "python3",
                                   position: (450, 58),
                                  },
                                  Raw {
                                   content: "sitePackages",
                                   position: (450, 66),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                             ],
                             position: (450, 18),
                            },
                           ],
                           position: (446, 37),
                          },
                         ],
                        },
                        position: (439, 24),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "DJANGO_SETTINGS_MODULE",
                          position: (452, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite.settings",
                          position: (452, 37),
                         },
                        ],
                        position: (452, 36),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "GRAPHITE_SETTINGS_MODULE",
                          position: (453, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite_local_settings",
                          position: (453, 39),
                         },
                        ],
                        position: (453, 38),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "GRAPHITE_CONF_DIR",
                          position: (454, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "configDir",
                        position: (454, 31),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "GRAPHITE_STORAGE_DIR",
                          position: (455, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "dataDir",
                        position: (455, 34),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "LD_LIBRARY_PATH",
                          position: (456, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (456, 32),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "cairo",
                              position: (456, 37),
                             },
                             Raw {
                              content: "out",
                              position: (456, 43),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/lib",
                          position: (456, 47),
                         },
                        ],
                        position: (456, 29),
                       },
                      },
                     ],
                     recursive: false,
                     position: (438, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "serviceConfig",
                       position: (458, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "ExecStart",
                          position: (459, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "",
                          position: (460, 1),
                         },
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (460, 15),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3Packages",
                              position: (460, 20),
                             },
                             Raw {
                              content: "waitress-django",
                              position: (460, 36),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/bin/waitress-serve-django \\\n  --host=",
                          position: (460, 52),
                         },
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (461, 24),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "web",
                              position: (461, 28),
                             },
                             Raw {
                              content: "listenAddress",
                              position: (461, 32),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: " --port=",
                          position: (461, 46),
                         },
                         Interpolation {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (461, 56),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (461, 65),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "web",
                                position: (461, 69),
                               },
                               Raw {
                                content: "port",
                                position: (461, 73),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "\n",
                          position: (461, 78),
                         },
                        ],
                        position: (459, 23),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "User",
                          position: (463, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (463, 19),
                         },
                        ],
                        position: (463, 18),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "Group",
                          position: (464, 11),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "graphite",
                          position: (464, 20),
                         },
                        ],
                        position: (464, 19),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "PermissionsStartOnly",
                          position: (465, 11),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "true",
                        position: (465, 34),
                       },
                      },
                     ],
                     recursive: false,
                     position: (458, 25),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "preStart",
                       position: (467, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "if ! test -e ",
                       position: (468, 1),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (468, 26),
                       },
                      },
                      Raw {
                       content: "/db-created; then\n  mkdir -p ",
                       position: (468, 34),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (469, 24),
                       },
                      },
                      Raw {
                       content: "/{whisper/,log/webapp/}\n  chmod 0700 ",
                       position: (469, 32),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (470, 26),
                       },
                      },
                      Raw {
                       content: "/{whisper/,log/webapp/}\n\n  ",
                       position: (470, 34),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (472, 15),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "python3Packages",
                           position: (472, 20),
                          },
                          Raw {
                           content: "django",
                           position: (472, 36),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/bin/django-admin.py migrate --noinput\n\n  chown -R graphite:graphite ",
                       position: (472, 43),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (474, 42),
                       },
                      },
                      Raw {
                       content: "\n\n  touch ",
                       position: (474, 50),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (476, 21),
                       },
                      },
                      Raw {
                       content: "/db-created\nfi\n\n# Only collect static files when graphite_web changes.\nif ! [ \"",
                       position: (476, 29),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (480, 21),
                       },
                      },
                      Raw {
                       content: "/current_graphite_web\" -ef \"",
                       position: (480, 29),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (480, 59),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "python3Packages",
                           position: (480, 64),
                          },
                          Raw {
                           content: "graphite-web",
                           position: (480, 80),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\" ]; then\n  mkdir -p ",
                       position: (480, 93),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "staticDir",
                        position: (481, 24),
                       },
                      },
                      Raw {
                       content: "\n  ",
                       position: (481, 34),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (482, 15),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "python3Packages",
                           position: (482, 20),
                          },
                          Raw {
                           content: "django",
                           position: (482, 36),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/bin/django-admin.py collectstatic  --noinput --clear\n  chown -R graphite:graphite ",
                       position: (482, 43),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "staticDir",
                        position: (483, 42),
                       },
                      },
                      Raw {
                       content: "\n  ln -sfT \"",
                       position: (483, 52),
                      },
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (484, 24),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "python3Packages",
                           position: (484, 29),
                          },
                          Raw {
                           content: "graphite-web",
                           position: (484, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "\" \"",
                       position: (484, 58),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (484, 63),
                       },
                      },
                      Raw {
                       content: "/current_graphite_web\"\nfi\n",
                       position: (484, 71),
                      },
                     ],
                     position: (467, 20),
                    },
                   },
                  ],
                  recursive: false,
                  position: (433, 38),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "environment",
                    position: (489, 7),
                   },
                   Raw {
                    content: "systemPackages",
                    position: (489, 19),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (489, 38),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "python3Packages",
                       position: (489, 43),
                      },
                      Raw {
                       content: "graphite-web",
                       position: (489, 59),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                  position: (489, 36),
                 },
                },
               ],
               recursive: false,
               position: (432, 27),
              },
              position: (432, 26),
             },
            ],
           },
           position: (432, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (492, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (492, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "api",
                 position: (492, 15),
                },
                Raw {
                 content: "enable",
                 position: (492, 19),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (493, 7),
                  },
                  Raw {
                   content: "services",
                   position: (493, 15),
                  },
                  Raw {
                   content: "graphiteApi",
                   position: (493, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (494, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Graphite Api Interface",
                      position: (494, 24),
                     },
                    ],
                    position: (494, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (495, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (495, 23),
                       },
                      ],
                      position: (495, 22),
                     },
                    ],
                    position: (495, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "after",
                      position: (496, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (496, 20),
                       },
                      ],
                      position: (496, 19),
                     },
                    ],
                    position: (496, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "environment",
                      position: (497, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PYTHONPATH",
                         position: (498, 11),
                        },
                       ],
                      },
                      to: LetIn {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "aenv",
                            position: (499, 15),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (499, 22),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3",
                              position: (499, 27),
                             },
                             Raw {
                              content: "buildEnv",
                              position: (499, 35),
                             },
                             Raw {
                              content: "override",
                              position: (499, 44),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "extraLibs",
                                 position: (500, 17),
                                },
                               ],
                              },
                              to: BinaryOperation {
                               operator: Concatenation,
                               operands: [
                                List {
                                 elements: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (500, 31),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "api",
                                      position: (500, 35),
                                     },
                                     Raw {
                                      content: "package",
                                      position: (500, 39),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "pkgs",
                                    position: (500, 47),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "cairo",
                                      position: (500, 52),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "pkgs",
                                    position: (500, 58),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "python3Packages",
                                      position: (500, 63),
                                     },
                                     Raw {
                                      content: "cffi",
                                      position: (500, 79),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                 position: (500, 29),
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (500, 89),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "api",
                                    position: (500, 93),
                                   },
                                   Raw {
                                    content: "finders",
                                    position: (500, 97),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                               position: (500, 86),
                              },
                             },
                            ],
                            recursive: false,
                            position: (499, 53),
                           },
                          ],
                         },
                        },
                       ],
                       target: String {
                        parts: [
                         Interpolation {
                          expression: Variable {
                           identifier: "aenv",
                           position: (502, 19),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (502, 24),
                         },
                         Interpolation {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (502, 27),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "python3",
                              position: (502, 32),
                             },
                             Raw {
                              content: "sitePackages",
                              position: (502, 40),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                        ],
                        position: (502, 16),
                       },
                       position: (498, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "GRAPHITE_API_CONFIG",
                         position: (503, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "graphiteApiConfig",
                       position: (503, 33),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "LD_LIBRARY_PATH",
                         position: (504, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (504, 32),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "cairo",
                             position: (504, 37),
                            },
                            Raw {
                             content: "out",
                             position: (504, 43),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib",
                         position: (504, 47),
                        },
                       ],
                       position: (504, 29),
                      },
                     },
                    ],
                    recursive: false,
                    position: (497, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (506, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "ExecStart",
                         position: (507, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "",
                         position: (508, 1),
                        },
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (508, 15),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "python3Packages",
                             position: (508, 20),
                            },
                            Raw {
                             content: "waitress",
                             position: (508, 36),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/waitress-serve \\\n--host=",
                         position: (508, 45),
                        },
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (509, 22),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "api",
                             position: (509, 26),
                            },
                            Raw {
                             content: "listenAddress",
                             position: (509, 30),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: " --port=",
                         position: (509, 44),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (509, 54),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (509, 63),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "api",
                               position: (509, 67),
                              },
                              Raw {
                               content: "port",
                               position: (509, 71),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: " \\\ngraphite_api.app:app\n",
                         position: (509, 76),
                        },
                       ],
                       position: (507, 23),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "User",
                         position: (512, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (512, 19),
                        },
                       ],
                       position: (512, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "Group",
                         position: (513, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (513, 20),
                        },
                       ],
                       position: (513, 19),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PermissionsStartOnly",
                         position: (514, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (514, 34),
                      },
                     },
                    ],
                    recursive: false,
                    position: (506, 25),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "preStart",
                      position: (516, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "if ! test -e ",
                      position: (517, 1),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (517, 26),
                      },
                     },
                     Raw {
                      content: "/db-created; then\n  mkdir -p ",
                      position: (517, 34),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (518, 24),
                      },
                     },
                     Raw {
                      content: "/cache/\n  chmod 0700 ",
                      position: (518, 32),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (519, 26),
                      },
                     },
                     Raw {
                      content: "/cache/\n\n  chown graphite:graphite ",
                      position: (519, 34),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (521, 39),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (521, 43),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\n  chown -R graphite:graphite ",
                      position: (521, 51),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (522, 42),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (522, 46),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/cache\n\n  touch ",
                      position: (522, 54),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (524, 21),
                      },
                     },
                     Raw {
                      content: "/db-created\nfi\n",
                      position: (524, 29),
                     },
                    ],
                    position: (516, 20),
                   },
                  },
                 ],
                 recursive: false,
                 position: (493, 38),
                },
               },
              ],
              recursive: false,
              position: (492, 26),
             },
            ],
           },
           position: (492, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (530, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (530, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "seyren",
                 position: (530, 15),
                },
                Raw {
                 content: "enable",
                 position: (530, 22),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (531, 7),
                  },
                  Raw {
                   content: "services",
                   position: (531, 15),
                  },
                  Raw {
                   content: "seyren",
                   position: (531, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (532, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Graphite Alerting Dashboard",
                      position: (532, 24),
                     },
                    ],
                    position: (532, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (533, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (533, 23),
                       },
                      ],
                      position: (533, 22),
                     },
                    ],
                    position: (533, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "after",
                      position: (534, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (534, 20),
                       },
                      ],
                      position: (534, 19),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mongodb.service",
                        position: (534, 37),
                       },
                      ],
                      position: (534, 36),
                     },
                    ],
                    position: (534, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "environment",
                      position: (535, 9),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "seyrenConfig",
                    position: (535, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (536, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "ExecStart",
                         position: (537, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (537, 26),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "seyren",
                             position: (537, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/seyren -httpPort ",
                         position: (537, 38),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (537, 62),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (537, 71),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "seyren",
                               position: (537, 75),
                              },
                              Raw {
                               content: "port",
                               position: (537, 82),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                       ],
                       position: (537, 23),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "WorkingDirectory",
                         position: (538, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "dataDir",
                       position: (538, 30),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "User",
                         position: (539, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (539, 19),
                        },
                       ],
                       position: (539, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "Group",
                         position: (540, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (540, 20),
                        },
                       ],
                       position: (540, 19),
                      },
                     },
                    ],
                    recursive: false,
                    position: (536, 25),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "preStart",
                      position: (542, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "if ! test -e ",
                      position: (543, 1),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (543, 26),
                      },
                     },
                     Raw {
                      content: "/db-created; then\n  mkdir -p ",
                      position: (543, 34),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (544, 24),
                      },
                     },
                     Raw {
                      content: "\n  chown graphite:graphite ",
                      position: (544, 32),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (545, 39),
                      },
                     },
                     Raw {
                      content: "\nfi\n",
                      position: (545, 47),
                     },
                    ],
                    position: (542, 20),
                   },
                  },
                 ],
                 recursive: false,
                 position: (531, 33),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "services",
                   position: (550, 7),
                  },
                  Raw {
                   content: "mongodb",
                   position: (550, 16),
                  },
                  Raw {
                   content: "enable",
                   position: (550, 24),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (550, 33),
                 },
                 arguments: [
                  Variable {
                   identifier: "true",
                   position: (550, 43),
                  },
                 ],
                },
               },
              ],
              recursive: false,
              position: (530, 29),
             },
            ],
           },
           position: (530, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (553, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (553, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "beacon",
                 position: (553, 15),
                },
                Raw {
                 content: "enable",
                 position: (553, 22),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (554, 7),
                  },
                  Raw {
                   content: "services",
                   position: (554, 15),
                  },
                  Raw {
                   content: "graphite-beacon",
                   position: (554, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (555, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Grpahite Beacon Alerting Daemon",
                      position: (555, 24),
                     },
                    ],
                    position: (555, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (556, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (556, 23),
                       },
                      ],
                      position: (556, 22),
                     },
                    ],
                    position: (556, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (557, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "ExecStart",
                         position: (558, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "",
                         position: (559, 1),
                        },
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (559, 15),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "python3Packages",
                             position: (559, 20),
                            },
                            Raw {
                             content: "graphite_beacon",
                             position: (559, 36),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/graphite-beacon \\\n  --config=",
                         position: (559, 52),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (560, 26),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "writeText",
                              position: (560, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "graphite-beacon.json",
                              position: (560, 42),
                             },
                            ],
                            position: (560, 41),
                           },
                           Parentheses {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (560, 65),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "toJSON",
                                 position: (560, 74),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (560, 81),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "beacon",
                                  position: (560, 85),
                                 },
                                 Raw {
                                  content: "config",
                                  position: (560, 92),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                            position: (560, 64),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (560, 100),
                        },
                       ],
                       position: (558, 23),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "User",
                         position: (562, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (562, 19),
                        },
                       ],
                       position: (562, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "Group",
                         position: (563, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (563, 20),
                        },
                       ],
                       position: (563, 19),
                      },
                     },
                    ],
                    recursive: false,
                    position: (557, 25),
                   },
                  },
                 ],
                 recursive: false,
                 position: (554, 42),
                },
               },
              ],
              recursive: false,
              position: (553, 29),
             },
            ],
           },
           position: (553, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (568, 6),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: LogicalOr,
               operands: [
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  BinaryOperation {
                   operator: LogicalOr,
                   operands: [
                    BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      BinaryOperation {
                       operator: LogicalOr,
                       operands: [
                        BinaryOperation {
                         operator: LogicalOr,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (569, 7),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "carbon",
                              position: (569, 11),
                             },
                             Raw {
                              content: "enableCache",
                              position: (569, 18),
                             },
                            ],
                           },
                           default: None,
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (569, 33),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "carbon",
                              position: (569, 37),
                             },
                             Raw {
                              content: "enableAggregator",
                              position: (569, 44),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                         position: (569, 30),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (569, 64),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "carbon",
                            position: (569, 68),
                           },
                           Raw {
                            content: "enableRelay",
                            position: (569, 75),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (569, 61),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (570, 7),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "web",
                          position: (570, 11),
                         },
                         Raw {
                          content: "enable",
                          position: (570, 15),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (569, 87),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (570, 25),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "api",
                        position: (570, 29),
                       },
                       Raw {
                        content: "enable",
                        position: (570, 33),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (570, 22),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (571, 7),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "seyren",
                      position: (571, 11),
                     },
                     Raw {
                      content: "enable",
                      position: (571, 18),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (570, 40),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (571, 28),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "beacon",
                    position: (571, 32),
                   },
                   Raw {
                    content: "enable",
                    position: (571, 39),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (571, 25),
              },
              position: (568, 11),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (573, 7),
                  },
                  Raw {
                   content: "users",
                   position: (573, 13),
                  },
                  Raw {
                   content: "graphite",
                   position: (573, 19),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "uid",
                      position: (574, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (574, 15),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "ids",
                       position: (574, 22),
                      },
                      Raw {
                       content: "uids",
                       position: (574, 26),
                      },
                      Raw {
                       content: "graphite",
                       position: (574, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "group",
                      position: (575, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "graphite",
                      position: (575, 18),
                     },
                    ],
                    position: (575, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (576, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Graphite daemon user",
                      position: (576, 24),
                     },
                    ],
                    position: (576, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "home",
                      position: (577, 9),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "dataDir",
                    position: (577, 16),
                   },
                  },
                 ],
                 recursive: false,
                 position: (573, 30),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (579, 7),
                  },
                  Raw {
                   content: "groups",
                   position: (579, 13),
                  },
                  Raw {
                   content: "graphite",
                   position: (579, 20),
                  },
                  Raw {
                   content: "gid",
                   position: (579, 29),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (579, 35),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "ids",
                    position: (579, 42),
                   },
                   Raw {
                    content: "gids",
                    position: (579, 46),
                   },
                   Raw {
                    content: "graphite",
                    position: (579, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
              recursive: false,
              position: (572, 8),
             },
            ],
           },
           position: (568, 5),
          },
         ],
         position: (371, 20),
        },
       ],
      },
     },
    ],
    recursive: false,
    position: (72, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}