tuple-ts 0.3.1 → 0.4.1

package/README.md

@@ -1,156 +1,330 @@
-# TupleTS
+# tuple-ts
 
-TupleTS is an implementation of tuples and records intended to be memory-safe, performant, and tiny.
+**Immutable tuples and structs with value-based identity for JavaScript and TypeScript.**
 
-- **Referential Equality (`===`)**: Identical tuples and records return the same instance in memory.
-- **Composite Keys for `Set` & `Map`**: Use tuples or records as keys without custom serialization or hashing workarounds.
-- **Memory-Safe**: Uses `WeakRef` and `FinalizationRegistry` to automatically purge entries upon garbage collection.
-- **Deeply Nestable & Immutable**: Tuples can contain other tuples; all created tuples and records are `Object.freeze`'d.
-- **TypeScript First**: Full type inference and type-safe factories.
-- **Zero Dependencies**: Lightweight implementation with fast MurmurHash3-based hashing.
+JavaScript normally compares arrays and objects by reference:
 
----
+```ts
+[1, 2] === [1, 2] // false
+
+{ x: 1 } === { x: 1 } // false
+```
+
+`tuple-ts` gives you a different model:
 
-## Installation
+```ts
+tuple(1, 2) === tuple(1, 2) // true
+
+struct({ x: 1 }) === struct({ 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.
+
+## Install
 
 ```bash
 npm install tuple-ts
 ```
 
----
+## Tuples
 
-## Usage Examples
+Create an immutable tuple with full TypeScript inference:
 
-### 1. Basic Tuples & Referential Equality
+```ts
+import { tuple } from "tuple-ts";
 
-Tuples with the same elements evaluate to the exact same object reference (`===`):
+const point = tuple(10, 20);
+//    ^? readonly [10, 20]
+
+console.log(point[0]); // 10
+console.log(point[1]); // 20
+```
+
+Calling `tuple` again with the same values gives you the **same object**:
 
 ```ts
-import { tuple } from "tuple-ts";
+const a = tuple(10, 20);
+const b = tuple(10, 20);
+
+a === b; // true
+Object.is(a, b); // true
+```
+
+Different values give you different objects:
 
-const a = tuple(1, "hello", true);
-const b = tuple(1, "hello", true);
+```ts
+tuple(10, 20) === tuple(10, 21); // false
+tuple(10, 20) === tuple(20, 10); // false
+```
+
+Tuples are ordinary frozen arrays, so there is no special API to learn:
 
-console.log(a === b); // true
+```ts
+const t = tuple("hello", 42, true);
 
-// Tuples are standard frozen arrays:
-console.log(a[0]);        // 1
-console.log(a.length);    // 3
-console.log([...a]);      // [1, "hello", true]
+t.length;       // 3
+t[0];            // "hello"
+[...t];          // ["hello", 42, true]
+Object.isFrozen(t); // true
 ```
 
-### 2. Nested Tuples
+## Why is this useful?
+
+### Composite `Map` keys
 
-Tuples can be nested arbitrarily and maintain referential equality across structures:
+JavaScript doesn't have value-based arrays, so this doesn't work:
 
 ```ts
-import { tuple } from "tuple-ts";
+const map = new Map();
 
-const t1 = tuple("matrix", tuple(1, 0), tuple(0, 1));
-const t2 = tuple("matrix", tuple(1, 0), tuple(0, 1));
-const t3 = tuple("matrix", tuple(1, 1), tuple(0, 1));
+map.set([10, 20], "visited");
 
-console.log(t1 === t2); // true
-console.log(t1 === t3); // false
+map.get([10, 20]); // undefined
 ```
 
-### 3. Composite Keys in `Map` and `Set`
-
-In standard JavaScript, arrays and objects compare by reference, preventing them from being used as composite keys in `Map` or values in `Set`. With `tuple`, structural equality makes composite keys work seamlessly:
+With `tuple-ts`:
 
 ```ts
-import { tuple } from "tuple-ts";
+const map = new Map();
+
+map.set(tuple(10, 20), "visited");
+
+map.get(tuple(10, 20)); // "visited"
+```
+
+The tuple constructed during the lookup is the same canonical object as the tuple used as the key.
+
+This is particularly useful for things like coordinates, memoization keys, graph nodes, dynamic-programming states, and other composite values.
 
-// Set: Deduplicating coordinate pairs
+### `Set` of values
+
+The same applies to `Set`:
+
+```ts
 const visited = new Set();
+
 visited.add(tuple(10, 20));
 
-console.log(visited.has(tuple(10, 20))); // true!
-console.log(visited.has(tuple(10, 21))); // false
+visited.has(tuple(10, 20)); // true
+visited.has(tuple(10, 21)); // false
+```
+
+No serialization, stringification, or custom hashing is required.
 
-// Map: Multi-argument function memoization / 2D grid
-const grid = new Map();
-grid.set(tuple(0, 0), "Origin");
-grid.set(tuple(3, 4), "Target");
+## Nested tuples
 
-console.log(grid.get(tuple(0, 0))); // "Origin"
-console.log(grid.get(tuple(3, 4))); // "Target"
+Tuples can be nested:
+
+```ts
+const a = tuple(
+  "matrix",
+  tuple(1, 0),
+  tuple(0, 1),
+);
+
+const b = tuple(
+  "matrix",
+  tuple(1, 0),
+  tuple(0, 1),
+);
+
+a === b; // true
+```
+
+Because nested tuples themselves have value-based identity, the resulting structures are canonicalised naturally.
+
+```ts
+const a = tuple("a", tuple("b", "c"));
+const b = tuple("a", tuple("b", "c"));
+const c = tuple("a", tuple("b", "d"));
+
+a === b; // true
+a === c; // false
 ```
 
-### 4. Custom Typed Tuples (`defineTupleType`)
+## Typed tuples
 
-You can create strictly-typed tuple factories:
+You can create a reusable constructor for a particular tuple type:
 
 ```ts
-import { defineTupleType } from "tuple-ts";
+type Point = [x: number, y: number];
 
-type Point2D = [x: number, y: number];
-const Point = defineTupleType<Point2D>();
+const Point = tuple<Point>;
 
-const p1 = Point(12, 34);
-const p2 = Point(12, 34);
+const a = Point(10, 20);
+const b = Point(10, 20);
 
-console.log(p1 === p2); // true
+a === b; // true
 ```
 
-### 5. Interned Records (`record`)
+The result retains the tuple's TypeScript type while gaining the same runtime identity semantics.
+
+## Structs
 
-Just like tuples, `record` interns shallow objects. Property key insertion order does not affect equality:
+`struct` provides the same semantics for objects:
 
 ```ts
-import { record } from "tuple-ts";
+import { struct } from "tuple-ts";
+
+const a = struct({
+  id: 1,
+  role: "admin",
+});
 
-const userA = record({ id: 1, role: "admin" });
-const userB = record({ role: "admin", id: 1 }); // different key order
+const b = struct({
+  role: "admin",
+  id: 1,
+});
 
-console.log(userA === userB); // true
-console.log(userA.role);      // "admin"
+a === b; // true
 ```
 
-### 6. Custom Typed Records (`defineRecordType`)
+Property order does not matter.
+
+Structs are frozen:
+
+```ts
+Object.isFrozen(a); // true
+```
 
-As with tuples, you can also create strictly-typed record factories:
+And they work naturally as `Map` keys:
 
 ```ts
-import { defineRecordType } from "tuple-ts";
+const users = new Map();
+
+users.set(
+  struct({ id: 42, role: "admin" }),
+  "Alice",
+);
+
+users.get(
+  struct({ role: "admin", id: 42 }),
+); // "Alice"
+```
 
-interface UserProfile {
+### Typed structs
+
+As with tuples, you can define a reusable typed constructor:
+
+```ts
+interface User {
   id: string;
   name: string;
   updatedAt: number;
 }
 
-const User = defineRecordType<UserProfile>();
+const User = struct<User>;
 
-const user1 = User({ id: "alice", name: "Alice", updatedAt: 1000 });
-const user2 = User({ name: "Alice", id: "alice", updatedAt: 1000 });
+const a = User({
+  id: "alice",
+  name: "Alice",
+  updatedAt: 1000,
+});
 
-console.log(user1 === user2); // true
-console.log(user1["name"]); // "Alice"
+const b = User({
+  name: "Alice",
+  id: "alice",
+  updatedAt: 1000,
+});
+
+a === b; // true
 ```
 
-### 7. Memory Safety & Garbage Collection
+## Equality semantics
 
-TupleTS uses `WeakRef` and `FinalizationRegistry` under the hood. When a tuple or record is no longer referenced anywhere in your program, the JavaScript runtime garbage-collects it, and its entry in the intern cache is automatically pruned.
+Primitive values are compared using [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is):
 
 ```ts
-// No need to manually clear caches or worry about memory leaks.
-{
-  const temp = tuple("transient", 123);
-  // once 'temp' leaves scope and GC runs, the intern cache entry is freed.
-}
+tuple(NaN) === tuple(NaN); // true
+
+tuple(+0) === tuple(-0);   // false
+```
+
+Object values retain JavaScript's normal identity semantics.
+
+The same object is the same value:
+
+```ts
+const value = { x: 1 };
+
+tuple(value) === tuple(value); // true
+```
+
+Two separately created objects are different values:
+
+```ts
+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.
+
+## Immutable by design
+
+Tuples and structs returned by `tuple-ts` are frozen:
+
+```ts
+const point = tuple(10, 20);
+
+Object.isFrozen(point); // true
 ```
 
----
+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.
+
+## Garbage-collection friendly
+
+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.
+
+## TypeScript first
+
+`tuple` and `struct` are designed to preserve TypeScript's inference:
+
+```ts
+const value = tuple(
+  "hello",
+  42,
+  true,
+);
+
+// readonly ["hello", 42, true]
+```
+
+The library is deliberately small: the runtime API consists of the two constructors you actually need:
+
+```ts
+import { tuple, struct } from "tuple-ts";
+```
+
+## 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
+
+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**.
+
+## Design
+
+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.
+
+The intern cache uses weak references, so canonical values do not need to be kept alive solely because they have previously been created.
+
+There are no runtime dependencies.
 
-## Equality Semantics
+## License
 
-TupleTS compares primitives via `Object.is`:
-- `NaN` is equivalent to `NaN` (`tuple(NaN) === tuple(NaN)`).
-- `+0` and `-0` are treated as distinct values (`tuple(+0) !== tuple(-0)`).
-- Object elements are interned by object identity:
-  ```ts
-  const shared = { value: 1 };
-  tuple(shared) === tuple(shared); // true
-  tuple({}) === tuple({});         // false (different object references)
-  ```
+ISC

package/dist/hash.d.ts

@@ -1,3 +1,3 @@
 export declare function tupleHash(elements: readonly unknown[]): number;
-export declare function recordHash(record: Record<string, unknown>): number;
+export declare function structHash(struct: Record<string, unknown>): number;
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -27,7 +27,7 @@ function linearCongruentialGenerator(seed = Date.now()) {
 }
 const randomUint32 = linearCongruentialGenerator();
 const tupleSeed = randomUint32();
-const recordSeed = randomUint32();
+const structSeed = randomUint32();
 const nullHash = randomUint32();
 const undefinedHash = randomUint32();
 const falseHash = randomUint32();
@@ -102,12 +102,12 @@ function valueHashes(values) {
 export function tupleHash(elements) {
     return mixHashes(valueHashes(elements), tupleSeed);
 }
-function keyAndValueHashes(record) {
-    return Object.keys(record).sort().flatMap(key => [
+function keyAndValueHashes(struct) {
+    return Object.keys(struct).sort().flatMap(key => [
         valueHash(key),
-        valueHash(record[key])
+        valueHash(struct[key])
     ]);
 }
-export function recordHash(record) {
-    return mixHashes(keyAndValueHashes(record), recordSeed);
+export function structHash(struct) {
+    return mixHashes(keyAndValueHashes(struct), structSeed);
 }

package/dist/index.d.ts

@@ -1,11 +1,7 @@
 import InternCache from "./intern-cache";
 export { InternCache };
-export type TupleType<T extends readonly unknown[]> = (...t: T) => Readonly<T>;
-export type RecordType<T extends Record<string, unknown>> = (r: T) => Readonly<T>;
 export declare const _tupleCache: InternCache<number, readonly unknown[]>;
-export declare const _recordCache: InternCache<number, Record<string, unknown>>;
-export declare const tuple: <const T_ extends readonly unknown[]>(...t: T_) => Readonly<T_>;
-export declare const record: <const T_ extends Record<string, unknown>>({ ...r }: T_) => T_;
-export declare const defineTupleType: <T extends readonly unknown[]>() => TupleType<T>;
-export declare const defineRecordType: <T extends Record<string, unknown>>() => RecordType<T>;
+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>;
 //# 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;AACzC,OAAO,EAAE,WAAW,EAAE,CAAC;AAGvB,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC/E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAC1D,CAAC,EAAE,CAAC,KACD,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEjB,eAAO,MAAM,WAAW,yCAGvB,CAAC;AACF,eAAO,MAAM,YAAY,8CAGxB,CAAC;AA4BF,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,GAAG,EAAE,iBAChC,CAAC;AAEpC,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,UAE9D,EAAE,KAAG,EAAwC,CAAC;AAEjD,eAAO,MAAM,eAAe,GACzB,CAAC,SAAS,SAAS,OAAO,EAAE,OAAK,SAAS,CAAC,CAAC,CAEjB,CAAC;AAE/B,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAK,UAAU,CAAC,CAAC,CAExC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,CAAC;AA6BvB,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"}

package/dist/index.js

@@ -1,8 +1,6 @@
 import InternCache from "./intern-cache";
 export { InternCache };
 import * as hash from "./hash";
-export const _tupleCache = new InternCache(hash.tupleHash, arrayEquivalent);
-export const _recordCache = new InternCache(hash.recordHash, recordEquivalent);
 function arrayEquivalent(a1, a2) {
     if (a2.length !== a1.length)
         return false;
@@ -12,7 +10,7 @@ function arrayEquivalent(a1, a2) {
     }
     return true;
 }
-function recordEquivalent(r1, r2) {
+function structEquivalent(r1, r2) {
     const r1Keys = Object.keys(r1);
     const r2Keys = Object.keys(r2);
     if (r2Keys.length !== r1Keys.length)
@@ -26,7 +24,7 @@ function recordEquivalent(r1, r2) {
     }
     return true;
 }
+export const _tupleCache = new InternCache(hash.tupleHash, arrayEquivalent);
+export const _structCache = new InternCache(hash.structHash, structEquivalent);
 export const tuple = (...t) => Object.freeze(_tupleCache.get(t));
-export const record = ({ ...r }) => Object.freeze(_recordCache.get(r));
-export const defineTupleType = () => (...t) => tuple(...t);
-export const defineRecordType = () => (r) => record(r);
+export const struct = ({ ...r }) => Object.freeze(_structCache.get(r));

package/dist/record.spec.js

@@ -1,18 +1,24 @@
-import { record } from ".";
-describe("record", () => {
+import { struct } from ".";
+describe("struct", () => {
     it("preserves keys and values", () => {
-        const a = record({ x: 1, y: 2 });
+        const a = struct({ x: 1, y: 2 });
         expect(a).toEqual({ x: 1, y: 2 });
     });
     it("returns the same object for shallow-equal input objects", () => {
-        const a = record({ x: 1, y: 2 });
-        const b = record({ x: 1, y: 2 });
+        const a = struct({ x: 1, y: 2 });
+        const b = struct({ x: 1, y: 2 });
         expect(a).toBe(b);
     });
     it("returns different object if keys or values differ", () => {
-        const r = record({ x: 1, y: 2 });
-        expect(record({ x: 1, y: 3 })).not.toBe(r);
-        expect(record({ x: 1, y: 3 })).not.toBe(r);
-        expect(record({ x: 1, y: 2, z: 3 })).not.toBe(r);
+        const r = struct({ x: 1, y: 2 });
+        expect(struct({ x: 1, y: 3 })).not.toBe(r);
+        expect(struct({ x: 1, y: 3 })).not.toBe(r);
+        expect(struct({ x: 1, y: 2, z: 3 })).not.toBe(r);
+    });
+    it("can be customised", () => {
+        const geocode = (struct);
+        const a = geocode({ lat: 1, long: 2 });
+        const b = geocode({ lat: 1, long: 2 });
+        expect(a).toBe(b);
     });
 });

package/dist/struct.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=struct.spec.d.ts.map

package/dist/struct.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"struct.spec.d.ts","sourceRoot":"","sources":["../src/struct.spec.ts"],"names":[],"mappings":""}

package/dist/struct.spec.js

@@ -0,0 +1,35 @@
+import { struct } from ".";
+describe("struct", () => {
+    it("preserves keys and values", () => {
+        const obj = { x: 1, y: 2 };
+        const s = struct(obj);
+        expect(s).toEqual(obj);
+    });
+    it("returns the same object for shallow-equal input objects", () => {
+        const a = struct({ x: 1, y: 2 });
+        const b = struct({ x: 1, y: 2 });
+        expect(a).toBe(b);
+        expect(a === b).toBe(true);
+    });
+    it("returns different object if keys or values differ", () => {
+        const s1 = struct({ x: 1, y: 2 });
+        const s2 = struct({ x: 1, y: 3 });
+        const s3 = struct({ x: 1, y: 2, z: 3 });
+        expect(s1).not.toBe(s2);
+        expect(s1).not.toBe(s3);
+        expect(s1 === s3).toBe(false);
+    });
+    it("can be customised", () => {
+        const geocode = (struct);
+        const a = geocode({ lat: 1, long: 2 });
+        const b = geocode({ lat: 1, long: 2 });
+        expect(a).toBe(b);
+    });
+    it("returns frozen instances", () => {
+        const s = struct({ x: 1, y: 2 });
+        expect(Object.isFrozen(s)).toBe(true);
+        expect(() => {
+            s.x = 42;
+        }).toThrow();
+    });
+});

package/dist/tuple.spec.js

@@ -1,4 +1,4 @@
-import { tuple, defineTupleType, _tupleCache } from ".";
+import { tuple, _tupleCache } from ".";
 async function waitForGC() {
     await new Promise((res) => setTimeout(res, 0));
     global.gc(); // requires node --expose-gc
@@ -7,7 +7,8 @@ async function waitForGC() {
 test("Empty tuples", () => {
     const a = tuple();
     const b = tuple();
-    expect(b).toBe(a);
+    expect(b).toBe(a); // identity
+    expect(a === b).toBe(true); // equality
 });
 test("Indexability", () => {
     const a = {};
@@ -27,12 +28,14 @@ test("Basic interned equality (if same input, same object)", () => {
     const f = () => { };
     const t1 = tuple(a, f, 42, "hi", undefined, true, null, 7839278492n);
     const t2 = tuple(a, f, 42, "hi", undefined, true, null, 7839278492n);
-    expect(t1).toBe(t2); // same object reference
+    expect(t1).toBe(t2); // identity
+    expect(t1 === t2).toBe(true); // equality
 });
 test("Referential inequality (same structure, different references)", () => {
     const t1 = tuple({}, 42);
     const t2 = tuple({}, 42);
-    expect(t1).not.toBe(t2); // different objects
+    expect(t1).not.toBe(t2); // non-identity
+    expect(t1 === t2).toBe(false); // non-equality
 });
 test("Different-length tuples are different tuples", () => {
     const t1 = tuple(1, 2);
@@ -46,10 +49,12 @@ test("Nestable", () => {
     const t2 = tuple("a", tuple("b1", "b2"), "c");
     const t3 = tuple("a", tuple("b1", "b3"), "c");
     expect(t2).toBe(t1);
+    expect(t1 === t2).toBe(true);
     expect(t3).not.toBe(t1);
 });
 test("NaN is equivalent to itself", () => {
     expect(tuple(NaN)).toBe(tuple(NaN));
+    expect(tuple(NaN) === tuple(NaN)).toBe(true);
 });
 test("NaN values with different bit representations are interned as identical", () => {
     // Construct NaN with payload 1
@@ -69,16 +74,29 @@ test("NaN values with different bit representations are interned as identical",
     // If NaNs were not canonicalized in numberToUint32s, this would fail (.not.toBe)
     // because nan1 and nan2 would hash to different buckets:
     expect(tuple(nan1)).toBe(tuple(nan2));
+    expect(tuple(nan1) === tuple(nan2)).toBe(true);
 });
 test("Positive and negative zero are distinct", () => {
+    const t1 = tuple(+0);
+    const t2 = tuple(-0);
+    expect(t1).not.toBe(t2);
+    expect(t1 === t2).toBe(false);
     expect(tuple(+0)).not.toBe(tuple(-0));
+    expect(tuple(+0) === tuple(-0)).toBe(false);
 });
 test("Tuple cache entry is cleared when tuple is garbage-collected", async () => {
     _tupleCache.reset();
     expect(_tupleCache.size).toBe(0);
-    const Point = defineTupleType();
+    const Point = (tuple);
     Point(15, 42);
     expect(_tupleCache.size).toBe(1);
     await waitForGC();
     expect(_tupleCache.size).toBe(0);
 });
+test("Tuples are frozen", () => {
+    const t = tuple(1, 2, 3);
+    expect(Object.isFrozen(t)).toBe(true);
+    expect(() => {
+        t[0] = 42;
+    }).toThrow();
+});

package/package.json

@@ -1,21 +1,14 @@
 {
   "type": "module",
   "name": "tuple-ts",
-  "version": "0.3.1",
-  "description": "Python-like tuples for JavaScript/TypeScript",
+  "version": "0.4.1",
+  "description": "Tuples and structs for TypeScript and JavaScript with equality and identity semantics.",
   "keywords": [
     "tuple",
-    "tuples",
-    "record",
-    "records",
-    "interning",
-    "hash-consing",
-    "value-equality",
-    "structural-equality",
-    "composite-key",
-    "immutable",
-    "immutability",
-    "weakref",
+    "struct",
+    "equality",
+    "identity",
+    "shallow-equality",
     "typescript"
   ],
   "main": "./dist/index.js",