tuple-ts 0.4.7 → 0.6.0

package/README.md

@@ -1,13 +1,13 @@
 # tuple-ts
 
-**Immutable tuples and structs with value-based identity for JavaScript and TypeScript.**
+**Immutable tuples, records and structs with value-based identity for JavaScript and TypeScript.**
 
 JavaScript normally compares arrays and objects by reference:
 
 ```ts
 [1, 2] === [1, 2] // false
 
-{ x: 1 } === { x: 1 } // false
+({ x: 1 }) === ({ x: 1 }) // false
 ```
 
 `tuple-ts` gives you a different model:
@@ -15,12 +15,12 @@ JavaScript normally compares arrays and objects by reference:
 ```ts
 tuple(1, 2) === tuple(1, 2) // true
 
-struct({ x: 1 }) === struct({ x: 1 }) // true
+record({ x: 1 }) === record({ x: 1 }) // true
 ```
 
 Equal values are **interned to the same object**.
 
-That makes tuples and structs immutable, naturally usable as composite `Map` keys and `Set` values, and particularly pleasant to use in functional TypeScript.
+That makes tuples, records and structs immutable, naturally usable as composite `Map` keys and `Set` values, and particularly pleasant to use in functional TypeScript.
 
 **Zero dependencies · Less than 1 KB gzipped**
 
@@ -148,12 +148,31 @@ a === c; // false
 
 ## Typed tuples
 
-You can create a reusable constructor for a particular tuple type:
+Use `tuple.like()` to create a reusable constructor for a particular tuple type.
+
+### Inferring the type from an exemplar
+
+```ts
+const Point = tuple.like(0, 0);
+
+const a = Point(10, 20);
+const b = Point(10, 20);
+
+a === b; // true
+```
+
+The exemplar determines the TypeScript type expected by the resulting factory. Its values are not used as defaults.
+
+By default, TypeScript widens the exemplar's literal types, so `tuple.like(0, 0)` produces a factory accepting two numbers.
+
+### Explicit type arguments
+
+Alternatively, specify the type directly:
 
 ```ts
 type Point = [x: number, y: number];
 
-const Point = tuple<Point>;
+const Point = tuple.like<Point>();
 
 const a = Point(10, 20);
 const b = Point(10, 20);
@@ -161,21 +180,34 @@ const b = Point(10, 20);
 a === b; // true
 ```
 
-The result retains the tuple's TypeScript type while gaining the same runtime identity semantics.
+No exemplar is required when the type argument is provided explicitly.
 
-## Structs
+### Preserving literal types
 
-`struct` provides the same semantics for objects:
+To preserve literal types rather than widen them, use `as const`:
 
 ```ts
-import { struct } from "tuple-ts";
+const Direction = tuple.like("north" as const, 1 as const);
+
+Direction("north", 1); // OK
+Direction("south", 1); // TypeScript error
+```
+
+In all cases, the resulting tuples are frozen and interned using the same shared cache as ordinary tuples.
+
+## Records
+
+`record` provides the same value-based identity semantics for objects:
 
-const a = struct({
+```ts
+import { record } from "tuple-ts";
+
+const a = record({
   id: 1,
   role: "admin",
 });
 
-const b = struct({
+const b = record({
   role: "admin",
   id: 1,
 });
@@ -185,7 +217,7 @@ a === b; // true
 
 Property order does not matter.
 
-Structs are frozen:
+Records are frozen:
 
 ```ts
 Object.isFrozen(a); // true
@@ -197,18 +229,36 @@ And they work naturally as `Map` keys:
 const users = new Map();
 
 users.set(
-  struct({ id: 42, role: "admin" }),
+  record({ id: 42, role: "admin" }),
   "Alice",
 );
 
 users.get(
-  struct({ role: "admin", id: 42 }),
+  record({ role: "admin", id: 42 }),
 ); // "Alice"
 ```
 
-### Typed structs
+### Record identity
 
-As with tuples, you can define a reusable typed constructor:
+A record's identity is determined by its own, enumerable, string-keyed properties and their values.
+
+Two records are equivalent if they contain exactly the same keys, with equivalent values, regardless of property order.
+
+```ts
+record({ x: 1, y: 2 }) ===
+record({ y: 2, x: 1 }); // true
+
+record({ x: 1 }) ===
+record({ x: 1, y: 2 }); // false
+```
+
+Symbol-keyed, inherited and non-enumerable properties are not copied into records.
+
+Numeric property keys are supported and follow JavaScript's normal conversion to string keys.
+
+### Typed records
+
+Use `record.like()` to create a reusable typed record constructor:
 
 ```ts
 interface User {
@@ -217,7 +267,7 @@ interface User {
   updatedAt: number;
 }
 
-const User = struct<User>;
+const User = record.like<User>();
 
 const a = User({
   id: "alice",
@@ -234,9 +284,151 @@ const b = User({
 a === b; // true
 ```
 
+Alternatively, infer the type from an exemplar:
+
+```ts
+const User = record.like({
+  id: "",
+  name: "",
+  updatedAt: 0,
+});
+```
+
+As with `tuple.like()`, the exemplar defines the type; it does not supply default values.
+
+The resulting factory requires the properties established by `like()`, but may also accept additional properties.
+
+Unlike `struct`, `record` preserves those additional properties, and they contribute to identity.
+
+```ts
+const User = record.like({ id: "" });
+
+const a = User({ id: "alice" });
+const b = User({ id: "alice", role: "admin" });
+
+a === b; // false
+```
+
+## Structs
+
+`record` interns whatever properties you give it. If you want a fixed set of keys to define identity, use `struct`.
+
+`struct` takes key names as arguments and returns a factory. The factory accepts any object with at least those keys, extracts **exactly the declared keys**, and interns the result.
+
+```ts
+import { struct } from "tuple-ts";
+
+const Point = struct("x", "y");
+
+const a = Point({ x: 1, y: 2 });
+const b = Point({ x: 1, y: 2 });
+
+a === b; // true
+```
+
+### Additional properties are discarded
+
+Unlike `record`, a struct factory ignores properties that are not part of its declared structure:
+
+```ts
+const Point = struct("x", "y");
+
+const a = Point({ x: 1, y: 2 });
+const b = Point({ x: 1, y: 2, z: 3 });
+
+a === b; // true
+```
+
+The resulting objects contain only `x` and `y`:
+
+```ts
+Object.keys(b); // ["x", "y"]
+
+b.z; // TypeScript error
+```
+
+This makes structs useful for projecting larger objects into canonical values with a precisely defined shape.
+
+```ts
+const Position = struct("x", "y");
+
+const location = {
+  x: 10,
+  y: 20,
+  altitude: 100,
+  timestamp: Date.now(),
+};
+
+const position = Position(location);
+// { x: 10, y: 20 }
+```
+
+The factory is deliberately permissive about additional input properties, but strict about which properties appear in its output.
+
+### Typed structs
+
+Use `struct(...keys).like()` to constrain the types of the declared properties.
+
+The type can be inferred from an exemplar:
+
+```ts
+const Point = struct("x", "y").like({
+  x: 0,
+  y: 0,
+});
+
+Point({ x: 10, y: 20 });    // OK
+Point({ x: "10", y: 20 });  // TypeScript error
+```
+
+Or provided explicitly:
+
+```ts
+type Coordinates = {
+  x: number;
+  y: number;
+};
+
+const Point = struct("x", "y").like<Coordinates>();
+
+Point({ x: 10, y: 20 }); // OK
+```
+
+As with the other factories, `like()` defines types, not default values.
+
+### Strict definitions, flexible construction
+
+There is an intentional distinction between defining a struct and constructing one.
+
+A `like()` exemplar must contain only the keys declared by `struct`:
+
+```ts
+const Point = struct("x", "y");
+
+Point.like({
+  x: 0,
+  y: 0,
+  z: 0, // TypeScript error: unexpected property
+});
+```
+
+But the resulting factory accepts extra properties and discards them:
+
+```ts
+const Point = struct("x", "y").like({
+  x: 0,
+  y: 0,
+});
+
+Point({ x: 10, y: 20, z: 30 }); // OK
+// { x: 10, y: 20 }
+```
+
+This keeps struct definitions precise without making callers manually remove unrelated properties from their input objects.
+
 ## Equality semantics
 
-Primitive values are compared using [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is):
+Values are compared using [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is):
 
 ```ts
 tuple(NaN) === tuple(NaN); // true
@@ -262,19 +454,54 @@ tuple({ x: 1 }) === tuple({ x: 1 }); // false
 
 This is **shallow equality**. `tuple-ts` does not recursively compare arbitrary JavaScript objects.
 
-Nested tuples and structs work particularly well because they are themselves canonical values.
+Nested tuples, records and structs work particularly well because they are themselves canonical values:
+
+```ts
+const a = record({
+  position: tuple(10, 20),
+});
+
+const b = record({
+  position: tuple(10, 20),
+});
+
+a === b; // true
+```
+
+The outer records compare equal because the inner tuples have already been interned to the same object.
+
+All three constructors share this model of identity.
 
 ## Immutable by design
 
-Tuples and structs returned by `tuple-ts` are frozen:
+Tuples, records and structs returned by `tuple-ts` are frozen:
 
 ```ts
 const point = tuple(10, 20);
+const user = record({ id: 1 });
+const position = struct("x", "y")({ x: 1, y: 2 });
+
+Object.isFrozen(point);    // true
+Object.isFrozen(user);     // true
+Object.isFrozen(position); // true
+```
+
+This is important to the identity semantics: once a value has been interned, its own properties cannot subsequently change while it is being used as a `Map` key or `Set` member.
+
+Freezing is shallow. If an interned value contains a reference to an ordinary mutable object, that nested object is not automatically frozen.
+
+For example:
+
+```ts
+const details = { name: "Alice" };
+const user = record({ details });
 
-Object.isFrozen(point); // true
+details.name = "Bob"; // Allowed
 ```
 
-This is important to the identity semantics: once a value has been interned, its contents cannot subsequently change while it is being used as a `Map` key or `Set` member.
+The reference to `details` remains unchanged, so the interned record retains its identity.
+
+If you need immutable nested values, construct them using `tuple`, `record` or `struct` as well.
 
 ## Garbage-collection friendly
 
@@ -282,40 +509,86 @@ Interning values creates a natural question: *doesn't the cache grow forever?*
 
 `tuple-ts` uses `WeakRef` and `FinalizationRegistry` internally. Cached values are weakly referenced, allowing the JavaScript garbage collector to reclaim values that are no longer referenced by the application.
 
-In other words, you don't have to manually maintain a global cache of every tuple you've ever created.
+In other words, you don't have to manually maintain a global cache of every tuple, record or struct you've ever created.
 
 ## TypeScript first
 
-`tuple` and `struct` are designed to preserve TypeScript's inference:
+`tuple`, `record` and `struct` are designed to preserve TypeScript's inference.
 
-```ts
-const value = tuple(
-  "hello",
-  42,
-  true,
-);
+### Literal inference
 
+By default, constructors preserve literal types:
+
+```ts
+const t = tuple("hello", 42, true);
 // readonly ["hello", 42, true]
+
+const r = record({ x: 1, y: 2 });
+// readonly properties x: 1, y: 2
+```
+
+### Reusable typed factories
+
+Use `.like()` to define reusable constructors:
+
+```ts
+const Pair = tuple.like("", 0);
+
+const User = record.like({
+  id: "",
+  name: "",
+});
+
+const Point = struct("x", "y").like({
+  x: 0,
+  y: 0,
+});
 ```
 
-The library is deliberately small: the runtime API consists of the two constructors you actually need:
+Or specify types explicitly:
 
 ```ts
-import { tuple, struct } from "tuple-ts";
+const Pair = tuple.like<[string, number]>();
+
+const User = record.like<{
+  id: string;
+  name: string;
+}>();
+
+const Point = struct("x", "y").like<{
+  x: number;
+  y: number;
+}>();
 ```
 
+In either form, TypeScript checks arguments to the resulting factories.
+
+### Readonly results
+
+All constructors return readonly types, reflecting the frozen runtime objects.
+
+The readonly typing is shallow, just like `Object.freeze()`.
+
 ## When should I use it?
 
 `tuple-ts` is particularly useful when you want **small immutable values with stable identity**:
 
-* composite `Map` keys
-* `Set` membership
-* memoization keys
-* graph/search states
-* coordinates and other multi-dimensional values
-* functional programming
-* immutable application state
-* canonical representations of frequently repeated values
+- Composite `Map` keys
+- `Set` membership
+- Memoization keys
+- Graph/search states
+- Coordinates and other multi-dimensional values
+- Functional programming
+- Immutable application state
+- Canonical representations of frequently repeated values
+
+Choose between the three constructors according to your data:
+
+| Constructor | Shape | Identity |
+|---|---|---|
+| `tuple` | Ordered sequence | Position and value of each element |
+| `record` | Arbitrary object properties | Complete set of keys and values |
+| `struct` | Fixed declared keys | Values of the declared keys only |
 
 If you just need an ordinary mutable array or object, use one. `tuple-ts` is for when you want the thing to behave more like a **value**.
 
@@ -323,10 +596,14 @@ If you just need an ordinary mutable array or object, use one. `tuple-ts` is for
 
 The implementation uses hashing to locate candidate values and then performs an exact shallow equality check before reusing an existing value. Hash collisions therefore do not determine equality.
 
+Property order is ignored for records and structs, but element order matters for tuples.
+
 The intern cache uses weak references, so canonical values do not need to be kept alive solely because they have previously been created.
 
+Constructed records and structs are copied before interning, so callers cannot alter an interned value by modifying the source object.
+
 There are no runtime dependencies.
 
 ## License
 
-ISC
+ISC

package/dist/index.d.ts

@@ -1,6 +1,78 @@
 import InternCache from "./intern-cache";
+type NoExtraKeys<T, K extends PropertyKey> = T & Record<Exclude<keyof T, K>, never>;
+type BaseKey = string | number;
+type BaseTuple = readonly unknown[];
+type BaseRecord<K extends BaseKey> = Record<K, unknown>;
 export declare const _tupleCache: InternCache<number, readonly unknown[]>;
-export declare const _structCache: InternCache<number, Record<string, unknown>>;
-export declare const tuple: <const T extends readonly unknown[]>(...t: T) => Readonly<T>;
-export declare const struct: <const T extends Record<string, unknown>>({ ...r }: T) => Readonly<T>;
+export declare const _recordCache: InternCache<number, Record<BaseKey, unknown>>;
+export declare const tuple: (<const T_ extends BaseTuple>(...t: T_) => Readonly<T_>) & {
+    like: <T_ extends BaseTuple>(...exemplar: [] | T_) => (<const T__1 extends T_>(...t: T__1) => Readonly<T__1>) & {
+        like: <T__1 extends T_>(...exemplar: [] | T__1) => (<const T__2 extends T__1>(...t: T__2) => Readonly<T__2>) & {
+            like: <T__2 extends T__1>(...exemplar: [] | T__2) => (<const T__3 extends T__2>(...t: T__3) => Readonly<T__3>) & {
+                like: <T__3 extends T__2>(...exemplar: [] | T__3) => (<const T__4 extends T__3>(...t: T__4) => Readonly<T__4>) & {
+                    like: <T__4 extends T__3>(...exemplar: [] | T__4) => (<const T__5 extends T__4>(...t: T__5) => Readonly<T__5>) & {
+                        like: <T__5 extends T__4>(...exemplar: [] | T__5) => (<const T__6 extends T__5>(...t: T__6) => Readonly<T__6>) & {
+                            like: <T__6 extends T__5>(...exemplar: [] | T__6) => (<const T__7 extends T__6>(...t: T__7) => Readonly<T__7>) & {
+                                like: <T__7 extends T__6>(...exemplar: [] | T__7) => (<const T__8 extends T__7>(...t: T__8) => Readonly<T__8>) & {
+                                    like: <T__8 extends T__7>(...exemplar: [] | T__8) => (<const T__9 extends T__8>(...t: T__9) => Readonly<T__9>) & {
+                                        like: <T__9 extends T__8>(...exemplar: [] | T__9) => (<const T__10 extends T__9>(...t: T__10) => Readonly<T__10>) & {
+                                            like: <T__10 extends T__9>(...exemplar: [] | T__10) => (<const T__11 extends T__10>(...t: T__11) => Readonly<T__11>) & /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const record: (<const R_ extends BaseRecord<BaseKey>>(r: R_) => Readonly<Pick<R_, Extract<keyof R_, BaseKey>>>) & {
+    like: <R_ extends BaseRecord<BaseKey>>(exemplar?: NoExtraKeys<R_, BaseKey> | undefined) => (<const R__1 extends R_>(r: R__1) => Readonly<Pick<R__1, Extract<keyof R__1, BaseKey>>>) & {
+        like: <R__1 extends R_>(exemplar?: NoExtraKeys<R__1, BaseKey> | undefined) => (<const R__2 extends R__1>(r: R__2) => Readonly<Pick<R__2, Extract<keyof R__2, BaseKey>>>) & {
+            like: <R__2 extends R__1>(exemplar?: NoExtraKeys<R__2, BaseKey> | undefined) => (<const R__3 extends R__2>(r: R__3) => Readonly<Pick<R__3, Extract<keyof R__3, BaseKey>>>) & {
+                like: <R__3 extends R__2>(exemplar?: NoExtraKeys<R__3, BaseKey> | undefined) => (<const R__4 extends R__3>(r: R__4) => Readonly<Pick<R__4, Extract<keyof R__4, BaseKey>>>) & {
+                    like: <R__4 extends R__3>(exemplar?: NoExtraKeys<R__4, BaseKey> | undefined) => (<const R__5 extends R__4>(r: R__5) => Readonly<Pick<R__5, Extract<keyof R__5, BaseKey>>>) & {
+                        like: <R__5 extends R__4>(exemplar?: NoExtraKeys<R__5, BaseKey> | undefined) => (<const R__6 extends R__5>(r: R__6) => Readonly<Pick<R__6, Extract<keyof R__6, BaseKey>>>) & {
+                            like: <R__6 extends R__5>(exemplar?: NoExtraKeys<R__6, BaseKey> | undefined) => (<const R__7 extends R__6>(r: R__7) => Readonly<Pick<R__7, Extract<keyof R__7, BaseKey>>>) & {
+                                like: <R__7 extends R__6>(exemplar?: NoExtraKeys<R__7, BaseKey> | undefined) => (<const R__8 extends R__7>(r: R__8) => Readonly<Pick<R__8, Extract<keyof R__8, BaseKey>>>) & {
+                                    like: <R__8 extends R__7>(exemplar?: NoExtraKeys<R__8, BaseKey> | undefined) => (<const R__9 extends R__8>(r: R__9) => Readonly<Pick<R__9, Extract<keyof R__9, BaseKey>>>) & {
+                                        like: <R__9 extends R__8>(exemplar?: NoExtraKeys<R__9, BaseKey> | undefined) => (<const R__10 extends R__9>(r: R__10) => Readonly<Pick<R__10, Extract<keyof R__10, BaseKey>>>) & {
+                                            like: <R__10 extends R__9>(exemplar?: NoExtraKeys<R__10, BaseKey> | undefined) => (<const R__11 extends R__10>(r: R__11) => Readonly<Pick<R__11, Extract<keyof R__11, BaseKey>>>) & /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const struct: <const K extends string>(...keys: readonly K[]) => (<const R_ extends BaseRecord<K>>(r: R_) => Readonly<Pick<R_, Extract<keyof R_, K>>>) & {
+    like: <R_ extends BaseRecord<K>>(exemplar?: NoExtraKeys<R_, K> | undefined) => (<const R__1 extends R_>(r: R__1) => Readonly<Pick<R__1, Extract<keyof R__1, K>>>) & {
+        like: <R__1 extends R_>(exemplar?: NoExtraKeys<R__1, K> | undefined) => (<const R__2 extends R__1>(r: R__2) => Readonly<Pick<R__2, Extract<keyof R__2, K>>>) & {
+            like: <R__2 extends R__1>(exemplar?: NoExtraKeys<R__2, K> | undefined) => (<const R__3 extends R__2>(r: R__3) => Readonly<Pick<R__3, Extract<keyof R__3, K>>>) & {
+                like: <R__3 extends R__2>(exemplar?: NoExtraKeys<R__3, K> | undefined) => (<const R__4 extends R__3>(r: R__4) => Readonly<Pick<R__4, Extract<keyof R__4, K>>>) & {
+                    like: <R__4 extends R__3>(exemplar?: NoExtraKeys<R__4, K> | undefined) => (<const R__5 extends R__4>(r: R__5) => Readonly<Pick<R__5, Extract<keyof R__5, K>>>) & {
+                        like: <R__5 extends R__4>(exemplar?: NoExtraKeys<R__5, K> | undefined) => (<const R__6 extends R__5>(r: R__6) => Readonly<Pick<R__6, Extract<keyof R__6, K>>>) & {
+                            like: <R__6 extends R__5>(exemplar?: NoExtraKeys<R__6, K> | undefined) => (<const R__7 extends R__6>(r: R__7) => Readonly<Pick<R__7, Extract<keyof R__7, K>>>) & {
+                                like: <R__7 extends R__6>(exemplar?: NoExtraKeys<R__7, K> | undefined) => (<const R__8 extends R__7>(r: R__8) => Readonly<Pick<R__8, Extract<keyof R__8, K>>>) & {
+                                    like: <R__8 extends R__7>(exemplar?: NoExtraKeys<R__8, K> | undefined) => (<const R__9 extends R__8>(r: R__9) => Readonly<Pick<R__9, Extract<keyof R__9, K>>>) & {
+                                        like: <R__9 extends R__8>(exemplar?: NoExtraKeys<R__9, K> | undefined) => (<const R__10 extends R__9>(r: R__10) => Readonly<Pick<R__10, Extract<keyof R__10, K>>>) & {
+                                            like: <R__10 extends R__9>(exemplar?: NoExtraKeys<R__10, K> | undefined) => (<const R__11 extends R__10>(r: R__11) => Readonly<Pick<R__11, Extract<keyof R__11, K>>>) & /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,gBAAgB,CAAC;AA6BzC,eAAO,MAAM,WAAW,yCAGvB,CAAC;AAEF,eAAO,MAAM,YAAY,8CAGxB,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,GAAG,CAAC,gBAC9B,CAAC;AAEpC,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,gBACvC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,gBAAgB,CAAC;AAGzC,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,IAAI,CAAC,GAC5C,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAErC,KAAK,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAC/B,KAAK,SAAS,GAAG,SAAS,OAAO,EAAE,CAAC;AACpC,KAAK,UAAU,CAAC,CAAC,SAAS,OAAO,IAAI,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AA+CxD,eAAO,MAAM,WAAW,yCAAoD,CAAC;AAE7E,eAAO,MAAM,YAAY,+CAQxB,CAAC;AAEF,eAAO,MAAM,KAAK,UAhCP,EAAE;WAEA,EAAE;;;;;;;;;;;;;;;;;;;;;CA8BmB,CAAC;AAEnC,eAAO,MAAM,MAAM,UAxBR,EAAE;WAKA,EAAE;;;;;;;;;;;;;;;;;;;;;CAmBqB,CAAC;AAErC,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,EAAE,aA1BzD,EAAE;WAKA,EAAE;;;;;;;;;;;;;;;;;;;;;CAsBK,CAAC"}

package/dist/index.js

@@ -9,21 +9,23 @@ function arrayEquivalent(a1, a2) {
     }
     return true;
 }
-function structEquivalent(r1, r2) {
+function recordEquivalent(r1, r2) {
     const r1Keys = Object.keys(r1);
     const r2Keys = Object.keys(r2);
     if (r2Keys.length !== r1Keys.length)
         return false;
-    for (let i = 0; i < r1Keys.length; i++) {
-        const k = r1Keys[i];
-        if (!(k in r2))
-            return false;
-        if (!Object.is(r2[k], r1[k]))
-            return false;
-    }
-    return true;
+    return r1Keys.every(k => Object.hasOwn(r2, k) && Object.is(r1[k], r2[k]));
 }
+const defineTuple = () => Object.assign((...t) => _tupleCache.get(t), {
+    like: (...exemplar) => defineTuple(),
+});
+const defineRecord = (keys) => Object.assign((r) => _recordCache.get(Object.fromEntries(keys ? keys.map((k) => [k, r[k]]) : Object.entries(r))), {
+    like: (exemplar) => defineRecord(keys),
+});
 export const _tupleCache = new InternCache(hash.valuesHash, arrayEquivalent);
-export const _structCache = new InternCache((r) => hash.valuesHash(Object.keys(r).sort().flatMap(k => [k, r[k]])), structEquivalent);
-export const tuple = (...t) => Object.freeze(_tupleCache.get(t));
-export const struct = ({ ...r }) => Object.freeze(_structCache.get(r));
+export const _recordCache = new InternCache((r) => hash.valuesHash(Object.keys(r)
+    .sort()
+    .flatMap((k) => [k, r[k]])), recordEquivalent);
+export const tuple = defineTuple();
+export const record = defineRecord();
+export const struct = (...keys) => defineRecord(keys);

package/dist/intern-cache.d.ts

@@ -1,11 +1,11 @@
 export default class<H, T extends object> {
-    private readonly map;
     private readonly hashFn;
-    private readonly identityFn;
+    private readonly matchFn;
+    private readonly map;
     private cleanupRegistry;
-    constructor(hashFn: (obj: T) => H, identityFn: (obj1: T, obj2: T) => boolean);
+    constructor(hashFn: (value: T) => H, matchFn: (a: T, b: T) => boolean);
     private remove;
-    get<U extends T>(obj: U): U;
+    get<T_ extends T>(obj: T_): Readonly<T_>;
     get size(): number;
     reset(): void;
 }

package/dist/intern-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intern-cache.d.ts","sourceRoot":"","sources":["../src/intern-cache.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,eAAe,CAErB;gBAGA,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EACrB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO;IAM3C,OAAO,CAAC,MAAM;IAWd,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAqB3B,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,KAAK,IAAI,IAAI;CAId"}
+{"version":3,"file":"intern-cache.d.ts","sourceRoot":"","sources":["../src/intern-cache.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM;IAOpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAC1D,OAAO,CAAC,eAAe,CAErB;gBAGiB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACvB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO;IAGnD,OAAO,CAAC,MAAM;IAWd,GAAG,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC;IAsBxC,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,KAAK,IAAI,IAAI;CAId"}

package/dist/intern-cache.js

@@ -1,9 +1,9 @@
 export default class {
-    constructor(hashFn, identityFn) {
+    constructor(hashFn, matchFn) {
+        this.hashFn = hashFn;
+        this.matchFn = matchFn;
         this.map = new Map();
         this.cleanupRegistry = new FinalizationRegistry((x) => this.remove(x));
-        this.hashFn = hashFn;
-        this.identityFn = identityFn;
     }
     remove([hash, ref]) {
         const hashBucket = this.map.get(hash);
@@ -21,7 +21,7 @@ export default class {
         if (hashBucket !== undefined) {
             for (const ref of hashBucket) {
                 const o = ref.deref();
-                if (o && this.identityFn(o, obj))
+                if (o && this.matchFn(obj, o))
                     return o;
             }
         }
@@ -31,6 +31,7 @@ export default class {
             this.map.set(hash, hashBucket);
         }
         // Object is not in the cache. Add it and return it.
+        Object.freeze(obj);
         const ref = new WeakRef(obj);
         hashBucket.add(ref);
         this.cleanupRegistry.register(obj, [hash, ref]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "tuple-ts",
-  "version": "0.4.7",
+  "version": "0.6.0",
   "description": "Tuples and structs for TypeScript and JavaScript with equality and identity semantics.",
   "keywords": [
     "tuple",