@fncts/schema 0.0.6 → 0.0.8

package/_src/Schema/api/either.ts

@@ -0,0 +1,96 @@
+import type { EitherJson } from "@fncts/base/json/EitherJson";
+
+import { EitherTypeId, EitherVariance } from "@fncts/base/data/Either";
+import { IOTypeId } from "@fncts/io/IO";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps either
+ */
+export function either<E, A>(left: Schema<E>, right: Schema<A>): Schema<Either<E, A>> {
+  return Schema.declaration(
+    Vector(left, right),
+    eitherInline(left, right),
+    eitherParser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "Either"),
+  );
+}
+
+function eitherJson<E, A>(left: Schema<E>, right: Schema<A>): Schema<EitherJson<E, A>> {
+  return Schema.union(
+    Schema.struct({
+      _tag: Schema.literal("Left"),
+      left,
+    }),
+    Schema.struct({
+      _tag: Schema.literal("Right"),
+      right,
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps eitherFromJson
+ */
+export function eitherFromJson<E, A>(left: Schema<E>, right: Schema<A>): Schema<Either<E, A>> {
+  return eitherJson(left, right).transform(
+    either(left, right),
+    (input) => {
+      if (input._tag === "Left") {
+        return Either.left(input.left);
+      } else {
+        return Either.right(input.right);
+      }
+    },
+    (input) => {
+      Either.concrete(input);
+      if (input.isLeft()) {
+        return {
+          _tag: "Left",
+          left: input.left,
+        } as const;
+      } else {
+        return {
+          _tag: "Right",
+          right: input.right,
+        } as const;
+      }
+    },
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Either]<_> 10
+ */
+export function deriveEither<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer _E, infer _A>]
+    ? Check<Check.IsEqual<A, Either<_E, _A>>> extends Check.True
+      ? [left: Schema<_E>, right: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(eitherFromJson(left, right));
+}
+
+function eitherParser<E, A>(left: Schema<E>, right: Schema<A>): Parser<Either<E, A>> {
+  const schema = either(left, right);
+  return Parser.make((u, options) => {
+    if (!Either.isEither(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    Either.concrete(u);
+    if (u.isLeft()) {
+      return left.decode(u.left, options).map(Either.left);
+    } else {
+      return right.decode(u.right, options).map(Either.right);
+    }
+  });
+}
+
+function eitherInline<E, A>(_left: Schema<E>, _right: Schema<A>): Schema<Either<E, A>> {
+  return Schema.struct({
+    [EitherTypeId]: Schema.uniqueSymbol(EitherTypeId),
+    [EitherVariance]: Schema.any,
+    [IOTypeId]: Schema.uniqueSymbol(IOTypeId),
+    trace: Schema.undefined,
+  }) as unknown as Schema<Either<E, A>>;
+}

package/_src/Schema.ts

@@ -1,4 +1,14 @@
 // codegen:start { preset: barrel, include: ./Schema/*.ts }
 export * from "./Schema/api.js";
 export * from "./Schema/definition.js";
+export * from "./Schema/derivations.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Schema/api/*.ts }
+export * from "./Schema/api/conc.js";
+export * from "./Schema/api/either.js";
+export * from "./Schema/api/hashMap.js";
+export * from "./Schema/api/immutableArray.js";
+export * from "./Schema/api/list.js";
+export * from "./Schema/api/maybe.js";
 // codegen:end

package/_src/global.ts

@@ -51,6 +51,10 @@ import { ParseResult } from "@fncts/schema/ParseResult";
  * @tsplus global
  */
 import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/schema/Schema"
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -50,6 +50,10 @@ import { ParseResult } from "@fncts/schema/ParseResult";
  * @tsplus global
  */
 import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/schema/Schema";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/schema",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "dependencies": {
-    "@fncts/base": "0.0.27",
+    "@fncts/base": "0.0.29",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {