Enhance S.union for TS API

Author: DZakh

IDEAS.md

@@ -44,6 +44,8 @@ let trimContract: S.contract<string => string> = S.contract(s => {
 - Change asyncParser from () => () => promise to () => promise
 - Add schema input to the error ??? What about build errors?
 - Improve S.schema performance and expose it to the JS/TS API instead of S.object shorthand
+- Get rid of S.literal in Js/ts API
+  // FIXME: Return back s.flatten support for schemas created with S.schema
 
 ### Done
 
@@ -55,6 +57,7 @@ let trimContract: S.contract<string => string> = S.contract(s => {
 - S.to/S.variant don't allow to distructure tuples anymore
 - Shorthand version for S.schema in Js/Ts API TODO: Update docs to use it by default
 - Fix tuple parsing nested in an object schema
+- Add shorthand syntax for S.union in Js/Ts API
 
 ## v10
 

packages/tests/src/benchmark/comparison.js

@@ -49,14 +49,14 @@ const valibotSchema = V.object({
 S.setGlobalConfig({
   disableNanNumberCheck: true,
 });
-const schema = S.object({
+const schema = S.schema({
   number: S.number,
   negNumber: S.number,
   maxNumber: S.number,
   string: S.string,
   longString: S.string,
   boolean: S.boolean,
-  deeplyNested: S.object({
+  deeplyNested: S.schema({
     foo: S.string,
     num: S.number,
     bool: S.boolean,
@@ -134,14 +134,14 @@ new B.Suite()
     return V.parse(valibotSchema, data);
   })
   .add("rescript-schema (create)", () => {
-    return S.object({
+    return S.schema({
       number: S.number,
       negNumber: S.number,
       maxNumber: S.number,
       string: S.string,
       longString: S.string,
       boolean: S.boolean,
-      deeplyNested: S.object({
+      deeplyNested: S.schema({
         foo: S.string,
         num: S.number,
         bool: S.boolean,
@@ -152,14 +152,14 @@ new B.Suite()
     return S.parseWith(data, schema);
   })
   .add("rescript-schema (create + parse)", () => {
-    const schema = S.object({
+    const schema = S.schema({
       number: S.number,
       negNumber: S.number,
       maxNumber: S.number,
       string: S.string,
       longString: S.string,
       boolean: S.boolean,
-      deeplyNested: S.object({
+      deeplyNested: S.schema({
         foo: S.string,
         num: S.number,
         bool: S.boolean,

packages/tests/src/core/S_test.ts

@@ -1331,6 +1331,57 @@ test("Successfully parses union", (t) => {
   >(true);
 });
 
+test("Shape union", (t) => {
+  const shapeSchema = S.union([
+    {
+      kind: "circle" as const,
+      radius: S.number,
+    },
+    {
+      kind: "square" as const,
+      x: S.number,
+    },
+    {
+      kind: "triangle" as const,
+      x: S.number,
+      y: S.number,
+    },
+  ]);
+  const value = S.parseWith(
+    {
+      kind: "circle",
+      radius: 123,
+    },
+    shapeSchema
+  );
+
+  t.deepEqual(value, {
+    kind: "circle",
+    radius: 123,
+  });
+
+  expectType<
+    TypeEqual<
+      typeof shapeSchema,
+      S.Schema<
+        | {
+            kind: "circle";
+            radius: number;
+          }
+        | {
+            kind: "square";
+            x: number;
+          }
+        | {
+            kind: "triangle";
+            x: number;
+            y: number;
+          }
+      >
+    >
+  >(true);
+});
+
 test("Successfully parses union with transformed items", (t) => {
   const schema = S.union([
     S.transform(S.string, (string) => Number(string)),

src/S.d.ts

@@ -14,6 +14,27 @@ export type Output<T> = T extends Schema<infer Output, unknown>
 export type Input<T> = T extends Schema<unknown, infer Input> ? Input : never;
 
 type UnknownSchema = Schema<unknown>;
+
+type UnknownToOuput<T> = T extends Schema<unknown>
+  ? Output<T>
+  : T extends {
+      [k in keyof T]: unknown;
+    }
+  ? {
+      [k in keyof T]: UnknownToOuput<T[k]>;
+    }
+  : T;
+
+type UnknownToInput<T> = T extends Schema<unknown>
+  ? Input<T>
+  : T extends {
+      [k in keyof T]: unknown;
+    }
+  ? {
+      [k in keyof T]: UnknownToInput<T[k]>;
+    }
+  : T;
+
 type SchemaTupleOutput<
   Tuple extends UnknownSchema[],
   Length extends number = Tuple["length"]
@@ -47,6 +68,47 @@ type _TupleInput<
   ? Accumulated
   : _TupleInput<Tuple, Length, [...Accumulated, Input<Tuple[Index]>]>;
 
+type SchemaUnionTupleOutput<
+  Tuple extends unknown[],
+  Length extends number = Tuple["length"]
+> = Length extends Length
+  ? number extends Length
+    ? Tuple
+    : _UnionTupleOutput<Tuple, Length, []>
+  : never;
+type _UnionTupleOutput<
+  Tuple extends unknown[],
+  Length extends number,
+  Accumulated extends unknown[],
+  Index extends number = Accumulated["length"]
+> = Index extends Length
+  ? Accumulated
+  : _UnionTupleOutput<
+      Tuple,
+      Length,
+      [...Accumulated, UnknownToOuput<Tuple[Index]>]
+    >;
+type SchemaUnionTupleInput<
+  Tuple extends unknown[],
+  Length extends number = Tuple["length"]
+> = Length extends Length
+  ? number extends Length
+    ? Tuple
+    : _UnionTupleInput<Tuple, Length, []>
+  : never;
+type _UnionTupleInput<
+  Tuple extends unknown[],
+  Length extends number,
+  Accumulated extends unknown[],
+  Index extends number = Accumulated["length"]
+> = Index extends Length
+  ? Accumulated
+  : _UnionTupleInput<
+      Tuple,
+      Length,
+      [...Accumulated, UnknownToInput<Tuple[Index]>]
+    >;
+
 export const string: Schema<string>;
 export const boolean: Schema<boolean>;
 export const integer: Schema<number>;
@@ -108,6 +170,7 @@ export function literal(value: undefined): Schema<undefined>;
 export function literal(value: null): Schema<null>;
 export function literal<T>(value: T): Schema<T>;
 
+// TODO: Deprecate for V9
 export function tuple(schemas: []): Schema<[]>;
 export function tuple<Output, Input>(
   schemas: [Schema<Output, Input>]
@@ -161,33 +224,13 @@ export const jsonString: <Output>(
   space?: number
 ) => Schema<Output, string>;
 
-export const union: <A extends UnknownSchema, B extends UnknownSchema[]>(
+export const union: <A, B extends unknown[]>(
   schemas: [A, ...B]
 ) => Schema<
-  Output<A> | SchemaTupleOutput<B>[number],
-  Input<A> | SchemaTupleInput<B>[number]
+  UnknownToOuput<A> | SchemaUnionTupleOutput<B>[number],
+  UnknownToInput<A> | SchemaUnionTupleInput<B>[number]
 >;
 
-type UnknownToOuput<T> = T extends Schema<unknown>
-  ? Output<T>
-  : T extends {
-      [k in keyof T]: unknown;
-    }
-  ? {
-      [k in keyof T]: UnknownToOuput<T[k]>;
-    }
-  : T;
-
-type UnknownToInput<T> = T extends Schema<unknown>
-  ? Input<T>
-  : T extends {
-      [k in keyof T]: unknown;
-    }
-  ? {
-      [k in keyof T]: UnknownToInput<T[k]>;
-    }
-  : T;
-
 /**
  * @deprecated Pass the Schema directly instead of using the s.matches method
  */
@@ -214,6 +257,9 @@ export function object<Output>(
     tag: (name: string, value: unknown) => void;
   }) => Output
 ): Schema<Output, unknown>;
+/**
+ * @deprecated Will be removed in V9. Use S.schema instead
+ */
 export function object<
   Shape extends {
     [k in keyof Shape]: unknown;
@@ -388,6 +434,9 @@ export const trim: <Input>(
 
 export type UnknownKeys = "Strip" | "Strict";
 
+/**
+ * @deprecated Will be removed in V9
+ */
 export function unwrap<Value>(result: Result<Value>): Value;
 
 export type GlobalConfigOverride = {

src/S.js

@@ -16,7 +16,7 @@ export const nullish = S.nullable;
 export const array = S.array;
 export const record = S.dict;
 export const jsonString = S.jsonString;
-export const union = S.union;
+export const union = S.js_union;
 export const object = S.js_object;
 export const schema = S.schema;
 export const safe = S.js_safe;

src/S_Core.bs.mjs

@@ -3008,6 +3008,10 @@ function unwrap(result) {
   throw result._0;
 }
 
+function js_union(values) {
+  return factory$7(values.map(definitionToSchema));
+}
+
 function js_transform(schema, maybeParser, maybeSerializer) {
   return transform$1(schema, (function (s) {
                 return {
@@ -3413,6 +3417,7 @@ export {
   trim ,
   js_safe ,
   js_safeAsync ,
+  js_union ,
   js_parseAsyncWith ,
   js_optional ,
   js_tuple ,

src/S_Core.res

@@ -4152,6 +4152,8 @@ let unwrap = result => {
 // JS/TS API
 // =============
 
+let js_union = values => Union.factory(values->Js.Array2.map(Schema.definitionToSchema))
+
 let js_transform = (schema, ~parser as maybeParser=?, ~serializer as maybeSerializer=?) => {
   schema->transform(s => {
     {

src/S_Core.resi

@@ -421,6 +421,8 @@ type jsResult<'value>
 let js_safe: (unit => 'v) => jsResult<'v>
 let js_safeAsync: (unit => promise<'v>) => promise<jsResult<'v>>
 
+let js_union: array<unknown> => t<'value>
+
 // TODO: Replace parseAsyncWith with it in V9
 let js_parseAsyncWith: (Js.Json.t, t<'value>) => promise<'value>