lib.types.coercedTo

The following is the current implementation of this function.

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 = {
        __functor = _self: x: (coercedType.check x && finalType.check (coerceFunc x)) || finalType.check x;
        isV2MergeCoherent = true;
      };
      merge = {
        __functor =
          self: loc: defs:
          (self.v2 { inherit loc defs; }).value;
        v2 =
          { loc, defs }:
          let
            finalDefs = (
              map (
                def:
                def
                // {
                  value =
                    let
                      merged =
                        if coercedType.merge ? v2 then
                          checkV2MergeCoherence loc coercedType (
                            coercedType.merge.v2 {
                              inherit loc;
                              defs = [ def ];
                            }
                          )
                        else
                          null;
                    in
                    if coercedType.merge ? v2 then
                      if merged.headError == null then coerceFunc def.value else def.value
                    else if coercedType.check def.value then
                      coerceFunc def.value
                    else
                      def.value;
                }
              ) defs
            );
          in
          if finalType.merge ? v2 then
            checkV2MergeCoherence loc finalType (
              finalType.merge.v2 {
                inherit loc;
                defs = finalDefs;
              }
            )
          else
            {
              value = finalType.merge loc finalDefs;
              valueMeta = { };
              headError = checkDefsForError check loc defs;
            };
      };
      emptyValue = finalType.emptyValue;
      getSubOptions = finalType.getSubOptions;
      getSubModules = finalType.getSubModules;
      substSubModules = m: coercedTo coercedType coerceFunc (finalType.substSubModules m);
      typeMerge = t: null;
      functor = (defaultFunctor name) // {
        wrappedDeprecationMessage = makeWrappedDeprecationMessage { elemType = finalType; };
      };
      nestedTypes.coercedType = coercedType;
      nestedTypes.finalType = finalType;
    };