@fncts/base 0.0.18 → 0.0.20

package/_mjs/data/EnvironmentPatch.mjs

@@ -0,0 +1,184 @@
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/List/definition";
+import * as tsplus_module_2 from "@fncts/base/data/Environment/api";
+import * as tsplus_module_3 from "@fncts/base/collection/immutable/List/constructors";
+import * as tsplus_module_4 from "@fncts/base/collection/immutable/HashMap/api";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_6 from "@fncts/base/collection/compat/Array/api";
+export const combine = combine_1;
+export const empty = empty_1;
+export const EnvironmentPatchTypeId = /*#__PURE__*/Symbol.for("fncts.Environment.Patch");
+/**
+ * @tsplus type fncts.Environment.Patch
+ * @tsplus companion fncts.Environment.PatchOps
+ */
+
+export class EnvironmentPatch {
+  constructor() {
+    this._typeId = EnvironmentPatchTypeId;
+  }
+
+}
+export class AddService extends EnvironmentPatch {
+  constructor(service, tag) {
+    super();
+    this.service = service;
+    this.tag = tag;
+    this._tag = 0
+    /* EnvironmentPatchTag.AddService */
+    ;
+  }
+
+}
+export class Combine extends EnvironmentPatch {
+  constructor(first, second) {
+    super();
+    this.first = first;
+    this.second = second;
+    this._tag = 3
+    /* EnvironmentPatchTag.Combine */
+    ;
+  }
+
+}
+export class Empty extends EnvironmentPatch {
+  constructor() {
+    super(...arguments);
+    this._tag = 4
+    /* EnvironmentPatchTag.Empty */
+    ;
+  }
+
+}
+export class RemoveService extends EnvironmentPatch {
+  constructor(tag) {
+    super();
+    this.tag = tag;
+    this._tag = 1
+    /* EnvironmentPatchTag.RemoveService */
+    ;
+  }
+
+}
+export class UpdateService extends EnvironmentPatch {
+  constructor(update, tag) {
+    super();
+    this.update = update;
+    this.tag = tag;
+    this._tag = 2
+    /* EnvironmentPatchTag.UpdateService */
+    ;
+  }
+
+}
+/**
+ * @tsplus macro remove
+ */
+
+export function concrete(_) {//
+}
+/**
+ * @tsplus tailRec
+ */
+
+function applyLoop(environment, patches) {
+  var environment_1 = environment,
+      patches_1 = patches;
+  var environment_2 = environment,
+      patches_2 = patches;
+
+  while (1) {
+    if (tsplus_module_1.isEmpty(patches_1)) {
+      return environment_1;
+    }
+
+    const head = patches_1.head;
+    const tail = patches_1.tail;
+    void 0;
+
+    switch (head._tag) {
+      case 0
+      /* EnvironmentPatchTag.AddService */
+      :
+        environment_2 = tsplus_module_2.add(environment_1, head.service, head.tag);
+        patches_2 = tail;
+        environment_1 = environment_2;
+        patches_1 = patches_2;
+        continue;
+
+      case 3
+      /* EnvironmentPatchTag.Combine */
+      :
+        environment_2 = environment_1;
+        patches_2 = tsplus_module_3.cons(head.first, tsplus_module_3.cons(head.second, tail));
+        environment_1 = environment_2;
+        patches_1 = patches_2;
+        continue;
+
+      case 4
+      /* EnvironmentPatchTag.Empty */
+      :
+        environment_2 = environment_1;
+        patches_2 = tail;
+        environment_1 = environment_2;
+        patches_1 = patches_2;
+        continue;
+
+      case 1
+      /* EnvironmentPatchTag.RemoveService */
+      :
+        environment_2 = environment_1;
+        patches_2 = tail;
+        environment_1 = environment_2;
+        patches_1 = patches_2;
+        continue;
+
+      case 2
+      /* EnvironmentPatchTag.UpdateService */
+      :
+        environment_2 = tsplus_module_2.update(environment_1, head.update, head.tag);
+        patches_2 = tail;
+        environment_1 = environment_2;
+        patches_1 = patches_2;
+        continue;
+    }
+  }
+}
+/**
+ * @tsplus fluent fncts.Environment.Patch __call
+ */
+
+
+export function apply(patch, environment) {
+  return applyLoop(environment, tsplus_module_3.cons(patch));
+}
+/**
+ * @tsplus fluent fncts.Environment.Patch combine
+ */
+
+function combine_1(self, that) {
+  return new Combine(self, that);
+}
+/**
+ * @tsplus static fncts.Environment.PatchOps diff
+ */
+
+
+export function diff(oldValue, newValue) {
+  const sorted = tsplus_module_4.toArray(newValue.map);
+  const [missingServices, patch] = tsplus_module_6.foldLeft(sorted, [tsplus_module_4.beginMutation(oldValue.map), empty_1()], ([map, patch], [tag, newService]) => tsplus_module_5.match_(tsplus_module_4.get_(map, tag), () => [tsplus_module_4.remove_(map, tag), combine_1(patch, new AddService(newService, tag))], oldService => {
+    if (oldService === newService) {
+      return [tsplus_module_4.remove_(map, tag), patch];
+    } else {
+      return [tsplus_module_4.remove_(map, tag), combine_1(patch, new UpdateService(_ => newService, tag))];
+    }
+  }));
+  return tsplus_module_4.foldLeftWithIndex_(missingServices, patch, (tag, patch) => combine_1(patch, new RemoveService(tag)));
+}
+/**
+ * @tsplus static fncts.Environment.PatchOps empty
+ */
+
+function empty_1() {
+  return new Empty();
+}
+//# sourceMappingURL=EnvironmentPatch.mjs.map

package/_mjs/data/EnvironmentPatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentPatch.mjs","mappings":"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","names":["combine","empty","EnvironmentPatchTypeId","Symbol","for","EnvironmentPatch","constructor","AddService","service","tag","Combine","first","second","Empty","RemoveService","UpdateService","update","concrete","_","applyLoop","environment","patches","patches_1","patches_2","tsplus_module_1","head","tail","_tag","tsplus_module_2","tsplus_module_3","apply","patch","self","that","diff","oldValue","newValue","sorted","map","missingServices","tsplus_module_6","empty_1","newService","tsplus_module_5","tsplus_module_4","combine_1","oldService"],"sourceRoot":"","sources":["../../_src/data/EnvironmentPatch.ts"],"sourcesContent":[null]}

package/_src/collection/weak/IterableWeakMap.ts

@@ -12,7 +12,7 @@ export class IterableWeakMap<K extends object, V> implements Iterable<readonly [
     set.delete(ref);
   }
 
-  constructor(iterable: Iterable<readonly [K, V]>) {
+  constructor(iterable: Iterable<readonly [K, V]> = Iterable.empty()) {
     for (const [key, value] of iterable) {
       this.set(key, value);
     }

package/_src/data/Branded/definition.ts

@@ -1,51 +1,54 @@
 import type { Union } from "@fncts/typelevel";
 
-type Brand_<A, K extends string> = Brand<A, K>;
+declare const validSym: unique symbol;
 
-export declare namespace Branded {
-  const Symbol: unique symbol;
-  export type Symbol = typeof Symbol;
+export declare namespace Brand {
+  export type valid = typeof validSym;
 
-  export interface Brand<A, K extends string> {
-    readonly [Branded.Symbol]: {
+  /**
+   * @tsplus derive nominal
+   */
+  export interface Valid<in out A, in out K extends string> {
+    [validSym]: {
       [_ in K]: A;
     };
   }
 
-  export type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
+  export type Type<A extends Validation<any, any>> = A extends Validation<infer A, infer K> ? Validated<A, K> : never;
 
-  export type Validated<A, K extends string> = A & Brand<A, K>;
+  export type Validated<A, K extends string> = A & Brand.Valid<A, K>;
 
-  export type IsValidated<P extends Brand<any, any>> = {
-    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1;
-  }[keyof P[Branded.Symbol]] extends 0
+  export type IsValidated<P extends Valid<any, any>> = {
+    [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K] ? 0 : 1;
+  }[keyof P[Brand.valid]] extends 0
     ? unknown
     : never;
 
-  export type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
+  export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
 
-  export type Brands<P extends Brand<any, any>> = Union.IntersectionOf<
+  export type Brands<P> = P extends Valid<any, any> ? Union.IntersectionOf<
     {
-      [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K]
+      [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
         ? K extends string
-          ? Brand<P[Branded.Symbol][K], K>
+          ? Valid<P[Brand.valid][K], K>
           : never
         : never;
-    }[keyof P[Branded.Symbol]]
-  >;
+    }[keyof P[Brand.valid]]
+  > : unknown;
 }
 
 /**
- * @tsplus type fncts.Brand
- * @tsplus companion fncts.BrandOps
+ * @tsplus type fncts.Validation
+ * @tsplus companion fncts.ValidationOps
+ * @tsplus derive nominal
  */
-export class Brand<A, K extends string> {
-  constructor(readonly validate: Refinement<A, A & Branded.Brand<A, K>>) {}
+export class Validation<in out A, in out K extends string> {
+  constructor(readonly validate: Refinement<A, A & Brand.Valid<A, K>>) {}
 }
 
 /**
- * @tsplus static fncts.BrandOps __call
+ * @tsplus static fncts.ValidationOps __call
  */
-export function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K> {
-  return new Brand(p as Refinement<A, A & Branded.Brand<A, K>>);
+export function makeValidation<A, K extends string>(p: Predicate<A>): Validation<A, K> {
+  return new Validation(p as Refinement<A, A & Brand.Valid<A, K>>);
 }

package/_src/data/Branded/derivations.ts

@@ -1,4 +1,4 @@
-import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Validation, Brand } from "@fncts/base/data/Branded/definition";
 import type { Check } from "@fncts/typelevel/Check";
 
 import { BrandedError, CompoundError } from "@fncts/base/data/DecodeError";
@@ -7,29 +7,29 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus derive fncts.Guard<_> 10
  */
-export function deriveGuard<A extends Branded.Brand<any, any>>(
-  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+export function deriveGuard<A extends Brand.Valid<any, any>>(
+  ...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True
     ? [
-        base: Guard<Branded.Unbrand<A>>,
+        base: Guard<Brand.Unbranded<A>>,
         brands: {
-          [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+          [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
         },
       ]
     : never
 ): Guard<A> {
-  const validations = Object.values(brands) as ReadonlyArray<Brand<A, any>>;
+  const validations = Object.values(brands) as ReadonlyArray<Validation<A, any>>;
   return Guard((u): u is A => base.is(u) && validations.every((brand) => brand.validate(u)));
 }
 
 /**
  * @tsplus derive fncts.Decoder<_> 10
  */
-export function deriveDecoder<A extends Branded.Brand<any, any>>(
-  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+export function deriveDecoder<A extends Brand.Valid<any, any>>(
+  ...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True
     ? [
-        base: Decoder<Branded.Unbrand<A>>,
+        base: Decoder<Brand.Unbranded<A>>,
         brands: {
-          [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+          [K in (keyof A[Brand.valid]) & string]: Validation<A[Brand.valid][K], K>;
         },
       ]
     : never

package/_src/data/Decoder/api.ts

@@ -17,7 +17,7 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus fluent fncts.Decoder __call
  */
-export function decode<I, E, A>(self: Decoder<A>, input: unknown): These<DecodeError, A> {
+export function decode<A>(self: Decoder<A>, input: unknown): These<DecodeError, A> {
   return self.decode(input);
 }
 

package/_src/data/Decoder/definition.ts

@@ -13,10 +13,10 @@ export interface DecoderF extends HKT {
 /**
  * @tsplus type fncts.Decoder
  * @tsplus companion fncts.DecoderOps
+ * @tsplus derive nominal
  */
-export class Decoder<A> {
+export class Decoder<in out A> {
   readonly _typeId: DecoderTypeId = DecoderTypeId;
-  readonly _A!: () => A;
   constructor(readonly decode: (input: unknown) => These<DecodeError, A>, readonly label: string) {}
 }
 

package/_src/data/Environment/definition.ts

@@ -1,3 +1,5 @@
+import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
+
 /**
  * @tsplus static fncts.prelude.builtin.SymbolOps env
  */
@@ -26,6 +28,10 @@ export class Environment<R> implements Hashable, Equatable {
   }
 }
 
+export declare namespace Environment {
+  type Patch<In, Out> = EnvironmentPatch<In, Out>;
+}
+
 export function isEnvironment(u: unknown): u is Environment<unknown> {
   return hasTypeId(u, EnvSymbol);
 }

package/_src/data/EnvironmentPatch.ts

@@ -0,0 +1,136 @@
+export const enum EnvironmentPatchTag {
+  AddService,
+  RemoveService,
+  UpdateService,
+  Combine,
+  Empty,
+}
+
+export const EnvironmentPatchTypeId = Symbol.for("fncts.Environment.Patch");
+export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
+
+/**
+ * @tsplus type fncts.Environment.Patch
+ * @tsplus companion fncts.Environment.PatchOps
+ */
+export abstract class EnvironmentPatch<In, Out> {
+  readonly _typeId: EnvironmentPatchTypeId = EnvironmentPatchTypeId;
+  readonly _R!: (_: In) => void;
+  readonly _A!: () => Out;
+}
+
+export class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {
+  readonly _tag = EnvironmentPatchTag.AddService;
+  constructor(readonly service: Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class Combine<In, Out, Out2> extends EnvironmentPatch<In, Out2> {
+  readonly _tag = EnvironmentPatchTag.Combine;
+  constructor(readonly first: EnvironmentPatch<In, Out>, readonly second: EnvironmentPatch<Out, Out2>) {
+    super();
+  }
+}
+
+export class Empty<Env> extends EnvironmentPatch<Env, Env> {
+  readonly _tag = EnvironmentPatchTag.Empty;
+}
+
+export class RemoveService<Env, Service> extends EnvironmentPatch<Env & Has<Service>, Env> {
+  readonly _tag = EnvironmentPatchTag.RemoveService;
+  constructor(readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class UpdateService<Env, Service> extends EnvironmentPatch<Env & Has<Service>, Env & Has<Service>> {
+  readonly _tag = EnvironmentPatchTag.UpdateService;
+  constructor(readonly update: (_: Service) => Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export type Concrete =
+  | AddService<any, any>
+  | Combine<any, any, any>
+  | Empty<any>
+  | RemoveService<any, any>
+  | UpdateService<any, any>;
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete(_: EnvironmentPatch<any, any>): asserts _ is Concrete {
+  //
+}
+
+/**
+ * @tsplus tailRec
+ */
+function applyLoop(environment: Environment<any>, patches: List<EnvironmentPatch<any, any>>): Environment<any> {
+  if (patches.isEmpty()) {
+    return environment;
+  }
+  const head = patches.head;
+  const tail = patches.tail;
+  concrete(head);
+  switch (head._tag) {
+    case EnvironmentPatchTag.AddService:
+      return applyLoop(environment.add(head.service, head.tag), tail);
+    case EnvironmentPatchTag.Combine:
+      return applyLoop(environment, Cons(head.first, Cons(head.second, tail)));
+    case EnvironmentPatchTag.Empty:
+      return applyLoop(environment, tail);
+    case EnvironmentPatchTag.RemoveService:
+      return applyLoop(environment, tail);
+    case EnvironmentPatchTag.UpdateService:
+      return applyLoop(environment.update(head.update, head.tag), tail);
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Environment.Patch __call
+ */
+export function apply<In, Out>(patch: EnvironmentPatch<In, Out>, environment: Environment<In>): Environment<Out> {
+  return applyLoop(environment, Cons(patch));
+}
+
+/**
+ * @tsplus fluent fncts.Environment.Patch combine
+ */
+export function combine<In, Out, Out2>(
+  self: EnvironmentPatch<In, Out>,
+  that: EnvironmentPatch<Out, Out2>,
+): EnvironmentPatch<In, Out2> {
+  return new Combine(self, that);
+}
+
+/**
+ * @tsplus static fncts.Environment.PatchOps diff
+ */
+export function diff<In, Out>(oldValue: Environment<In>, newValue: Environment<Out>): EnvironmentPatch<In, Out> {
+  const sorted                   = newValue.map.toArray;
+  const [missingServices, patch] = sorted.foldLeft(
+    [oldValue.map.beginMutation, EnvironmentPatch.empty() as EnvironmentPatch<any, any>],
+    ([map, patch], [tag, newService]) =>
+      map.get(tag).match(
+        () => [map.remove(tag), patch.combine(new AddService(newService, tag))],
+        (oldService) => {
+          if (oldService === newService) {
+            return [map.remove(tag), patch];
+          } else {
+            return [map.remove(tag), patch.combine(new UpdateService((_: any) => newService, tag))];
+          }
+        },
+      ),
+  );
+  return missingServices.foldLeftWithIndex(patch, (tag, patch) => patch.combine(new RemoveService(tag)));
+}
+
+/**
+ * @tsplus static fncts.Environment.PatchOps empty
+ */
+export function empty<A>(): EnvironmentPatch<A, A> {
+  return new Empty();
+}

package/_src/data.ts

@@ -11,6 +11,7 @@ export type {} from "./data/Decoder.js";
 export type {} from "./data/Duration.js";
 export type {} from "./data/Either.js";
 export type {} from "./data/Environment.js";
+export type {} from "./data/EnvironmentPatch.js";
 export type {} from "./data/exceptions.js";
 export type {} from "./data/ExecutionStrategy.js";
 export type {} from "./data/Exit.js";
@@ -23,7 +24,6 @@ export type {} from "./data/Maybe.js";
 export type {} from "./data/Newtype.js";
 export type {} from "./data/number.js";
 export type {} from "./data/object.js";
-export type {} from "./data/Patch.js";
 export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
 export type {} from "./data/string.js";

package/_src/global.ts

@@ -110,7 +110,7 @@ import { DatumEither } from "@fncts/base/data/DatumEither/definition";
 /**
  * @tsplus global
  */
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus global
  */
@@ -123,6 +123,10 @@ import { Either } from "@fncts/base/data/Either/definition";
  * @tsplus global
  */
 import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
 /**
  * @tsplus global
  */

package/collection/compat/Array/derivations.d.ts

@@ -1,5 +1,5 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import { These } from "@fncts/base/data/These";
 import type { Check } from "@fncts/typelevel/Check";
 /**

package/collection/compat/Record/instances.d.ts

@@ -1,5 +1,5 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard<_> 15

package/collection/immutable/Conc/derivations.d.ts

@@ -1,6 +1,6 @@
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.Conc]<_> 10

package/collection/immutable/ImmutableArray/derivations.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10

package/collection/immutable/ImmutableNonEmptyArray/derivations.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10

package/collection/weak/IterableWeakMap.d.ts

@@ -6,7 +6,7 @@ export declare class IterableWeakMap<K extends object, V> implements Iterable<re
     private refSet;
     private finalizationGroup;
     private static cleanup;
-    constructor(iterable: Iterable<readonly [K, V]>);
+    constructor(iterable?: Iterable<readonly [K, V]>);
     set(this: this, key: K, value: V): this;
     get(this: this, key: K): V | undefined;
     delete(this: this, key: K): boolean;

package/data/Branded/definition.d.ts

@@ -1,36 +1,39 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type { Union } from "@fncts/typelevel";
-type Brand_<A, K extends string> = Brand<A, K>;
-export declare namespace Branded {
-    const Symbol: unique symbol;
-    type Symbol = typeof Symbol;
-    interface Brand<A, K extends string> {
-        readonly [Branded.Symbol]: {
+declare const validSym: unique symbol;
+export declare namespace Brand {
+    type valid = typeof validSym;
+    /**
+     * @tsplus derive nominal
+     */
+    interface Valid<in out A, in out K extends string> {
+        [validSym]: {
             [_ in K]: A;
         };
     }
-    type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
-    type Validated<A, K extends string> = A & Brand<A, K>;
-    type IsValidated<P extends Brand<any, any>> = {
-        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1;
-    }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
-    type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
-    type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
-        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? K extends string ? Brand<P[Branded.Symbol][K], K> : never : never;
-    }[keyof P[Branded.Symbol]]>;
+    type Type<A extends Validation<any, any>> = A extends Validation<infer A, infer K> ? Validated<A, K> : never;
+    type Validated<A, K extends string> = A & Brand.Valid<A, K>;
+    type IsValidated<P extends Valid<any, any>> = {
+        [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K] ? 0 : 1;
+    }[keyof P[Brand.valid]] extends 0 ? unknown : never;
+    type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
+    type Brands<P> = P extends Valid<any, any> ? Union.IntersectionOf<{
+        [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K] ? K extends string ? Valid<P[Brand.valid][K], K> : never : never;
+    }[keyof P[Brand.valid]]> : unknown;
 }
 /**
- * @tsplus type fncts.Brand
- * @tsplus companion fncts.BrandOps
+ * @tsplus type fncts.Validation
+ * @tsplus companion fncts.ValidationOps
+ * @tsplus derive nominal
  */
-export declare class Brand<A, K extends string> {
-    readonly validate: Refinement<A, A & Branded.Brand<A, K>>;
-    constructor(validate: Refinement<A, A & Branded.Brand<A, K>>);
+export declare class Validation<in out A, in out K extends string> {
+    readonly validate: Refinement<A, A & Brand.Valid<A, K>>;
+    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>);
 }
 /**
- * @tsplus static fncts.BrandOps __call
+ * @tsplus static fncts.ValidationOps __call
  * @tsplus location "@fncts/base/data/Branded/definition"
  */
-export declare function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K>;
+export declare function makeValidation<A, K extends string>(p: Predicate<A>): Validation<A, K>;
 export {};