How to lift all the values of an object to option while while preserving the type

Question

Is there any function in fp-ts capable of lifting all values of an object to an option and keep the shape of the type? The cherry on top will be to be able to not transform any value that is already option. Something like this:

({ a: string, b: Option<number> }) => { a: Option<string>,  b: Option<number>}

Answer 1

The short answer to this question is "no", as far as I can tell, fp-ts provides no helper to achieve exactly what you're looking for. The idea of "keep[ing] the shape of the type" is something that fp-ts refers to as a "struct". There is a struct.ts section of the library but it is fairly limited at the time of writing.

If I understand your question correctly, you are looking for a function that operates on a struct and converts the type at each key roughly according to the following types:

import * as O from 'fp-ts/lib/Option';
// If the T is already an option return it otherwise wrap it up.
type FlatOption<T> = T extends O.Option<any> ? T : O.Option<T>;
// For some T, replace all the values in T with FlatOption values
type Optionify<T> = {[K in keyof T]: FlatOption<T[K]>}
declare function optionify<T>(t: T): Optionify<T>;

And optionify does not exist in the library. We could try and make one though. The main obstacle is detecting if something is an option. fp-ts does not actually declare an Option class so we cannot use instanceof to check if something coming in is really an Option, but we can make a best guess by breaking some layers of abstraction and looking for an _tag field that says 'None' or 'Some' as per the current implementation.

So a possible implementation might look like:

import * as O from "fp-ts/lib/Option";

interface IFoo {
  a: string;
  b: O.Option<number>;
}

type FlatOption<T> = T extends O.Option<any> ? T : O.Option<T>;
type Optionify<T> = { [K in keyof T]: FlatOption<T[K]> };

function flatOpt<A>(a: A): FlatOption<A> {
  // Lots of work here to make sure we have an option.
  // If you're using `io-ts` or other things in the ecosystem
  // then there may be better options for checking if something is
  // an Option.
  // This approach is fragile since if the library ever decided to change its
  // internals, your code would no longer work.

  // Use at your own risk!
  if (
    typeof a === "object" &&
    a !== null &&
    "_tag" in a &&
    (a._tag === "None" || a._tag === "Some")
  ) {
    return a as FlatOption<A>;
  }
  // Note this will wrap up `undefined` and `null` in `Option` as well.
  return O.some(a) as FlatOption<A>;
}

type NonArray<T> = T extends Array<any> ? never : T;
// - Non-enumerable values in the given object will be missing from the
//   newly created object
// - This attempts to avoid bad calls by making sure the value is an object
//   and eliminating arrays
function optionify<A extends object>(a: NonArray<A>) {
  return Object.fromEntries(
    // Lots of type handwaving to get the type checker off our backs for
    // to ignore the problems described as gotchas.
    Object.entries(a).map(([key, val]) => [key, flatOpt(val)] as any),
  ) as Optionify<A>;
}

const foo: IFoo = { a: "cat", b: O.some(1) };
const bar: Optionify<IFoo> = optionify(foo);
console.log(bar);

One last note, if you don't have a struct but instead have say a Record, then you could use fp-ts/lib/Record's map function to apply flatOpt and avoid at least the gotchas described with optionify.

Answer 2

I ended doing my own implementation. It required some type coercion, but I covered it with 100% code coverage, so I think is quite reliable, and very simple after all:

import { record } from "fp-ts";
import { O, pipe, type _Option as Option } from "../fp";

type OptKeys<T extends Record<string, unknown>> = {
  [K in keyof T]: T[K] extends Option<infer U> ? Option<U> : Option<T[K]>;
};
// If anyone knows a better version without this many type coercions, please let me know.
const isOption = (v: unknown): v is Option<unknown> => {
  if (typeof v === "object" && v !== null) {
    return O.isSome(v as Option<unknown>) || O.isNone(v as Option<unknown>);
  }
  return false;
};

/**
 * Lift all values of an object into optional values preserving the original structure
 * Existing optional values will not be nested.
 * Example:
 * 
 * const obj = { name: "John", age: O.some(30), address: null, }
 * const liftedObj = liftOpt(obj)
 * // liftedObj = { name: O.of("John"), age: O.some(30), address: O.none, }
 *
 * @param obj the object to lift
 * @returns A new object with all values lifted into optional values
 */
export const liftObjToOpt = <T extends Record<string, unknown>>(
  obj: T
): OptKeys<T> => {
  return pipe(
    obj,
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    record.map((v: any) => (isOption(v) ? v : O.fromNullable(v)))
  ) as OptKeys<T>;
};