`Option` vs non-`Option`

foo.md

Option vs non-Option

	Option<T>	non-Option (T | undefined)
accessing property	userOption.map(user => user.age)	userNullish?.age
calling a method	userOption.map(user => user.fn())	userNullish?.fn()
providing fallback	ageOption.getOrElse(0)	ageNullish ?? 0
filter	ageOption.filter(checkIsOddNumber)	ageNullish !== undefined && checkIsOddNumber(ageNullish) ? ageNullish : undefined
map	ageOption.map(add1)	ageNullish !== undefined ? add1(ageNullish) : undefined
flat map / chain	ageOption.flatMap(add1)	ageNullish !== undefined ? add1(ageNullish) : undefined
check for existence with predicate	ageOption.exists(checkIsOddNumber)	ageNullish !== undefined ? checkIsOddNumber(ageNullish) : false
check for existence with method	nameOption.exists(name => name.startsWith('bob'))	nameNullish?.startsWith('bob') ?? false
nesting	Option<Option<T>>	impossible
sequencing	sequence(fa, fb)	fa !== undefined ? fb !== undefined ? [fa, fb] : undefined : undefined
mapping multiple	sequence(fa, fb).map(add)	fa !== undefined ? fb !== undefined ? add([fa, fb]) : undefined : undefined

Comparison of advanced example

const age1 = userOption
  .flatMap(user => user.age)
  .map(plus1)
  .filter(checkIsOddNumber)
  .getOrElse(0);

const age2 =
  (user?.age !== undefined
    ? (() => {
        const agePlus1 = plus1(user.age);
        return checkIsOddNumber(agePlus1) ? agePlus1 : undefined;
      })()
    : undefined) ?? 0;

I see, for the case where you are mapping with a function f where f<T>(ta: Nilable<T>): Nilable<T> you lose information during composition. Effectively this is the case where undefined is meaningful as a value.