@fncts/schema 0.0.4 → 0.0.6

package/_src/Schema/api/immutableArray.ts

@@ -0,0 +1,88 @@
+import type { Sized } from "@fncts/test/control/Sized";
+
+import {
+  ImmutableArray,
+  ImmutableArrayTypeId,
+  ImmutableArrayVariance,
+} from "@fncts/base/collection/immutable/ImmutableArray";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+
+/**
+ * @tsplus getter fncts.schema.Schema immutableArray
+ * @tsplus static fncts.schema.SchemaOps immutableArray
+ */
+export function immutableArray<A>(value: Schema<A>): Schema<ImmutableArray<A>> {
+  return Schema.declaration(
+    Vector(value),
+    inline(value),
+    parser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "ImmutableArray").annotate(ASTAnnotation.GenHook, gen),
+  );
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema immutableArrayFromArray
+ * @tsplus static fncts.schema.SchemaOps immutableArrayFromArray
+ */
+export function immutableArrayFromArray<A>(value: Schema<A>): Schema<ImmutableArray<A>> {
+  return Schema.array(value).transform(
+    immutableArray(value),
+    (input) => new ImmutableArray(input),
+    (input) => input._array,
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.ImmutableArray]<_> 10
+ */
+export function deriveImmutableArray<A extends ImmutableArray<any>>(
+  ...[value]: [A] extends [ImmutableArray<infer _A>]
+    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
+      ? [value: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(immutableArrayFromArray(value));
+}
+
+function parser<A>(value: Schema<A>): Parser<ImmutableArray<A>> {
+  const schema = immutableArray(value);
+  return Parser.make((u, options) => {
+    if (!ImmutableArray.is(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    const out: Array<A> = [];
+    const errors        = Vector.emptyPushable<ParseError>();
+    const allErrors     = options?.allErrors;
+    const index         = 0;
+    for (const v of u) {
+      const t = value.decode(v, options);
+      Either.concrete(t);
+      if (t.isLeft()) {
+        errors.push(ParseError.IndexError(index, t.left));
+        if (allErrors) {
+          continue;
+        }
+        return ParseResult.failures(errors);
+      } else {
+        out.push(t.right);
+      }
+    }
+    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(new ImmutableArray(out));
+  });
+}
+
+function inline<A>(value: Schema<A>): Schema<ImmutableArray<A>> {
+  return Schema.struct({
+    [ImmutableArrayTypeId]: Schema.uniqueSymbol(ImmutableArrayTypeId),
+    [ImmutableArrayVariance]: Schema.any,
+    _array: Schema.array(value),
+    [Symbol.equals]: Schema.any,
+    [Symbol.hash]: Schema.any,
+    [Symbol.iterator]: Schema.any,
+  });
+}
+
+function gen<A>(value: Gen<Sized, A>): Gen<Sized, ImmutableArray<A>> {
+  return Gen.array(value).map((array) => new ImmutableArray(array));
+}

package/_src/Schema/api/list.ts

@@ -0,0 +1,96 @@
+import type { Sized } from "@fncts/test/control/Sized";
+
+import { ListTypeId } from "@fncts/base/collection/immutable/List";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps list
+ * @tsplus getter fncts.Schema.Schema list
+ */
+export function list<A>(value: Schema<A>): Schema<List<A>> {
+  return Schema.declaration(
+    Vector(value),
+    inline(value),
+    parser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "List").annotate(ASTAnnotation.GenHook, gen),
+  );
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps listFromArray
+ * @tsplus getter fncts.Schema.Schema listFromArray
+ */
+export function listFromArray<A>(value: Schema<A>): Schema<List<A>> {
+  return Schema.array(value).transform(
+    list(value),
+    (input) => List.from(input),
+    (input) => Array.from(input),
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.List]<_> 10
+ */
+export function deriveList<A extends List<any>>(
+  ...[value]: [A] extends [List<infer _A>]
+    ? Check<Check.IsEqual<A, List<_A>>> extends Check.True
+      ? [value: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(listFromArray(value));
+}
+
+function parser<A>(value: Schema<A>): Parser<List<A>> {
+  const schema = list(value);
+  return Parser.make((u, options) => {
+    if (!List.is(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    const out       = new ListBuffer<A>();
+    const errors    = Vector.emptyPushable<ParseError>();
+    const allErrors = options?.allErrors;
+    const index     = 0;
+    for (const v of u) {
+      const t = value.decode(v, options);
+      Either.concrete(t);
+      if (t.isLeft()) {
+        errors.push(ParseError.IndexError(index, t.left));
+        if (allErrors) {
+          continue;
+        }
+        return ParseResult.failures(errors);
+      } else {
+        out.append(t.right);
+      }
+    }
+    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(out.toList);
+  });
+}
+
+function nil<A>(_value: Schema<A>): Schema<Nil<A>> {
+  return Schema.struct({
+    _tag: Schema.literal("Nil"),
+    [ListTypeId]: Schema.uniqueSymbol(ListTypeId),
+    [Symbol.iterator]: Schema.any,
+  });
+}
+
+function cons<A>(value: Schema<A>): Schema<Cons<A>> {
+  return Schema.lazy(() =>
+    Schema.struct({
+      _tag: Schema.literal("Cons"),
+      [ListTypeId]: Schema.uniqueSymbol(ListTypeId),
+      [Symbol.iterator]: Schema.any,
+      head: value,
+      tail: inline(value),
+    }),
+  );
+}
+
+function inline<A>(value: Schema<A>): Schema<List<A>> {
+  return Schema.lazy(() => Schema.union(nil(value), cons(value)));
+}
+
+function gen<A>(value: Gen<Sized, A>): Gen<Sized, List<A>> {
+  return Gen.array(value).map((array) => List.from(array));
+}

package/_src/Schema/api/maybe.ts

@@ -0,0 +1,68 @@
+import type { Check } from "@fncts/typelevel";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps maybe
+ * @tsplus getter fncts.schema.Schema maybe
+ */
+export function maybe<A>(value: Schema<A>): Schema<Maybe<A>> {
+  return Schema.declaration(
+    Vector(value),
+    maybeInline(value),
+    maybeParser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "Maybe"),
+  );
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps maybeFromNullable
+ * @tsplus getter fncts.schema.Schema maybeFromNullable
+ */
+export function maybeFromNullable<A>(value: Schema<A>): Schema<Maybe<A>> {
+  return Schema.union(Schema.undefined, value.nullable).transform(value.maybe, Maybe.fromNullable, (input) =>
+    input.getOrElse(null),
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Maybe]<_> 10
+ */
+export function deriveMaybe<A extends Maybe<any>>(
+  ...[value]: [A] extends [Maybe<infer _A>]
+    ? Check<Check.IsEqual<A, Maybe<_A>>> extends Check.True
+      ? [value: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(maybeFromNullable(value));
+}
+
+function maybeParser<A>(value: Schema<A>): Parser<Maybe<A>> {
+  const schema = maybe(value);
+  return Parser.make((u, options) => {
+    if (!Maybe.isMaybe(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    Maybe.concrete(u);
+    if (u.isNothing()) {
+      return ParseResult.succeed(Nothing());
+    } else {
+      return value.decode(u.value, options).map((a) => Just(a));
+    }
+  });
+}
+
+function maybeInline<A>(value: Schema<A>): Schema<Maybe<A>> {
+  return Schema.union(
+    Schema.struct({
+      _tag: Schema.literal("Nothing"),
+      [Symbol.equals]: Schema.any,
+      [Symbol.hash]: Schema.any,
+    }),
+    Schema.struct({
+      _tag: Schema.literal("Just"),
+      value,
+      [Symbol.equals]: Schema.any,
+      [Symbol.hash]: Schema.any,
+    }),
+  ) as unknown as Schema<Maybe<A>>;
+}