functype 0.8.63 → 0.8.64

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Jordan Burke
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 Jordan Burke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,277 +1,277 @@
-# Functype
-
-![NPM Version](https://img.shields.io/npm/v/functype?link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2Ffunctype)
-[![Node.js Build](https://github.com/jordanburke/functype/actions/workflows/pnpm-build.yml/badge.svg)](https://github.com/jordanburke/functype/actions/workflows/pnpm-build.yml)
-
-## A Functional Programming Library for TypeScript
-
-Functype is a lightweight functional programming library for TypeScript, drawing inspiration from functional programming paradigms, the Scala Standard Library, and ZIO. It provides a comprehensive set of utilities and abstractions designed to facilitate functional programming within TypeScript applications.
-
-[API Documentation](https://jordanburke.github.io/functype/)
-
-## Core Principles
-
-- **Immutability**: All data structures are immutable, promoting predictable and side-effect-free code
-- **Type Safety**: Leverages TypeScript's type system to ensure compile-time safety
-- **Composability**: Provides abstractions for building complex programs from simple components
-- **Functional Paradigms**: Embraces concepts like monads, functors, and type classes
-
-## Key Features
-
-- **Option Type**: Handle nullable values with `Some` and `None` types
-- **Either Type**: Express computation results with potential failures using `Left` and `Right`
-- **List, Set, Map**: Immutable collection types with functional operators
-- **Try Type**: Safely execute operations that might throw exceptions
-- **Task**: Handle synchronous and asynchronous operations with error handling
-- **Tuple**: Type-safe fixed-length arrays
-- **Typeable**: Runtime type identification with compile-time safety
-
-## Roadmap / TODO
-
-### Missing Functionality
-
-- [ ] Add lazy evaluation structures (LazyList/Stream)
-- [ ] Implement Validation type for applicative validation
-- [ ] Add Reader/State/IO monads for more functional patterns
-- [ ] Implement lens/optics for immutable updates
-- [ ] Expand concurrent execution utilities beyond FPromise.all
-
-### Performance Optimizations
-
-- [ ] Add memoization utilities
-- [ ] Improve recursive operations for large collections
-- [ ] Implement immutable data structures with structural sharing
-- [ ] Add performance benchmarks
-- [x] Optimize TreeShaking with sideEffects flag in package.json
-- [x] Support selective module imports for smaller bundles
-- [x] Add bundle size monitoring to CI/CD
-
-### API Consistency
-
-- [ ] Ensure all modules follow the Scala-inspired pattern:
-  - Constructor functions that return objects with methods
-  - Object methods for common operations
-  - Companion functions for additional utilities
-- [x] Align Task API with other monadic structures
-- [ ] Standardize import patterns (@ imports vs relative paths)
-- [x] Implement consistent error handling strategy for async operations
-
-### Testing and Documentation
-
-- [ ] Add observable test coverage metrics
-- [x] Implement property-based testing
-- [ ] Expand error handling tests
-- [ ] Add interoperability tests with other libraries
-
-### TypeScript Improvements
-
-- [x] Enable stricter TypeScript settings (noImplicitAny: true)
-- [x] Add noUncheckedIndexedAccess for safer array indexing
-- [ ] Improve support for higher-kinded types:
-  - Current type parameters work well for first-order types
-  - Expand to support type constructors as parameters (F<A> => F<B>)
-- [ ] Add branded/nominal types for stronger type safety
-- [ ] Implement more type-level utilities (conditional types, template literals)
-- [ ] Leverage newer TypeScript features (const type parameters, tuple manipulation)
-
-## Installation
-
-```bash
-# NPM
-npm install functype
-
-# Yarn
-yarn add functype
-
-# PNPM
-pnpm add functype
-
-# Bun
-bun add functype
-```
-
-### Bundle Size Optimization
-
-Functype is optimized for tree-shaking and offers multiple import strategies to minimize bundle size:
-
-```typescript
-// Selective module imports (recommended for production)
-import { Option } from "functype/option"
-import { Either } from "functype/either"
-
-// Direct constructor imports (smallest bundle)
-import { some, none } from "functype/option"
-```
-
-For detailed optimization strategies, see the [Bundle Optimization Guide](docs/BUNDLE_OPTIMIZATION.md).
-
-## Usage Examples
-
-### Option
-
-```typescript
-import { Option, Some, None } from "functype"
-
-// Create options
-const value = Option("hello") // Some("hello")
-const empty = Option(null) // None
-const explicit = Some(42) // Some(42)
-
-// Transform values
-const length = value.map((s) => s.length) // Some(5)
-const nothing = empty.map((s) => s.length) // None
-
-// Handle default values
-const result = value.getOrElse("world") // "hello"
-const fallback = empty.getOrElse("world") // "world"
-
-// Conditionally filter
-const filtered = value.filter((s) => s.length > 10) // None
-```
-
-### Either
-
-```typescript
-import { Either, Right, Left } from "functype"
-
-// Success case
-const success = Right<string, number>(42)
-// Error case
-const failure = Left<string, number>("error")
-
-// Transform values (map only applies to Right)
-const doubled = success.map((x) => x * 2) // Right(84)
-const stillError = failure.map((x) => x * 2) // Left("error")
-
-// Handle errors
-const value = success.getOrElse(0) // 42
-const fallback = failure.getOrElse(0) // 0
-
-// Pattern matching with fold
-const result = success.fold(
-  (err) => `Error: ${err}`,
-  (val) => `Success: ${val}`,
-) // "Success: 42"
-```
-
-### List
-
-```typescript
-import { List } from "functype"
-
-const numbers = List([1, 2, 3, 4])
-
-// Transform
-const doubled = numbers.map((x) => x * 2) // List([2, 4, 6, 8])
-
-// Filter
-const evens = numbers.filter((x) => x % 2 === 0) // List([2, 4])
-
-// Reduce
-const sum = numbers.foldLeft(0)((acc, x) => acc + x) // 10
-
-// Add/remove elements (immutably)
-const withFive = numbers.add(5) // List([1, 2, 3, 4, 5])
-const without3 = numbers.remove(3) // List([1, 2, 4])
-```
-
-### Try
-
-```typescript
-import { Try } from "functype"
-
-// Safely execute code that might throw
-const result = Try(() => {
-  // Potentially throwing operation
-  return JSON.parse('{"name": "John"}')
-})
-
-// Handle success/failure
-if (result.isSuccess()) {
-  console.log("Result:", result.get())
-} else {
-  console.error("Error:", result.error)
-}
-
-// Transform with map (only applies on Success)
-const name = result.map((obj) => obj.name)
-
-// Convert to Either
-const either = result.toEither()
-```
-
-### Task
-
-```typescript
-import { Task } from "functype"
-
-// Synchronous operations with error handling
-const syncResult = Task().Sync(
-  () => "success",
-  (error) => new Error(`Failed: ${error}`),
-)
-
-// Asynchronous operations
-const asyncTask = async () => {
-  const result = await Task().Async(
-    async () => await fetchData(),
-    async (error) => new Error(`Fetch failed: ${error}`),
-  )
-  return result
-}
-
-// Converting promise-based functions to Task
-const fetchUserAPI = (userId: string): Promise<User> => fetch(`/api/users/${userId}`).then((r) => r.json())
-
-// Use the adapter pattern for seamless integration
-const fetchUser = Task({ name: "UserFetch" }).fromPromise(fetchUserAPI)
-
-// Later use it with standard promise patterns
-fetchUser("user123")
-  .then((user) => console.log(user))
-  .catch((error) => console.error(error))
-
-// Or convert Task results back to promises
-const taskResult = Task().Sync(() => "hello world")
-const promise = Task().toPromise(taskResult) // Promise<string>
-```
-
-## Type Safety
-
-Functype leverages TypeScript's advanced type system to provide compile-time safety for functional patterns, ensuring that your code is both robust and maintainable.
-
-```typescript
-// Type inference works seamlessly
-const option = Option(42)
-// Inferred as number
-const mappedValue = option.map((x) => x.toString())
-// Inferred as string
-```
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-MIT License
-
-Copyright (c) 2025 Jordan Burke
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+# Functype
+
+![NPM Version](https://img.shields.io/npm/v/functype?link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2Ffunctype)
+[![Node.js Build](https://github.com/jordanburke/functype/actions/workflows/pnpm-build.yml/badge.svg)](https://github.com/jordanburke/functype/actions/workflows/pnpm-build.yml)
+
+## A Functional Programming Library for TypeScript
+
+Functype is a lightweight functional programming library for TypeScript, drawing inspiration from functional programming paradigms, the Scala Standard Library, and ZIO. It provides a comprehensive set of utilities and abstractions designed to facilitate functional programming within TypeScript applications.
+
+[API Documentation](https://jordanburke.github.io/functype/)
+
+## Core Principles
+
+- **Immutability**: All data structures are immutable, promoting predictable and side-effect-free code
+- **Type Safety**: Leverages TypeScript's type system to ensure compile-time safety
+- **Composability**: Provides abstractions for building complex programs from simple components
+- **Functional Paradigms**: Embraces concepts like monads, functors, and type classes
+
+## Key Features
+
+- **Option Type**: Handle nullable values with `Some` and `None` types
+- **Either Type**: Express computation results with potential failures using `Left` and `Right`
+- **List, Set, Map**: Immutable collection types with functional operators
+- **Try Type**: Safely execute operations that might throw exceptions
+- **Task**: Handle synchronous and asynchronous operations with error handling
+- **Tuple**: Type-safe fixed-length arrays
+- **Typeable**: Runtime type identification with compile-time safety
+
+## Roadmap / TODO
+
+### Missing Functionality
+
+- [ ] Add lazy evaluation structures (LazyList/Stream)
+- [ ] Implement Validation type for applicative validation
+- [ ] Add Reader/State/IO monads for more functional patterns
+- [ ] Implement lens/optics for immutable updates
+- [ ] Expand concurrent execution utilities beyond FPromise.all
+
+### Performance Optimizations
+
+- [ ] Add memoization utilities
+- [ ] Improve recursive operations for large collections
+- [ ] Implement immutable data structures with structural sharing
+- [ ] Add performance benchmarks
+- [x] Optimize TreeShaking with sideEffects flag in package.json
+- [x] Support selective module imports for smaller bundles
+- [x] Add bundle size monitoring to CI/CD
+
+### API Consistency
+
+- [ ] Ensure all modules follow the Scala-inspired pattern:
+  - Constructor functions that return objects with methods
+  - Object methods for common operations
+  - Companion functions for additional utilities
+- [x] Align Task API with other monadic structures
+- [ ] Standardize import patterns (@ imports vs relative paths)
+- [x] Implement consistent error handling strategy for async operations
+
+### Testing and Documentation
+
+- [ ] Add observable test coverage metrics
+- [x] Implement property-based testing
+- [ ] Expand error handling tests
+- [ ] Add interoperability tests with other libraries
+
+### TypeScript Improvements
+
+- [x] Enable stricter TypeScript settings (noImplicitAny: true)
+- [x] Add noUncheckedIndexedAccess for safer array indexing
+- [ ] Improve support for higher-kinded types:
+  - Current type parameters work well for first-order types
+  - Expand to support type constructors as parameters (F<A> => F<B>)
+- [ ] Add branded/nominal types for stronger type safety
+- [ ] Implement more type-level utilities (conditional types, template literals)
+- [ ] Leverage newer TypeScript features (const type parameters, tuple manipulation)
+
+## Installation
+
+```bash
+# NPM
+npm install functype
+
+# Yarn
+yarn add functype
+
+# PNPM
+pnpm add functype
+
+# Bun
+bun add functype
+```
+
+### Bundle Size Optimization
+
+Functype is optimized for tree-shaking and offers multiple import strategies to minimize bundle size:
+
+```typescript
+// Selective module imports (recommended for production)
+import { Option } from "functype/option"
+import { Either } from "functype/either"
+
+// Direct constructor imports (smallest bundle)
+import { some, none } from "functype/option"
+```
+
+For detailed optimization strategies, see the [Bundle Optimization Guide](docs/BUNDLE_OPTIMIZATION.md).
+
+## Usage Examples
+
+### Option
+
+```typescript
+import { Option, Some, None } from "functype"
+
+// Create options
+const value = Option("hello") // Some("hello")
+const empty = Option(null) // None
+const explicit = Some(42) // Some(42)
+
+// Transform values
+const length = value.map((s) => s.length) // Some(5)
+const nothing = empty.map((s) => s.length) // None
+
+// Handle default values
+const result = value.getOrElse("world") // "hello"
+const fallback = empty.getOrElse("world") // "world"
+
+// Conditionally filter
+const filtered = value.filter((s) => s.length > 10) // None
+```
+
+### Either
+
+```typescript
+import { Either, Right, Left } from "functype"
+
+// Success case
+const success = Right<string, number>(42)
+// Error case
+const failure = Left<string, number>("error")
+
+// Transform values (map only applies to Right)
+const doubled = success.map((x) => x * 2) // Right(84)
+const stillError = failure.map((x) => x * 2) // Left("error")
+
+// Handle errors
+const value = success.getOrElse(0) // 42
+const fallback = failure.getOrElse(0) // 0
+
+// Pattern matching with fold
+const result = success.fold(
+  (err) => `Error: ${err}`,
+  (val) => `Success: ${val}`,
+) // "Success: 42"
+```
+
+### List
+
+```typescript
+import { List } from "functype"
+
+const numbers = List([1, 2, 3, 4])
+
+// Transform
+const doubled = numbers.map((x) => x * 2) // List([2, 4, 6, 8])
+
+// Filter
+const evens = numbers.filter((x) => x % 2 === 0) // List([2, 4])
+
+// Reduce
+const sum = numbers.foldLeft(0)((acc, x) => acc + x) // 10
+
+// Add/remove elements (immutably)
+const withFive = numbers.add(5) // List([1, 2, 3, 4, 5])
+const without3 = numbers.remove(3) // List([1, 2, 4])
+```
+
+### Try
+
+```typescript
+import { Try } from "functype"
+
+// Safely execute code that might throw
+const result = Try(() => {
+  // Potentially throwing operation
+  return JSON.parse('{"name": "John"}')
+})
+
+// Handle success/failure
+if (result.isSuccess()) {
+  console.log("Result:", result.get())
+} else {
+  console.error("Error:", result.error)
+}
+
+// Transform with map (only applies on Success)
+const name = result.map((obj) => obj.name)
+
+// Convert to Either
+const either = result.toEither()
+```
+
+### Task
+
+```typescript
+import { Task } from "functype"
+
+// Synchronous operations with error handling
+const syncResult = Task().Sync(
+  () => "success",
+  (error) => new Error(`Failed: ${error}`),
+)
+
+// Asynchronous operations
+const asyncTask = async () => {
+  const result = await Task().Async(
+    async () => await fetchData(),
+    async (error) => new Error(`Fetch failed: ${error}`),
+  )
+  return result
+}
+
+// Converting promise-based functions to Task
+const fetchUserAPI = (userId: string): Promise<User> => fetch(`/api/users/${userId}`).then((r) => r.json())
+
+// Use the adapter pattern for seamless integration
+const fetchUser = Task({ name: "UserFetch" }).fromPromise(fetchUserAPI)
+
+// Later use it with standard promise patterns
+fetchUser("user123")
+  .then((user) => console.log(user))
+  .catch((error) => console.error(error))
+
+// Or convert Task results back to promises
+const taskResult = Task().Sync(() => "hello world")
+const promise = Task().toPromise(taskResult) // Promise<string>
+```
+
+## Type Safety
+
+Functype leverages TypeScript's advanced type system to provide compile-time safety for functional patterns, ensuring that your code is both robust and maintainable.
+
+```typescript
+// Type inference works seamlessly
+const option = Option(42)
+// Inferred as number
+const mappedValue = option.map((x) => x.toString())
+// Inferred as string
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License
+
+Copyright (c) 2025 Jordan Burke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/branded/index.mjs

@@ -1,2 +1,2 @@
-export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'../chunk-42EDYQ3O.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/{chunk-TQJDL6YW.mjs → chunk-42EDYQ3O.mjs}

@@ -1,2 +1,2 @@
-function e(n,r){return r}function t(n){return n}function d(n,r){return n!=null}function a(n){return r=>e(n,r)}var o=n=>r=>e(n,r),s=n=>r=>e(n,r),K=n=>r=>e(n,r);export{e as a,t as b,d as c,a as d,o as e,s as f,K as g};//# sourceMappingURL=chunk-TQJDL6YW.mjs.map
-//# sourceMappingURL=chunk-TQJDL6YW.mjs.map
+function e(n,r){return r}function t(n){return n}function d(n,r){return n!=null}function a(n){return r=>e(n,r)}var o=n=>r=>e(n,r),s=n=>r=>e(n,r),K=n=>r=>e(n,r);export{e as a,t as b,d as c,a as d,o as e,s as f,K as g};//# sourceMappingURL=chunk-42EDYQ3O.mjs.map
+//# sourceMappingURL=chunk-42EDYQ3O.mjs.map

package/dist/chunk-42EDYQ3O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/branded/Brand.ts"],"names":["Brand","brand","value","unbrand","branded","hasBrand","createBrander","BrandedString","BrandedNumber","BrandedBoolean"],"mappings":"AAoBO,SAASA,CAAAA,CAA2BC,CAAUC,CAAAA,CAAAA,CAAuB,CAC1E,OAAOA,CACT,CAOO,SAASC,CAAWC,CAAAA,CAAAA,CAA8B,CACvD,OAAOA,CACT,CAaO,SAASC,CAA8BH,CAAAA,CAAAA,CAAgBD,CAAgC,CAAA,CAG5F,OAAOC,CAAAA,EAAU,IACnB,CAOO,SAASI,CAAAA,CAAmCL,CAAU,CAAA,CAC3D,OAAQC,CAA0BF,EAAAA,CAAAA,CAAMC,CAAOC,CAAAA,CAAK,CACtD,KAQaK,CACQN,CAAAA,CAAAA,EAClBC,CACCF,EAAAA,CAAAA,CAAMC,CAAOC,CAAAA,CAAK,EAETM,CACQP,CAAAA,CAAAA,EAClBC,CACCF,EAAAA,CAAAA,CAAMC,CAAOC,CAAAA,CAAK,CAETO,CAAAA,CAAAA,CACQR,CAClBC,EAAAA,CAAAA,EACCF,CAAMC,CAAAA,CAAAA,CAAOC,CAAK","file":"chunk-42EDYQ3O.mjs","sourcesContent":["/**\r\n * Brand is a utility for creating nominal typing in TypeScript\r\n * It allows for creating distinct types that are structurally identical\r\n * but considered different by TypeScript's type system\r\n */\r\n\r\n// The brand symbol type\r\nexport type Brand<K extends string, T> = T & { readonly __brand: K }\r\n\r\n// Utility type to extract the underlying type from a branded type\r\nexport type Unbrand<T> = T extends Brand<string, infer U> ? U : never\r\n\r\n// Utility type to extract the brand from a branded type\r\nexport type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never\r\n\r\n/**\r\n * Helper to create a branded type\r\n * @param value - The value to brand\r\n * @returns The branded value\r\n */\r\nexport function Brand<K extends string, T>(brand: K, value: T): Brand<K, T> {\r\n  return value as Brand<K, T>\r\n}\r\n\r\n/**\r\n * Helper to remove a brand from a value\r\n * @param branded - The branded value\r\n * @returns The original value without the brand\r\n */\r\nexport function unbrand<T>(branded: Brand<string, T>): T {\r\n  return branded as T\r\n}\r\n\r\n/**\r\n * Type guard for checking if a value has a specific brand\r\n * @param value - The value to check\r\n * @param brand - The brand to check for\r\n * @returns True if the value has the specified brand\r\n *\r\n * Note: Since brands are phantom types that exist only at compile time,\r\n * this function can only provide a runtime approximation. It always returns true\r\n * for non-null values, as we have no way to actually check the brand at runtime.\r\n * This function is primarily for API consistency and documentation purposes.\r\n */\r\nexport function hasBrand<K extends string, T>(value: unknown, brand: K): value is Brand<K, T> {\r\n  // In a phantom type system, we can't actually check the brand at runtime\r\n  // We can only verify the value exists\r\n  return value !== null && value !== undefined\r\n}\r\n\r\n/**\r\n * Create a branded type constructor for a specific brand\r\n * @param brand - The brand name\r\n * @returns A function that brands values with the specified brand\r\n */\r\nexport function createBrander<K extends string, T>(brand: K) {\r\n  return (value: T): Brand<K, T> => Brand(brand, value)\r\n}\r\n\r\n// Common branded primitive types\r\nexport type BrandedString<K extends string> = Brand<K, string>\r\nexport type BrandedNumber<K extends string> = Brand<K, number>\r\nexport type BrandedBoolean<K extends string> = Brand<K, boolean>\r\n\r\n// Factory for common primitive branded types\r\nexport const BrandedString =\r\n  <K extends string>(brand: K) =>\r\n  (value: string): BrandedString<K> =>\r\n    Brand(brand, value)\r\n\r\nexport const BrandedNumber =\r\n  <K extends string>(brand: K) =>\r\n  (value: number): BrandedNumber<K> =>\r\n    Brand(brand, value)\r\n\r\nexport const BrandedBoolean =\r\n  <K extends string>(brand: K) =>\r\n  (value: boolean): BrandedBoolean<K> =>\r\n    Brand(brand, value)\r\n"]}

package/dist/{chunk-PXFJPCM7.mjs → chunk-DWRQQO3M.mjs}

@@ -1,2 +1,2 @@
-function n({_tag:e,impl:t}){return {...t,_tag:e}}function a(e,t){return !e||typeof e!="object"||!("_tag"in e)?false:t?e._tag===t:true}var T=e=>({_tag:"Tuple",map:t=>{let r=t(e);return T(r)},flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,[Symbol.iterator](){let t=0;return {next:()=>t<e.length?{value:e[t++],done:false}:{value:void 0,done:true}}},toValue:()=>({_tag:"Tuple",value:e})});export{n as a,a as b,T as c};//# sourceMappingURL=chunk-PXFJPCM7.mjs.map
-//# sourceMappingURL=chunk-PXFJPCM7.mjs.map
+function n({_tag:e,impl:t}){return {...t,_tag:e}}function a(e,t){return !e||typeof e!="object"||!("_tag"in e)?false:t?e._tag===t:true}var T=e=>({_tag:"Tuple",map:t=>{let r=t(e);return T(r)},flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,[Symbol.iterator](){let t=0;return {next:()=>t<e.length?{value:e[t++],done:false}:{value:void 0,done:true}}},toValue:()=>({_tag:"Tuple",value:e})});export{n as a,a as b,T as c};//# sourceMappingURL=chunk-DWRQQO3M.mjs.map
+//# sourceMappingURL=chunk-DWRQQO3M.mjs.map

package/dist/chunk-DWRQQO3M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/typeable/Typeable.ts","../src/tuple/Tuple.ts"],"names":["Typeable","_tag","impl","isTypeable","value","tag","Tuple","values","f","mapValue","index"],"mappings":"AAWO,SAASA,CAAAA,CAAgC,CAAE,IAAAC,CAAAA,CAAAA,CAAM,KAAAC,CAAK,CAAA,CAA6C,CACxG,OAAO,CACL,GAAGA,EACH,IAAMD,CAAAA,CACR,CACF,CAGO,SAASE,CAAAA,CAAcC,EAAgBC,CAAyB,CAAA,CACrE,OAAI,CAACD,CAAS,EAAA,OAAOA,GAAU,QAAY,EAAA,EAAE,MAAUA,GAAAA,CAAAA,CAAAA,CAC9C,KAGFC,CAAAA,CAAAA,CAAMD,EAAM,IAASC,GAAAA,CAAAA,CAAM,IACpC,CCPaC,IAAAA,CAAAA,CAA2BC,IAC/B,CACL,IAAA,CAAM,OACN,CAAA,GAAA,CAAwBC,CAAiC,EAAA,CACvD,IAAMC,CAAWD,CAAAA,CAAAA,CAAED,CAAM,CAAA,CACzB,OAAOD,CAAAA,CAAMG,CAAQ,CACvB,CAAA,CAEA,OAA4BD,CAAAA,CAAAA,EACnBA,CAAED,CAAAA,CAAM,EAGjB,GAAwBG,CAAAA,CAAAA,EACfH,CAAOG,CAAAA,CAAK,CAGrB,CAAA,OAAA,CAAS,IACAH,CAET,CAAA,CAAC,MAAO,CAAA,QAAQ,CAAyB,EAAA,CACvC,IAAIG,CAAQ,CAAA,CAAA,CACZ,OAAO,CACL,IAAM,CAAA,IACAA,EAAQH,CAAO,CAAA,MAAA,CACV,CACL,KAAA,CAAOA,CAAOG,CAAAA,CAAAA,EAAO,EACrB,IAAM,CAAA,KACR,CAEO,CAAA,CACL,KAAO,CAAA,MAAA,CACP,KAAM,IACR,CAGN,CACF,CAAA,CACA,OAAS,CAAA,KAAO,CAAE,IAAM,CAAA,OAAA,CAAS,KAAOH,CAAAA,CAAO,CACjD,CAAA,CAAA","file":"chunk-DWRQQO3M.mjs","sourcesContent":["// Core type for Typeable objects\r\nexport type Typeable<Tag extends string, T = object> = T & {\r\n  readonly _tag: Tag\r\n}\r\n\r\nexport type TypeableParams<Tag extends string, T> = { _tag: Tag; impl: T }\r\n\r\n// Utility type to extract the Tag from a Typeable type\r\nexport type ExtractTag<T> = T extends Typeable<infer Tag, unknown> ? Tag : never\r\n\r\n// Create a tagged object with type inference\r\nexport function Typeable<Tag extends string, T>({ _tag, impl }: TypeableParams<Tag, T>): Typeable<Tag, T> {\r\n  return {\r\n    ...impl,\r\n    _tag: _tag,\r\n  }\r\n}\r\n\r\n// Type guard with automatic type inference using the full type\r\nexport function isTypeable<T>(value: unknown, tag: string): value is T {\r\n  if (!value || typeof value !== \"object\" || !(\"_tag\" in value)) {\r\n    return false\r\n  }\r\n\r\n  return tag ? value._tag === tag : true\r\n}\r\n\r\n// // Usage\r\n// type User = Typeable<\r\n//   \"User\",\r\n//   {\r\n//     id: string\r\n//     name: string\r\n//     email: string\r\n//   }\r\n// >\r\n//\r\n// const user = Typeable(\"User\", {\r\n//   id: \"123\",\r\n//   name: \"John\",\r\n//   email: \"john@example.com\",\r\n// })\r\n//\r\n// const maybeUser: unknown = user\r\n//\r\n// // Now we only need to specify User type\r\n// if (isTypeable<User>(maybeUser, \"User\")) {\r\n//   console.log(maybeUser.name) // typed\r\n//   console.log(maybeUser.email) // typed\r\n//   console.log(maybeUser._tag) // typed as \"User\"\r\n// }\r\n//\r\n// // Can still check just for Typeable without specific tag\r\n// if (isTypeable<User>(maybeUser)) {\r\n//   console.log(maybeUser.name) // typed\r\n//   console.log(maybeUser.email) // typed\r\n//   console.log(maybeUser._tag) // typed as \"User\"\r\n// }\r\n","import type { ArrayFunctor, Type } from \"@/functor\"\r\nimport { Typeable } from \"@/typeable/Typeable\"\r\nimport { Valuable } from \"@/valuable/Valuable\"\r\n\r\nexport type Tuple<T extends Type[]> = {\r\n  get<K extends number>(index: K): T[K]\r\n\r\n  map<U extends Type[]>(f: (value: T) => U): Tuple<U>\r\n\r\n  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>\r\n\r\n  toArray(): T\r\n\r\n  [Symbol.iterator](): Iterator<T[number]>\r\n} & ArrayFunctor<T> &\r\n  Typeable<\"Tuple\"> &\r\n  Valuable<\"Tuple\", T>\r\n\r\nexport const Tuple = <T extends Type[]>(values: T): Tuple<T> => {\r\n  return {\r\n    _tag: \"Tuple\",\r\n    map: <U extends Type[]>(f: (value: T) => U): Tuple<U> => {\r\n      const mapValue = f(values)\r\n      return Tuple(mapValue)\r\n    },\r\n\r\n    flatMap: <U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U> => {\r\n      return f(values)\r\n    },\r\n\r\n    get: <K extends number>(index: K): T[K] => {\r\n      return values[index]\r\n    },\r\n\r\n    toArray: (): T => {\r\n      return values\r\n    },\r\n    [Symbol.iterator](): Iterator<T[number]> {\r\n      let index = 0\r\n      return {\r\n        next: (): IteratorResult<T[number]> => {\r\n          if (index < values.length) {\r\n            return {\r\n              value: values[index++],\r\n              done: false,\r\n            }\r\n          } else {\r\n            return {\r\n              value: undefined,\r\n              done: true,\r\n            }\r\n          }\r\n        },\r\n      }\r\n    },\r\n    toValue: () => ({ _tag: \"Tuple\", value: values }),\r\n  }\r\n}\r\n"]}