types.nix

# Definitions related to run-time type checking.  Used in particular
# to type-check NixOS configurations.
{ lib }:

let
  inherit (lib)
    elem
    flip
    isAttrs
    isBool
    isDerivation
    isFloat
    isFunction
    isInt
    isList
    isString
    isStorePath
    throwIf
    toDerivation
    toList
    ;
  inherit (lib.lists)
    all
    concatLists
    count
    elemAt
    filter
    foldl'
    head
    imap1
    last
    length
    tail
    ;
  inherit (lib.attrsets)
    attrNames
    filterAttrs
    hasAttr
    mapAttrs
    optionalAttrs
    zipAttrsWith
    ;
  inherit (lib.options)
    getFiles
    getValues
    mergeDefaultOption
    mergeEqualOption
    mergeOneOption
    mergeUniqueOption
    showFiles
    showOption
    ;
  inherit (lib.strings)
    concatMapStringsSep
    concatStringsSep
    escapeNixString
    hasInfix
    isStringLike
    ;
  inherit (lib.trivial)
    boolToString
    ;

  inherit (lib.modules)
    mergeDefinitions
    fixupOptionType
    mergeOptionDecls
    ;

  inAttrPosSuffix = v: name:
    let pos = builtins.unsafeGetAttrPos name v; in
    if pos == null then "" else " at ${pos.file}:${toString pos.line}:${toString pos.column}";

  outer_types =
rec {
  isType = type: x: (x._type or "") == type;

  setType = typeName: value: value // {
    _type = typeName;
  };


  # Default type merging function
  # takes two type functors and return the merged type
  defaultTypeMerge = f: f':
    let mergedWrapped = f.wrapped.typeMerge f'.wrapped.functor;
        mergedPayload = f.binOp f.payload f'.payload;

        hasPayload = assert (f'.payload != null) == (f.payload != null); f.payload != null;
        hasWrapped = assert (f'.wrapped != null) == (f.wrapped != null); f.wrapped != null;
    in
    # Abort early: cannot merge different types
    if f.name != f'.name
       then null
    else

    if hasPayload then
      if hasWrapped then
        # Has both wrapped and payload
        throw ''
          Type ${f.name} defines both `functor.payload` and `functor.wrapped` at the same time, which is not supported.

          Use either `functor.payload` or `functor.wrapped` but not both.

          If your code worked before remove `functor.payload` from the type definition.
        ''
      else
        # Has payload
        if mergedPayload == null then null else f.type mergedPayload
    else
      if hasWrapped then
        # Has wrapped
        # TODO(@hsjobeki): This could also be a warning and removed in the future
        if mergedWrapped == null then null else f.type mergedWrapped
      else
        f.type;

  # Default type functor
  defaultFunctor = name: {
    inherit name;
    type    = types.${name} or null;
    wrapped = null;
    payload = null;
    binOp   = a: b: null;
  };

  isOptionType = isType "option-type";
  mkOptionType =
    { # Human-readable representation of the type, should be equivalent to
      # the type function name.
      name
    , # Description of the type, defined recursively by embedding the wrapped type if any.
      description ? null
      # A hint for whether or not this description needs parentheses. Possible values:
      #  - "noun": a noun phrase
      #    Example description: "positive integer",
      #  - "conjunction": a phrase with a potentially ambiguous "or" connective
      #    Example description: "int or string"
      #  - "composite": a phrase with an "of" connective
      #    Example description: "list of string"
      #  - "nonRestrictiveClause": a noun followed by a comma and a clause
      #    Example description: "positive integer, meaning >0"
      # See the `optionDescriptionPhrase` function.
    , descriptionClass ? null
    , # DO NOT USE WITHOUT KNOWING WHAT YOU ARE DOING!
      # Function applied to each definition that must return false when a definition
      # does not match the type. It should not check more than the root of the value,
      # because checking nested values reduces laziness, leading to unnecessary
      # infinite recursions in the module system.
      # Further checks of nested values should be performed by throwing in
      # the merge function.
      # Strict and deep type checking can be performed by calling lib.deepSeq on
      # the merged value.
      #
      # See https://github.com/NixOS/nixpkgs/pull/6794 that introduced this change,
      # https://github.com/NixOS/nixpkgs/pull/173568 and
      # https://github.com/NixOS/nixpkgs/pull/168295 that attempted to revert this,
      # https://github.com/NixOS/nixpkgs/issues/191124 and
      # https://github.com/NixOS/nixos-search/issues/391 for what happens if you ignore
      # this disclaimer.
      check ? (x: true)
    , # Merge a list of definitions together into a single value.
      # This function is called with two arguments: the location of
      # the option in the configuration as a list of strings
      # (e.g. ["boot" "loader "grub" "enable"]), and a list of
      # definition values and locations (e.g. [ { file = "/foo.nix";
      # value = 1; } { file = "/bar.nix"; value = 2 } ]).
      merge ? mergeDefaultOption
    , # Whether this type has a value representing nothingness. If it does,
      # this should be a value of the form { value = <the nothing value>; }
      # If it doesn't, this should be {}
      # This may be used when a value is required for `mkIf false`. This allows the extra laziness in e.g. `lazyAttrsOf`.
      emptyValue ? {}
    , # Return a flat attrset of sub-options.  Used to generate
      # documentation.
      getSubOptions ? prefix: {}
    , # List of modules if any, or null if none.
      getSubModules ? null
    , # Function for building the same option type with a different list of
      # modules.
      substSubModules ? m: null
    , # Function that merge type declarations.
      # internal, takes a functor as argument and returns the merged type.
      # returning null means the type is not mergeable
      typeMerge ? defaultTypeMerge functor
    , # The type functor.
      # internal, representation of the type as an attribute set.
      #   name: name of the type
      #   type: type function.
      #   wrapped: the type wrapped in case of compound types.
      #   payload: values of the type, two payloads of the same type must be
      #            combinable with the binOp binary operation.
      #   binOp: binary operation that merge two payloads of the same type.
      functor ? defaultFunctor name
    , # The deprecation message to display when this type is used by an option
      # If null, the type isn't deprecated
      deprecationMessage ? null
    , # The types that occur in the definition of this type. This is used to
      # issue deprecation warnings recursively. Can also be used to reuse
      # nested types
      nestedTypes ? {}
    }:
    { _type = "option-type";
      inherit
        name check merge emptyValue getSubOptions getSubModules substSubModules
        typeMerge functor deprecationMessage nestedTypes descriptionClass;
      description = if description == null then name else description;
    };

  # optionDescriptionPhrase :: (str -> bool) -> optionType -> str
  #
  # Helper function for producing unambiguous but readable natural language
  # descriptions of types.
  #
  # Parameters
  #
  #     optionDescriptionPhase unparenthesize optionType
  #
  # `unparenthesize`: A function from descriptionClass string to boolean.
  #   It must return true when the class of phrase will fit unambiguously into
  #   the description of the caller.
  #
  # `optionType`: The option type to parenthesize or not.
  #   The option whose description we're returning.
  #
  # Return value
  #
  # The description of the `optionType`, with parentheses if there may be an
  # ambiguity.
  optionDescriptionPhrase = unparenthesize: t:
    if unparenthesize (t.descriptionClass or null)
    then t.description
    else "(${t.description})";

  # When adding new types don't forget to document them in
  # nixos/doc/manual/development/option-types.section.md!
  types = rec {

    raw = mkOptionType {
      name = "raw";
      description = "raw value";
      descriptionClass = "noun";
      check = value: true;
      merge = mergeOneOption;
    };

    anything = mkOptionType {
      name = "anything";
      description = "anything";
      descriptionClass = "noun";
      check = value: true;
      merge = loc: defs:
        let
          getType = value:
            if isAttrs value && isStringLike value
            then "stringCoercibleSet"
            else builtins.typeOf value;

          # Returns the common type of all definitions, throws an error if they
          # don't have the same type
          commonType = foldl' (type: def:
            if getType def.value == type
            then type
            else throw "The option `${showOption loc}' has conflicting option types in ${showFiles (getFiles defs)}"
          ) (getType (head defs).value) defs;

          mergeFunction = {
            # Recursively merge attribute sets
            set = (attrsOf anything).merge;
            # This is the type of packages, only accept a single definition
            stringCoercibleSet = mergeOneOption;
            lambda = loc: defs: arg: anything.merge
              (loc ++ [ "<function body>" ])
              (map (def: {
                file = def.file;
                value = def.value arg;
              }) defs);
            # Otherwise fall back to only allowing all equal definitions
          }.${commonType} or mergeEqualOption;
        in mergeFunction loc defs;
    };

    unspecified = mkOptionType {
      name = "unspecified";
      description = "unspecified value";
      descriptionClass = "noun";
    };

    bool = mkOptionType {
      name = "bool";
      description = "boolean";
      descriptionClass = "noun";
      check = isBool;
      merge = mergeEqualOption;
    };

    boolByOr = mkOptionType {
      name = "boolByOr";
      description = "boolean (merged using or)";
      descriptionClass = "noun";
      check = isBool;
      merge = loc: defs:
        foldl'
          (result: def:
            # Under the assumption that .check always runs before merge, we can assume that all defs.*.value
            # have been forced, and therefore we assume we don't introduce order-dependent strictness here
            result || def.value
          )
          false
          defs;
    };

    int = mkOptionType {
      name = "int";
      description = "signed integer";
      descriptionClass = "noun";
      check = isInt;
      merge = mergeEqualOption;
    };

    # Specialized subdomains of int
    ints =
      let
        betweenDesc = lowest: highest:
          "${toString lowest} and ${toString highest} (both inclusive)";
        between = lowest: highest:
          assert lib.assertMsg (lowest <= highest)
            "ints.between: lowest must be smaller than highest";
          addCheck int (x: x >= lowest && x <= highest) // {
            name = "intBetween";
            description = "integer between ${betweenDesc lowest highest}";
          };
        ign = lowest: highest: name: docStart:
          between lowest highest // {
            inherit name;
            description = docStart + "; between ${betweenDesc lowest highest}";
          };
        unsign = bit: range: ign 0 (range - 1)
          "unsignedInt${toString bit}" "${toString bit} bit unsigned integer";
        sign = bit: range: ign (0 - (range / 2)) (range / 2 - 1)
          "signedInt${toString bit}" "${toString bit} bit signed integer";

      in {
        # TODO: Deduplicate with docs in nixos/doc/manual/development/option-types.section.md
        /**
          An int with a fixed range.

          # Example
          :::{.example}
          ## `lib.types.ints.between` usage example

          ```nix
          (ints.between 0 100).check (-1)
          => false
          (ints.between 0 100).check (101)
          => false
          (ints.between 0 0).check 0
          => true
          ```

          :::
        */
        inherit between;

        unsigned = addCheck types.int (x: x >= 0) // {
          name = "unsignedInt";
          description = "unsigned integer, meaning >=0";
          descriptionClass = "nonRestrictiveClause";
        };
        positive = addCheck types.int (x: x > 0) // {
          name = "positiveInt";
          description = "positive integer, meaning >0";
          descriptionClass = "nonRestrictiveClause";
        };
        u8 = unsign 8 256;
        u16 = unsign 16 65536;
        # the biggest int Nix accepts is 2^63 - 1 (9223372036854775808)
        # the smallest int Nix accepts is -2^63 (-9223372036854775807)
        u32 = unsign 32 4294967296;
        # u64 = unsign 64 18446744073709551616;

        s8 = sign 8 256;
        s16 = sign 16 65536;
        s32 = sign 32 4294967296;
      };

    # Alias of u16 for a port number
    port = ints.u16;

    float = mkOptionType {
      name = "float";
      description = "floating point number";
      descriptionClass = "noun";
      check = isFloat;
      merge = mergeEqualOption;
    };

    number = either int float;

    numbers = let
      betweenDesc = lowest: highest:
        "${builtins.toJSON lowest} and ${builtins.toJSON highest} (both inclusive)";
    in {
      between = lowest: highest:
        assert lib.assertMsg (lowest <= highest)
          "numbers.between: lowest must be smaller than highest";
        addCheck number (x: x >= lowest && x <= highest) // {
          name = "numberBetween";
          description = "integer or floating point number between ${betweenDesc lowest highest}";
        };

      nonnegative = addCheck number (x: x >= 0) // {
        name = "numberNonnegative";
        description = "nonnegative integer or floating point number, meaning >=0";
        descriptionClass = "nonRestrictiveClause";
      };
      positive = addCheck number (x: x > 0) // {
        name = "numberPositive";
        description = "positive integer or floating point number, meaning >0";
        descriptionClass = "nonRestrictiveClause";
      };
    };

    str = mkOptionType {
      name = "str";
      description = "string";
      descriptionClass = "noun";
      check = isString;
      merge = mergeEqualOption;
    };

    nonEmptyStr = mkOptionType {
      name = "nonEmptyStr";
      description = "non-empty string";
      descriptionClass = "noun";
      check = x: str.check x && builtins.match "[ \t\n]*" x == null;
      inherit (str) merge;
    };

    # Allow a newline character at the end and trim it in the merge function.
    singleLineStr =
      let
        inherit (strMatching "[^\n\r]*\n?") check merge;
      in
      mkOptionType {
        name = "singleLineStr";
        description = "(optionally newline-terminated) single-line string";
        descriptionClass = "noun";
        inherit check;
        merge = loc: defs:
          lib.removeSuffix "\n" (merge loc defs);
      };

    strMatching = pattern: mkOptionType {
      name = "strMatching ${escapeNixString pattern}";
      description = "string matching the pattern ${pattern}";
      descriptionClass = "noun";
      check = x: str.check x && builtins.match pattern x != null;
      inherit (str) merge;
    };

    # Merge multiple definitions by concatenating them (with the given
    # separator between the values).
    separatedString = sep: mkOptionType rec {
      name = "separatedString";
      description = if sep == ""
        then "Concatenated string" # for types.string.
        else "strings concatenated with ${builtins.toJSON sep}"
      ;
      descriptionClass = "noun";
      check = isString;
      merge = loc: defs: concatStringsSep sep (getValues defs);
      functor = (defaultFunctor name) // {
        payload = sep;
        binOp = sepLhs: sepRhs:
          if sepLhs == sepRhs then sepLhs
          else null;
      };
    };

    lines = separatedString "\n";
    commas = separatedString ",";
    envVar = separatedString ":";

    # Deprecated; should not be used because it quietly concatenates
    # strings, which is usually not what you want.
    # We use a lib.warn because `deprecationMessage` doesn't trigger in nested types such as `attrsOf string`
    string = lib.warn
      "The type `types.string` is deprecated. See https://github.com/NixOS/nixpkgs/pull/66346 for better alternative types."
      (separatedString "" // {
        name = "string";
      });

    passwdEntry = entryType: addCheck entryType (str: !(hasInfix ":" str || hasInfix "\n" str)) // {
      name = "passwdEntry ${entryType.name}";
      description = "${optionDescriptionPhrase (class: class == "noun") entryType}, not containing newlines or colons";
      descriptionClass = "nonRestrictiveClause";
    };

    attrs = mkOptionType {
      name = "attrs";
      description = "attribute set";
      check = isAttrs;
      merge = loc: foldl' (res: def: res // def.value) {};
      emptyValue = { value = {}; };
    };

    # A package is a top-level store path (/nix/store/hash-name). This includes:
    # - derivations
    # - more generally, attribute sets with an `outPath` or `__toString` attribute
    #   pointing to a store path, e.g. flake inputs
    # - strings with context, e.g. "${pkgs.foo}" or (toString pkgs.foo)
    # - hardcoded store path literals (/nix/store/hash-foo) or strings without context
    #   ("/nix/store/hash-foo"). These get a context added to them using builtins.storePath.
    # If you don't need a *top-level* store path, consider using pathInStore instead.
    package = mkOptionType {
      name = "package";
      descriptionClass = "noun";
      check = x: isDerivation x || isStorePath x;
      merge = loc: defs:
        let res = mergeOneOption loc defs;
        in if builtins.isPath res || (builtins.isString res && ! builtins.hasContext res)
          then toDerivation res
          else res;
    };

    shellPackage = package // {
      check = x: isDerivation x && hasAttr "shellPath" x;
    };

    pkgs = addCheck
      (unique { message = "A Nixpkgs pkgs set can not be merged with another pkgs set."; } attrs // {
        name = "pkgs";
        descriptionClass = "noun";
        description = "Nixpkgs package set";
      })
      (x: (x._type or null) == "pkgs");

    path = mkOptionType {
      name = "path";
      descriptionClass = "noun";
      check = x: isStringLike x && builtins.substring 0 1 (toString x) == "/";
      merge = mergeEqualOption;
    };

    pathInStore = mkOptionType {
      name = "pathInStore";
      description = "path in the Nix store";
      descriptionClass = "noun";
      check = x: isStringLike x && builtins.match "${builtins.storeDir}/[^.].*" (toString x) != null;
      merge = mergeEqualOption;
    };

    listOf = elemType: mkOptionType rec {
      name = "listOf";
      description = "list of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";
      descriptionClass = "composite";
      check = isList;
      merge = loc: defs:
        map (x: x.value) (filter (x: x ? value) (concatLists (imap1 (n: def:
          imap1 (m: def':
            (mergeDefinitions
              (loc ++ ["[definition ${toString n}-entry ${toString m}]"])
              elemType
              [{ inherit (def) file; value = def'; }]
            ).optionalValue
          ) def.value
        ) defs)));
      emptyValue = { value = []; };
      getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
      getSubModules = elemType.getSubModules;
      substSubModules = m: listOf (elemType.substSubModules m);
      functor = (defaultFunctor name) // { wrapped = elemType; };
      nestedTypes.elemType = elemType;
    };

    nonEmptyListOf = elemType:
      let list = addCheck (types.listOf elemType) (l: l != []);
      in list // {
        description = "non-empty ${optionDescriptionPhrase (class: class == "noun") list}";
        emptyValue = { }; # no .value attr, meaning unset
        substSubModules = m: nonEmptyListOf (elemType.substSubModules m);
      };

    attrsOf = elemType: mkOptionType rec {
      name = "attrsOf";
      description = "attribute set of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";
      descriptionClass = "composite";
      check = isAttrs;
      merge = loc: defs:
        mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs:
            (mergeDefinitions (loc ++ [name]) elemType defs).optionalValue
          )
          # Push down position info.
          (map (def: mapAttrs (n: v: { inherit (def) file; value = v; }) def.value) defs)));
      emptyValue = { value = {}; };
      getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
      getSubModules = elemType.getSubModules;
      substSubModules = m: attrsOf (elemType.substSubModules m);
      functor = (defaultFunctor name) // { wrapped = elemType; };
      nestedTypes.elemType = elemType;
    };

    # A version of attrsOf that's lazy in its values at the expense of
    # conditional definitions not working properly. E.g. defining a value with
    # `foo.attr = mkIf false 10`, then `foo ? attr == true`, whereas with
    # attrsOf it would correctly be `false`. Accessing `foo.attr` would throw an
    # error that it's not defined. Use only if conditional definitions don't make sense.
    lazyAttrsOf = elemType: mkOptionType rec {
      name = "lazyAttrsOf";
      description = "lazy attribute set of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";
      descriptionClass = "composite";
      check = isAttrs;
      merge = loc: defs:
        zipAttrsWith (name: defs:
          let merged = mergeDefinitions (loc ++ [name]) elemType defs;
          # mergedValue will trigger an appropriate error when accessed
          in merged.optionalValue.value or elemType.emptyValue.value or merged.mergedValue
        )
        # Push down position info.
        (map (def: mapAttrs (n: v: { inherit (def) file; value = v; }) def.value) defs);
      emptyValue = { value = {}; };
      getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
      getSubModules = elemType.getSubModules;
      substSubModules = m: lazyAttrsOf (elemType.substSubModules m);
      functor = (defaultFunctor name) // { wrapped = elemType; };
      nestedTypes.elemType = elemType;
    };

    # TODO: deprecate this in the future:
    loaOf = elemType: types.attrsOf elemType // {
      name = "loaOf";
      deprecationMessage = "Mixing lists with attribute values is no longer"
        + " possible; please use `types.attrsOf` instead. See"
        + " https://github.com/NixOS/nixpkgs/issues/1800 for the motivation.";
      nestedTypes.elemType = elemType;
    };

    attrTag = tags:
      let tags_ = tags; in
      let
        tags =
          mapAttrs
            (n: opt:
              builtins.addErrorContext "while checking that attrTag tag ${lib.strings.escapeNixIdentifier n} is an option with a type${inAttrPosSuffix tags_ n}" (
                throwIf (opt._type or null != "option")
                  "In attrTag, each tag value must be an option, but tag ${lib.strings.escapeNixIdentifier n} ${
                    if opt?_type then
                      if opt._type == "option-type"
                      then "was a bare type, not wrapped in mkOption."
                      else "was of type ${lib.strings.escapeNixString opt._type}."
                    else "was not."}"
                opt // {
                  declarations = opt.declarations or (
                    let pos = builtins.unsafeGetAttrPos n tags_;
                    in if pos == null then [] else [ pos.file ]
                  );
                  declarationPositions = opt.declarationPositions or (
                    let pos = builtins.unsafeGetAttrPos n tags_;
                    in if pos == null then [] else [ pos ]
                  );
                }
              ))
            tags_;
        choicesStr = concatMapStringsSep ", " lib.strings.escapeNixIdentifier (attrNames tags);
      in
      mkOptionType {
        name = "attrTag";
        description = "attribute-tagged union";
        descriptionClass = "noun";
        getSubOptions = prefix:
          mapAttrs
            (tagName: tagOption: {
              "${lib.showOption prefix}" =
                tagOption // {
                  loc = prefix ++ [ tagName ];
                };
            })
            tags;
        check = v: isAttrs v && length (attrNames v) == 1 && tags?${head (attrNames v)};
        merge = loc: defs:
          let
            choice = head (attrNames (head defs).value);
            checkedValueDefs = map
              (def:
                assert (length (attrNames def.value)) == 1;
                if (head (attrNames def.value)) != choice
                then throw "The option `${showOption loc}` is defined both as `${choice}` and `${head (attrNames def.value)}`, in ${showFiles (getFiles defs)}."
                else { inherit (def) file; value = def.value.${choice}; })
              defs;
          in
            if tags?${choice}
            then
              { ${choice} =
                  (lib.modules.evalOptionValue
                    (loc ++ [choice])
                    tags.${choice}
                    checkedValueDefs
                  ).value;
              }
            else throw "The option `${showOption loc}` is defined as ${lib.strings.escapeNixIdentifier choice}, but ${lib.strings.escapeNixIdentifier choice} is not among the valid choices (${choicesStr}). Value ${choice} was defined in ${showFiles (getFiles defs)}.";
        nestedTypes = tags;
        functor = defaultFunctor "attrTag" // {
          type = { tags, ... }: types.attrTag tags;
          payload = { inherit tags; };
          binOp =
            let
              # Add metadata in the format that submodules work with
              wrapOptionDecl =
                option: { options = option; _file = "<attrTag {...}>"; pos = null; };
            in
            a: b: {
              tags = a.tags // b.tags //
                mapAttrs
                  (tagName: bOpt:
                    lib.mergeOptionDecls
                      # FIXME: loc is not accurate; should include prefix
                      #        Fortunately, it's only used for error messages, where a "relative" location is kinda ok.
                      #        It is also returned though, but use of the attribute seems rare?
                      [tagName]
                      [ (wrapOptionDecl a.tags.${tagName}) (wrapOptionDecl bOpt) ]
                    // {
                      # mergeOptionDecls is not idempotent in these attrs:
                      declarations = a.tags.${tagName}.declarations ++ bOpt.declarations;
                      declarationPositions = a.tags.${tagName}.declarationPositions ++ bOpt.declarationPositions;
                    }
                  )
                  (builtins.intersectAttrs a.tags b.tags);
          };
        };
      };

    uniq = unique { message = ""; };

    unique = { message }: type: mkOptionType rec {
      name = "unique";
      inherit (type) description descriptionClass check;
      merge = mergeUniqueOption { inherit message; inherit (type) merge; };
      emptyValue = type.emptyValue;
      getSubOptions = type.getSubOptions;
      getSubModules = type.getSubModules;
      substSubModules = m: uniq (type.substSubModules m);
      functor = (defaultFunctor name) // { wrapped = type; };
      nestedTypes.elemType = type;
    };

    # Null or value of ...
    nullOr = elemType: mkOptionType rec {
      name = "nullOr";
      description = "null or ${optionDescriptionPhrase (class: class == "noun" || class == "conjunction") elemType}";
      descriptionClass = "conjunction";
      check = x: x == null || elemType.check x;
      merge = loc: defs:
        let nrNulls = count (def: def.value == null) defs; in
        if nrNulls == length defs then null
        else if nrNulls != 0 then
          throw "The option `${showOption loc}` is defined both null and not null, in ${showFiles (getFiles defs)}."
        else elemType.merge loc defs;
      emptyValue = { value = null; };
      getSubOptions = elemType.getSubOptions;
      getSubModules = elemType.getSubModules;
      substSubModules = m: nullOr (elemType.substSubModules m);
      functor = (defaultFunctor name) // { wrapped = elemType; };
      nestedTypes.elemType = elemType;
    };

    functionTo = elemType: mkOptionType {
      name = "functionTo";
      description = "function that evaluates to a(n) ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";
      descriptionClass = "composite";
      check = isFunction;
      merge = loc: defs:
        fnArgs: (mergeDefinitions (loc ++ [ "<function body>" ]) elemType (map (fn: { inherit (fn) file; value = fn.value fnArgs; }) defs)).mergedValue;
      getSubOptions = prefix: elemType.getSubOptions (prefix ++ [ "<function body>" ]);
      getSubModules = elemType.getSubModules;
      substSubModules = m: functionTo (elemType.substSubModules m);
      functor = (defaultFunctor "functionTo") // { wrapped = elemType; };
      nestedTypes.elemType = elemType;
    };

    # A submodule (like typed attribute set). See NixOS manual.
    submodule = modules: submoduleWith {
      shorthandOnlyDefinesConfig = true;
      modules = toList modules;
    };

    # A module to be imported in some other part of the configuration.
    deferredModule = deferredModuleWith { };

    # A module to be imported in some other part of the configuration.
    # `staticModules`' options will be added to the documentation, unlike
    # options declared via `config`.
    deferredModuleWith = attrs@{ staticModules ? [] }: mkOptionType {
      name = "deferredModule";
      description = "module";
      descriptionClass = "noun";
      check = x: isAttrs x || isFunction x || path.check x;
      merge = loc: defs: {
        imports = staticModules ++ map (def: lib.setDefaultModuleLocation "${def.file}, via option ${showOption loc}" def.value) defs;
      };
      inherit (submoduleWith { modules = staticModules; })
        getSubOptions
        getSubModules;
      substSubModules = m: deferredModuleWith (attrs // {
        staticModules = m;
      });
      functor = defaultFunctor "deferredModuleWith" // {
        type = types.deferredModuleWith;
        payload = {
          inherit staticModules;
        };
        binOp = lhs: rhs: {
          staticModules = lhs.staticModules ++ rhs.staticModules;
        };
      };
    };

    # The type of a type!
    optionType = mkOptionType {
      name = "optionType";
      description = "optionType";
      descriptionClass = "noun";
      check = value: value._type or null == "option-type";
      merge = loc: defs:
        if length defs == 1
        then (head defs).value
        else let
          # Prepares the type definitions for mergeOptionDecls, which
          # annotates submodules types with file locations
          optionModules = map ({ value, file }:
            {
              _file = file;
              # There's no way to merge types directly from the module system,
              # but we can cheat a bit by just declaring an option with the type
              options = lib.mkOption {
                type = value;
              };
            }
          ) defs;
          # Merges all the types into a single one, including submodule merging.
          # This also propagates file information to all submodules
          mergedOption = fixupOptionType loc (mergeOptionDecls loc optionModules);
        in mergedOption.type;
    };

    submoduleWith =
      { modules
      , specialArgs ? {}
      , shorthandOnlyDefinesConfig ? false
      , description ? null
      , class ? null
      }@attrs:
      let
        inherit (lib.modules) evalModules;

        allModules = defs: map ({ value, file }:
          if isAttrs value && shorthandOnlyDefinesConfig
          then { _file = file; config = value; }
          else { _file = file; imports = [ value ]; }
        ) defs;

        base = evalModules {
          inherit class specialArgs;
          modules = [{
            # This is a work-around for the fact that some sub-modules,
            # such as the one included in an attribute set, expects an "args"
            # attribute to be given to the sub-module. As the option
            # evaluation does not have any specific attribute name yet, we
            # provide a default for the documentation and the freeform type.
            #
            # This is necessary as some option declaration might use the
            # "name" attribute given as argument of the submodule and use it
            # as the default of option declarations.
            #
            # We use lookalike unicode single angle quotation marks because
            # of the docbook transformation the options receive. In all uses
            # &gt; and &lt; wouldn't be encoded correctly so the encoded values
            # would be used, and use of `<` and `>` would break the XML document.
            # It shouldn't cause an issue since this is cosmetic for the manual.
            _module.args.name = lib.mkOptionDefault "‹name›";
          }] ++ modules;
        };

        freeformType = base._module.freeformType;

        name = "submodule";

      in
      mkOptionType {
        inherit name;
        description =
          if description != null then description
          else freeformType.description or name;
        check = x: isAttrs x || isFunction x || path.check x;
        merge = loc: defs:
          (base.extendModules {
            modules = [ { _module.args.name = last loc; } ] ++ allModules defs;
            prefix = loc;
          }).config;
        emptyValue = { value = {}; };
        getSubOptions = prefix: (base.extendModules
          { inherit prefix; }).options // optionalAttrs (freeformType != null) {
            # Expose the sub options of the freeform type. Note that the option
            # discovery doesn't care about the attribute name used here, so this
            # is just to avoid conflicts with potential options from the submodule
            _freeformOptions = freeformType.getSubOptions prefix;
          };
        getSubModules = modules;
        substSubModules = m: submoduleWith (attrs // {
          modules = m;
        });
        nestedTypes = lib.optionalAttrs (freeformType != null) {
          freeformType = freeformType;
        };
        functor = defaultFunctor name // {
          type = types.submoduleWith;
          payload = {
            inherit modules class specialArgs shorthandOnlyDefinesConfig description;
          };
          binOp = lhs: rhs: {
            class =
              # `or null` was added for backwards compatibility only. `class` is
              # always set in the current version of the module system.
              if lhs.class or null == null then rhs.class or null
              else if rhs.class or null == null then lhs.class or null
              else if lhs.class or null == rhs.class then lhs.class or null
              else throw "A submoduleWith option is declared multiple times with conflicting class values \"${toString lhs.class}\" and \"${toString rhs.class}\".";
            modules = lhs.modules ++ rhs.modules;
            specialArgs =
              let intersecting = builtins.intersectAttrs lhs.specialArgs rhs.specialArgs;
              in if intersecting == {}
              then lhs.specialArgs // rhs.specialArgs
              else throw "A submoduleWith option is declared multiple times with the same specialArgs \"${toString (attrNames intersecting)}\"";
            shorthandOnlyDefinesConfig =
              if lhs.shorthandOnlyDefinesConfig == null
              then rhs.shorthandOnlyDefinesConfig
              else if rhs.shorthandOnlyDefinesConfig == null
              then lhs.shorthandOnlyDefinesConfig
              else if lhs.shorthandOnlyDefinesConfig == rhs.shorthandOnlyDefinesConfig
              then lhs.shorthandOnlyDefinesConfig
              else throw "A submoduleWith option is declared multiple times with conflicting shorthandOnlyDefinesConfig values";
            description =
              if lhs.description == null
              then rhs.description
              else if rhs.description == null
              then lhs.description
              else if lhs.description == rhs.description
              then lhs.description
              else throw "A submoduleWith option is declared multiple times with conflicting descriptions";
          };
        };
      };

    # A value from a set of allowed ones.
    enum = values:
      let
        inherit (lib.lists) unique;
        show = v:
               if builtins.isString v then ''"${v}"''
          else if builtins.isInt v then builtins.toString v
          else if builtins.isBool v then boolToString v
          else ''<${builtins.typeOf v}>'';
      in
      mkOptionType rec {
        name = "enum";
        description =
          # Length 0 or 1 enums may occur in a design pattern with type merging
          # where an "interface" module declares an empty enum and other modules
          # provide implementations, each extending the enum with their own
          # identifier.
          if values == [] then
            "impossible (empty enum)"
          else if builtins.length values == 1 then
            "value ${show (builtins.head values)} (singular enum)"
          else
            "one of ${concatMapStringsSep ", " show values}";
        descriptionClass =
          if builtins.length values < 2
          then "noun"
          else "conjunction";
        check = flip elem values;
        merge = mergeEqualOption;
        functor = (defaultFunctor name) // { payload = values; binOp = a: b: unique (a ++ b); };
      };

    # Either value of type `t1` or `t2`.
    either = t1: t2: mkOptionType rec {
      name = "either";
      description =
        if t1.descriptionClass or null == "nonRestrictiveClause"
        then
          # Plain, but add comma
          "${t1.description}, or ${optionDescriptionPhrase (class: class == "noun" || class == "conjunction") t2}"
        else
          "${optionDescriptionPhrase (class: class == "noun" || class == "conjunction") t1} or ${optionDescriptionPhrase (class: class == "noun" || class == "conjunction" || class == "composite") t2}";
      descriptionClass = "conjunction";
      check = x: t1.check x || t2.check x;
      merge = loc: defs:
        let
          defList = map (d: d.value) defs;
        in
          if   all (x: t1.check x) defList
               then t1.merge loc defs
          else if all (x: t2.check x) defList
               then t2.merge loc defs
          else mergeOneOption loc defs;
      typeMerge = f':
        let mt1 = t1.typeMerge (elemAt f'.wrapped 0).functor;
            mt2 = t2.typeMerge (elemAt f'.wrapped 1).functor;
        in
           if (name == f'.name) && (mt1 != null) && (mt2 != null)
           then functor.type mt1 mt2
           else null;
      functor = (defaultFunctor name) // { wrapped = [ t1 t2 ]; };
      nestedTypes.left = t1;
      nestedTypes.right = t2;
    };

    # Any of the types in the given list
    oneOf = ts:
      let
        head' = if ts == [] then throw "types.oneOf needs to get at least one type in its argument" else head ts;
        tail' = tail ts;
      in foldl' either head' tail';

    # Either value of type `coercedType` or `finalType`, the former is
    # converted to `finalType` using `coerceFunc`.
    coercedTo = coercedType: coerceFunc: finalType:
      assert lib.assertMsg (coercedType.getSubModules == null)
        "coercedTo: coercedType must not have submodules (it’s a ${
          coercedType.description})";
      mkOptionType rec {
        name = "coercedTo";
        description = "${optionDescriptionPhrase (class: class == "noun") finalType} or ${optionDescriptionPhrase (class: class == "noun") coercedType} convertible to it";
        check = x: (coercedType.check x && finalType.check (coerceFunc x)) || finalType.check x;
        merge = loc: defs:
          let
            coerceVal = val:
              if coercedType.check val then coerceFunc val
              else val;
          in finalType.merge loc (map (def: def // { value = coerceVal def.value; }) defs);
        emptyValue = finalType.emptyValue;
        getSubOptions = finalType.getSubOptions;
        getSubModules = finalType.getSubModules;
        substSubModules = m: coercedTo coercedType coerceFunc (finalType.substSubModules m);
        typeMerge = t: null;
        functor = (defaultFunctor name) // { wrapped = finalType; };
        nestedTypes.coercedType = coercedType;
        nestedTypes.finalType = finalType;
      };

    # Augment the given type with an additional type check function.
    addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

  };
};

in outer_types // outer_types.types