Combination of S.nullable and prop.opt

[schickling]

Is your feature request related to a problem? Please describe.

When when modelling an object using S.props it's currently possible to make a field "nullable or optional" using

1. myProp: S.prop(S.nullable(S.string))
2. myProp: S.prop(S.string).opt()

(1) results in accepting null or "some-str" as value and being parsed into myProp: O.Option<string>.
(2) results in accepting undefined, "some-str" or omitting the field and being parsed into byProp: string | undefined.

Describe the solution you'd like

I'd like something "in between". Basically something that allows me to omit a field like in (2) but being parsed into an option like in (1)

Describe alternatives you've considered

Additional context

[patroza]

This is already S.prop(S.nullable(S.string)).opt()
It ends up as Option | undefined but that seems correct.
Omitting is not the same as null: if you mean None/null, why not be explicit and pass null?
undefined is not considered a value in json, even though in js you can use it as a value.

I suppose though that it wouldn't hurt to be able to define a default value for optional properties.

[patroza]

Actually, this works as expected:

const a = S.props({
  a: S.prop(S.string).opt(),
  b: S.prop(S.nullable(S.string)),
  c: S.prop(S.nullable(S.string)).opt(),
  d: S.prop(S.nullable(S.string)).def(() => O.none),
})

type I = S.ParserInputOf<typeof a>
type E = S.EncodedOf<typeof a>
type A = S.ParsedShapeOf<typeof a>

const parser = S.Parser.for(a)["|>"](S.unsafe)
console.log(
  parser({
    b: "abc",
  })
)

with the exception that the E type will loose | undefined for d. But imo that is correct.

Using Option for both null and undefined, means it's lossy;

• undefined -> Option
• null -> Option
• Option -> ?? (can only go to null or to undefined if you use O.toUndefined).

[schickling]

Thanks for your elaborate example. In my case I actually do want the "lossy parsing -> encoding" scenario since in my case I rather want to keep the accepted input data more flexible (i.e. allow for both null and explicit / implicit undefined values) while keeping my implementation when working with the data simple by just working with Optionwhere I don't care whether the original data wasnullorundefined`.

[patroza]

Thanks for your elaborate example. In my case I actually do want the "lossy parsing -> encoding" scenario since in my case I rather want to keep the accepted input data more flexible (i.e. allow for both null and explicit / implicit undefined values) while keeping my implementation when working with the data simple by just working with Optionwhere I don't care whether the original data wasnullorundefined`.

alright, what you want is this:

export type ParserInputFromProperties<Props extends PropertyRecord> = Compute<
  UnionToIntersection<
    {
      [k in keyof Props]: Props[k] extends AnyProperty
        ? Props[k]["_optional"] extends "optional"
          ? {
              readonly [h in Props[k]["_as"] extends O.Some<any>
                ? Props[k]["_as"]["value"]
                : k]?: S.EncodedOf<Props[k]["_schema"]>
            }
          : Props[k]["_def"] extends O.Option<["parser" | "both", any]>
          ? {
              readonly [h in Props[k]["_as"] extends O.Some<any>
                ? Props[k]["_as"]["value"]
                : k]?: S.EncodedOf<Props[k]["_schema"]>
            }
          : {
              readonly [h in Props[k]["_as"] extends O.Some<any>
                ? Props[k]["_as"]["value"]
                : k]: S.EncodedOf<Props[k]["_schema"]>
            }
        : never
    }[keyof Props]
  >,
  "flat"
>

type PI = S.ParserInputFromProperties<typeof a["Api"]["props"]>

with the trick being the part

Props[k]["_def"] extends O.Option<["parser" | "both", any]>
          ? {
              readonly [h in Props[k]["_as"] extends O.Some<any>
                ? Props[k]["_as"]["value"]
                : k]?: S.EncodedOf<Props[k]["_schema"]>
            }

Let's see if we can make this more elegant to derive.