slang-ts 0.0.2 → 0.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 Functional programming library for TypeScript.
 
-My experiment to learn more functional programming and other cool programming stuff from other languages as I try to implement them in TypeScript.
+A collection of functional programming utilities and other cool programming stuff from other languages such as rust implemented in TypeScript.
 
 ## Install
 
@@ -19,17 +19,16 @@ npm i slang-ts
 - [x] Expect
 - [x] Unwrap (on Option)
 - [x] Else (on unwrap)
-- [ ] Panic!
+- [x] Panic
 - [x] Zip, Unzip, zipWith
-- [ ] Try
-- [ ] Catch
+- [x] SafeTry
 - [x] Match
 - [x] MatchAll
-- [ ] Pipe
+- [x] Pipe
 - [ ] Map
 - [x] To (converters, e.g. `userAtom.to('option')`)
 - [ ] Promises and async utilities
-- [ ] Curry
+- [ ] Currys
 
 ## Others (Planned)
 
@@ -46,6 +45,11 @@ import { Ok, Err } from "slang-ts";
 
 // Or import multiple at once
 import { option, Ok, Err, atom, match } from "slang-ts";
+
+// Or import under namespace (not so performant)
+import * as slang from "slang-ts";
+
+slang.println("Hello world!");
 ```
 
 ### println
@@ -296,6 +300,90 @@ println(unzip(zipped));
 // [[1, 2, 3], [4, 5, 6]]
 ```
 
+### Pipe
+
+Sequential function composition where each function receives a `Result` and returns a `Result`. Accepts plain values, Option, Result, or Atom as initial input.
+
+```ts
+import { pipe, Ok, Err, option, type Result } from "slang-ts";
+
+// Create pipeline functions
+const add = (x: number) => (res: Result<number, string>) =>
+  res.isOk ? Ok(res.value + x) : res;
+
+const multiply = (x: number) => (res: Result<number, string>) =>
+  res.isOk ? Ok(res.value * x) : res;
+
+// Basic usage
+const result = await pipe(5, add(3), multiply(2)).run();
+println("Result:", result.value); // 16
+
+// With Options as initial value
+const fromOption = await pipe(option(10), add(5)).run();
+println("From option:", fromOption.value); // 15
+
+// With callbacks and error handling
+const result = await pipe(5, add(3), multiply(2)).run({
+  onEach: ({ currentFn, prevResult }) => {
+    println("Executed:", currentFn);
+  },
+  onSuccess: (value) => println("Done:", value),
+  onError: (err) => println("Failed:", err.message),
+  allowErrors: false, // stops pipeline on first Err
+});
+```
+
+### SafeTry
+
+Wraps potentially throwing functions in try-catch, returning a `Result<T, string>`. Always needs to be awaited as its async.
+
+```ts
+import { safeTry } from "slang-ts";
+
+const result = await safeTry(() => {
+  if (denom === 0) throw new Error("Cannot divide by zero");
+  return num / denom;
+});
+
+if (result.isOk) {
+  println("Result:", result.value);
+} else {
+  println("Error:", result.error);
+}
+
+// Async functions work the same way
+const data = await safeTry(async () => {
+  const res = await fetch("/api/user");
+  return res.json();
+});
+
+if (data.isOk) {
+  println("User:", data.value);
+}
+
+// Re-throw critical errors instead of capturing
+await safeTry(() => {
+  throw new Error("Critical!");
+}, { throw: true });
+```
+
+### Panic
+
+Throws an error immediately. Use for unrecoverable failures.
+
+```ts
+import { panic } from "slang-ts";
+
+function processUser(user: User | null) {
+  if (!user) panic("User cannot be null");
+  return user.name;
+}
+
+// Guard clause pattern
+const config = loadConfig();
+if (!config.apiKey) panic("API key required");
+```
+
 And more are to be implemented in coming versions...
 
 ## Code Samples

package/dist/index.d.ts

@@ -1,281 +1,5 @@
-export declare const println: (...args: unknown[]) => void;
 /**
- * Converts between Slang types.
- * - `option`: Wraps primitive or symbol description into `Option`
- * - `atom`: Converts `Some<string>` to `Atom` or returns symbol Atom
- * - `result`: Wraps values into `Ok`, `None` into `Err`
+ * Slang - Functional programming utilities for TypeScript
+ * Re-exports all types and functions from the modular src folder.
  */
-export declare function _to<T>(value: Option<T>, target: "option"): Option<T>;
-export declare function _to<T extends string>(value: Option<T>, target: "atom"): Atom<T>;
-export declare function _to<T extends string>(value: Atom<T>, target: "option"): Option<string>;
-export declare function _to<T extends string>(value: Atom<T>, target: "atom"): Atom<T>;
-export declare function _to<T, E = string>(value: Option<T>, target: "result"): Result<T, E>;
-export declare function _to<E = string>(value: Atom<any>, target: "result"): Result<string, E>;
-/** Unique symbol to brand atoms */
-declare const __atom__: unique symbol;
-/** Atom type carrying the original name for hover/type info */
-export type Atom<T extends string = string> = symbol & {
-    readonly [__atom__]: T;
-};
-/**
- * Creates a new, unique atom (non-interned)
- * @param name Name of the atom (used for hover/description)
- * @example
- * const a = atom("loading");
- * typeof a; // Atom<"loading">
- */
-/**
- * Creates a new, unique atom (non-interned)
- * @param name Name of the atom (used for hover/description)
- * @returns `Atom<T>` with chainable `to()`
- * @example
- * const ready = atom("ready");
- * ready.to("option"); // Some("ready")
- * ready.to("result"); // Ok("ready")
- */
-/** Methods available on an Atom */
-export interface AtomMethods<T extends string> {
-    /** Returns the same atom */
-    to(target: "atom"): Atom<T>;
-    /** Returns `Option<string>` using the atom description
-     * @example atom("ready").to("option") // Some("ready")
-     */
-    to(target: "option"): Option<string>;
-    /** Returns `Ok<string>` using the atom description
-     * @example atom("ready").to("result") // Ok("ready")
-     */
-    to(target: "result"): Result<string, string>;
-}
-export declare function atom<const T extends string>(name: T): Atom<T> & AtomMethods<T>;
-declare const __result__: unique symbol;
-export type Ok<T> = {
-    type: "Ok";
-    value: T;
-    readonly isOk: true;
-    readonly isErr: false;
-    readonly [__result__]: true;
-};
-export type Err<E> = {
-    type: "Err";
-    error: E;
-    readonly isOk: false;
-    readonly isErr: true;
-    readonly [__result__]: true;
-};
-export type Result<T, E> = (Ok<T> | Err<E>) & ResultMethods<T>;
-/**
- * Creates a new, successful result
- * @param value Value of the result
- * @example
- * const a = Ok("hello");
- * typeof a; // Ok<"hello">
- */
-/** Methods available on a Result */
-export interface ResultMethods<T> {
-    /** Unwraps the value, throwing for Err
-     * @example maybeFail().expect("must succeed")
-     */
-    expect(msg?: string): T;
-    /** Returns an unwrap chain that throws if no else is provided
-     * Use `.else(valueOrFn)` to supply a fallback for Err.
-     * - If `Ok`, `.else(...)` returns the inner value and ignores fallback.
-     * - If `Err`, `.else(...)` returns the fallback; if a function, it receives the error.
-     */
-    unwrap(): {
-        /** Fallback value or function to recover from Err
-         * If a function is provided, it is called with the Err's error.
-         * Returns the unwrapped value (Ok) or the provided fallback (Err).
-         */ else(fallback: T | ((error: any) => T)): T;
-    };
-}
-/** Creates a new, successful result */
-export declare function Ok<T>(value: T): Ok<T> & ResultMethods<T>;
-/**
- * Creates a new, failed result
- * @param error Error of the result
- * @example
- * const a = Err("error");
- * typeof a; // Err<"error">
- */
-/** Creates a new, failed result */
-export declare function Err<E>(error: E): Err<E> & ResultMethods<never>;
-declare const __option__: unique symbol;
-export type Some<T> = {
-    type: "Some";
-    value: T;
-    readonly isSome: true;
-    readonly isNone: false;
-    readonly [__option__]: true;
-};
-export type None = {
-    type: "None";
-    readonly isSome: false;
-    readonly isNone: true;
-    readonly [__option__]: true;
-};
-export type Option<T> = (Some<T> | None) & OptionMethods<T>;
-export type NonTruthy = null | undefined | "";
-/**
- * Creates a new option type from a value
- * @param value - the value to be made an option
- * @tutorial The returned option will be Some if the value is truthy, and None if it is not (null,undefined,Nan,'')
- * @example
- * const b = option("hello");
- * typeof b; // Some<"hello">
- * const c = option(null);
- * typeof c; // None
- * const d = option(undefined);
- * typeof d; // None
- * const e = option(0);
- * typeof e; // Some<number>
- * const f = option("");
- * typeof f; // None
- * const g = option(false);
- * typeof g; // Some<boolean>
- */
-/** Methods available on an Option */
-export interface OptionMethods<T> {
-    /** Returns the same option */
-    to(target: "option"): Option<T>;
-    /** Converts `Some<string>` to `Atom<string>`; throws for `None` or non-string */
-    to(target: "atom"): Atom<T & string>;
-    /** Converts to `Result<T, string>`; `None` becomes `Err("Value is None")` */
-    to(target: "result"): Result<T | (T extends string ? never : Atom<string>), string>;
-    /**
-     * Unwraps the option, throwing if `None`.
-     * @throws Error with provided message or default.
-     * @example
-     * option(42).expect(); // 42
-     * option("").expect("must be present"); // throws
-     */
-    expect(msg?: string): T;
-    /** Returns an unwrap chain that MUST be completed with `.else(...)`.
-     * If `.else(...)` is not chained, an error is thrown ("Expected else").
-     * - If `Some`, `.else(...)` is required but ignored for outcome; returns the inner value.
-     * - If `None`, `.else(...)` provides fallback; if a function, it is called with `undefined`.
-     * - Fallback result must be truthy; otherwise, throws ("Fallback must be truthy").
-     */
-    unwrap(): {
-        /** Fallback value or transformer to recover from `None`.
-         * - Function form receives `undefined` and must return a truthy value.
-         * - Direct value must be truthy.
-         * Returns the inner value for `Some`, or the validated fallback for `None`.
-         */ else(fallback: T | ((value: T | undefined) => T)): T;
-    };
-}
-/**
- * Creates a new option type from a value.
- * - Truthy values become `Some<T>`; `null|undefined|""` become `None`.
- * - Provides chainable `.to()` and `.expect()` helpers.
- * @example
- * option("hi").expect(); // "hi"
- * option("").expect("cannot be empty"); // throws Error("cannot be empty")
- * option("state").to("atom"); // Atom<"state">
- * option(null).to("result"); // Err("Value is None")
- */
-export declare function option<T>(value: T | NonTruthy): Option<T> & OptionMethods<T>;
-/**
- * Pattern matching for `Result` and `Option` — exhaustiveness enforced.
- *
- * Returns the value returned by the selected handler. If all handlers return
- * `Result` or `Option`, TypeScript will infer that automatically.
- */
-export declare function match<T, E, R>(value: Result<T, E> | (Result<any, any> & ResultMethods<any>), patterns: {
-    Ok: ((v: Ok<T>) => R) | (() => R);
-    Err: ((e: Err<E>) => R) | (() => R);
-}): R;
-export declare function match<T, R>(value: Some<T> | None, patterns: {
-    Some: ((v: Some<T>) => R) | (() => R);
-    None: ((v: None) => R) | (() => R);
-}): R;
-/**
- * Allowed keys in matchAll patterns.
- * - Strings, numbers, and Atom descriptions.
- * - Booleans are represented as "true" | "false" strings
- */
-type MatchKey = string | number | symbol;
-/**
- * Type-safe pattern object: must always have `_` fallback.
- */
-type MatchPatterns<V, R> = {
-    [K in MatchKey]?: (v: V) => R;
-} & {
-    _: () => R;
-};
-/**
- * Matches a value against literal or Atom cases by *semantic name*.
- * - Supports string, number, booleans and Atom (symbol) values.
- * - Unsupported will throw an error. (objects, arrays, functions, etc)
- * - For Atoms, uses their description as a key (e.g. atom("ready") → "ready").
- * - Requires a `_` default handler.
- *
- * @example
- * matchAll(ready, {
- *   1: () => println("One"),
- *   2: () => println("Two"),
- *   0: () => println("Zero"),
- *   true: () => println("True"),
- *   false: () => println("False"),
- *   ready: () => println("Ready!"),
- *   failed: () => println("Failed!"),
- *   _: () => println("Unknown!"),
- * });
- */
-export declare function matchAll<T extends MatchKey | boolean, R>(value: T, patterns: MatchPatterns<T, R>): R;
-/**
- * Combines multiple collections element-wise into tuples.
- * - All inputs must be the same type (all arrays, all Sets, or all objects).
- * - By default, only arrays are allowed; set `includeValues: true` to extract values from Sets/Objects.
- * - Stops at shortest collection by default; use `fillValue` to extend to longest.
- * - Transforms columns into rows for parallel iteration.
- * @param inputs Collections of the same type to combine
- * @param options Configuration: `fillValue` extends to longest, `includeValues` extracts values from Sets/Objects (default: false)
- * @returns Array of tuples, one per index position
- * @example
- * zip([[1, 2], ['a', 'b']]); // [[1, 'a'], [2, 'b']]
- * zip([[1, 2], ['a']], { fillValue: 'x' }); // [[1, 'a'], [2, 'x']]
- * const s1 = new Set([1, 2]); const s2 = new Set([3, 4]);
- * zip([s1, s2], { includeValues: true }); // [[1, 3], [2, 4]]
- */
-export declare function zip<T extends readonly any[]>(inputs: {
-    [K in keyof T]: Iterable<T[K]> | {
-        [key: string]: T[K];
-    };
-}, options?: {
-    fillValue?: T[number];
-    includeValues?: boolean;
-}): T[number][][];
-/**
- * Combines multiple collections element-wise and transforms each tuple.
- * - All inputs must be the same type (all arrays, all Sets, or all objects).
- * - By default, only arrays are allowed; set `includeValues: true` to extract values from Sets/Objects.
- * - Applies a function to each set of corresponding elements.
- * - Useful for aggregating, computing, or transforming aligned data.
- * @param inputs Collections of the same type to combine
- * @param fn Transform function applied to each tuple
- * @param options Configuration: `fillValue` extends to longest, `includeValues` extracts values from Sets/Objects (default: false)
- * @returns Array of transformed results
- * @example
- * zipWith([[1, 2], [3, 4]], (t) => t[0] + t[1]); // [4, 6]
- * zipWith([[1, 2], [10]], (t) => t.reduce((a, b) => a + b, 0), { fillValue: 0 }); // [11, 2]
- */
-export declare function zipWith<T extends readonly any[], R>(inputs: {
-    [K in keyof T]: Iterable<T[K]> | {
-        [key: string]: T[K];
-    };
-}, fn: (tuple: T[number][]) => R, options?: {
-    fillValue?: T[number];
-    includeValues?: boolean;
-}): R[];
-/**
- * Unzips an array of tuples back into separate arrays.
- * - Reverses the zip operation: transforms rows to columns.
- * - Useful for separating previously combined collections.
- * @param zipped Array of tuples (rows) to transpose
- * @returns Array of arrays (columns), one per tuple position
- * @example
- * const zipped = [[1, 'a'], [2, 'b'], [3, 'c']];
- * unzip(zipped); // [[1, 2, 3], ['a', 'b', 'c']]
- */
-export declare function unzip<T>(zipped: T[][]): T[][];
-export {};
+export * from "./src";

package/dist/index.js

@@ -1 +1 @@
-var _=(...j)=>{globalThis?.console?.log?.(...j)},Z=(j)=>{let B=globalThis?.queueMicrotask;if(typeof B==="function")B(j);else Promise.resolve().then(j)};function $(j,B){let G=(H)=>H!=null&&typeof H==="object"&&("isSome"in H)&&("isNone"in H);if(j&&(j.type==="Ok"||j.type==="Err"))throw Error("Cannot convert a Result to any other type");switch(B){case"option":{if(G(j))return j;if(typeof j==="symbol")return Y(j.description);return Y(j)}case"atom":{if(G(j)){if(j.isNone)throw Error("Cannot convert None to Atom");if(typeof j.value!=="string")throw Error("Only string values can be converted to Atom");return N(j.value)}if(typeof j==="symbol")return j;throw Error(`Cannot convert type ${typeof j} to Atom`)}case"result":{if(G(j))return j.isSome?X(j.value):R("Value is None");if(typeof j==="symbol")return X(j.description);return X(j)}default:throw Error(`Invalid target: ${B}`)}}function N(j){let B=Symbol(j),G=Object(B),H=(D)=>$(B,D);return G.to=H,G}function X(j){let B=Object.freeze({type:"Ok",value:j,isOk:!0,isErr:!1});return{...B,expect:(H)=>B.value,unwrap:()=>{let H=!1;return Z(()=>{}),{else(D){return H=!0,B.value}}}}}function R(j){let B=Object.freeze({type:"Err",error:j,isOk:!1,isErr:!0}),G=(D,I)=>{if(typeof D==="string")return D;if(D&&typeof D==="object"&&"message"in D)return String(D.message);return I??String(D)};return{...B,expect:(D)=>{throw Error(D??G(B.error,"Expected Ok, got Err"))},unwrap:()=>{let D=!1;return Z(()=>{if(!D){let I=G(B.error,"Expected Ok, got Err");throw Error(I)}}),{else(I){if(D=!0,typeof I==="function")return I(B.error);return I}}}}}var C=(j)=>{return j===null||j===void 0||j===""||Number.isNaN(j)||j===1/0||j===-1/0};function q(j){if(C(j))throw Error("Cannot wrap null, undefined, NaN, or empty string in Some");return Object.freeze({type:"Some",value:j,isSome:!0,isNone:!1})}var F=Object.freeze({type:"None",isSome:!1,isNone:!0});function Y(j){let B=C(j)?F:q(j);return{...B,to:(P)=>$(B,P),expect:(P)=>{if(B.isSome)return B.value;throw Error(P??"Expected Some, got None")},unwrap:()=>{let P=!1,Q=B;return Z(()=>{if(!P)throw Error("Expected else")}),{else(T){if(P=!0,Q.isSome)return Q.value;let J=typeof T==="function"?T(void 0):T;if(Y(J).isNone)throw Error("Fallback must be truthy");return J}}}}}function A(j,B){let G=B[j.type];if(!G)throw Error(`Non-exhaustive match — missing handler for '${j.type}'`);return G(j)}var L=(j)=>{return typeof j==="string"||typeof j==="number"||typeof j==="boolean"||typeof j==="symbol"};function E(j,B){let G=(Q)=>typeof Q?.valueOf==="function"?Q.valueOf():Q,H=(Q)=>typeof Q==="symbol"?Q.description:void 0,D=G(j);if(!L(D))throw Error(`Unsupported match all value type: ${typeof D}`);let I=H(D)??D,P=typeof I==="boolean"||typeof I==="number"?String(I):I;if(P!=null&&P in B)return B[P](j);return B._()}function S(j,B=!1){if(!B&&!Array.isArray(j))throw Error("Only arrays allowed when includeValues=false");if(Array.isArray(j))return j;if(j instanceof Set)return Array.from(j);return Object.values(j)}function U(j,B){let{fillValue:G,includeValues:H=!1}=B||{};if(j.length===0)return[];let D=j.map((J)=>S(J,H)),I=Math.max(...D.map((J)=>J.length)),P=Math.min(...D.map((J)=>J.length)),Q=G===void 0?P:I,T=[];for(let J=0;J<Q;J++)T.push(D.map((W)=>J<W.length?W[J]:G));return T}function K(j,B,G){return U(j,G).map(B)}function M(j){if(j.length===0)return[];let B=j[0]?.length??0,G=Array.from({length:B},()=>[]);for(let H of j)H.forEach((D,I)=>G[I]?.push(D));return G}export{K as zipWith,U as zip,M as unzip,_ as println,Y as option,E as matchAll,A as match,N as atom,$ as _to,X as Ok,R as Err};
+var W=(G)=>{let B=globalThis?.queueMicrotask;if(typeof B==="function")B(G);else Promise.resolve().then(G)},C=(G)=>G!=null&&typeof G==="object"&&("type"in G)&&(G.type==="Ok"||G.type==="Err"),F=(G)=>G!=null&&typeof G==="object"&&("isSome"in G)&&("isNone"in G),z=(G)=>G!=null&&typeof G==="object"&&typeof G.valueOf?.()==="symbol";function q(G){if(z(G))return{ok:!0,value:G.valueOf().description};if(C(G)){if(G.isOk)return{ok:!0,value:G.value};return{ok:!1,error:typeof G.error==="string"?G.error:String(G.error)}}if(F(G)){if(G.isSome)return{ok:!0,value:G.value};return{ok:!1,error:"Option was None"}}return{ok:!0,value:G}}var O=(...G)=>{globalThis?.console?.log?.(...G)};function E(G){throw Error(G)}function L(G){let B=Object.freeze({type:"Ok",value:G,isOk:!0,isErr:!1});return{...B,expect:(J)=>B.value,unwrap:()=>{let J=!1;return W(()=>{}),{else(Q){return J=!0,B.value}}}}}function I(G){return{...Object.freeze({type:"Err",error:G,isOk:!1,isErr:!0}),expect:(J)=>{throw Error(J??G)},unwrap:()=>{let J=!1;return W(()=>{if(!J)throw Error(G)}),{else(Q){if(J=!0,typeof Q==="function")return Q(G);return Q}}}}}var K=(G)=>{return G===null||G===void 0||G===""||Number.isNaN(G)||G===1/0||G===-1/0};function R(G){if(K(G))throw Error("Cannot wrap null, undefined, NaN, or empty string in Some");return Object.freeze({type:"Some",value:G,isSome:!0,isNone:!1})}var g=Object.freeze({type:"None",isSome:!1,isNone:!0}),N=null;function M(G){N=G}function U(G){let B=K(G)?g:R(G);return{...B,to:($)=>{if(!N)throw Error("Converter not initialized");return N(B,$)},expect:($)=>{if(B.isSome)return B.value;throw Error($??"Expected Some, got None")},unwrap:()=>{let $=!1,X=B;return W(()=>{if(!$)throw Error("Expected else")}),{else(j){if($=!0,X.isSome)return X.value;let Y=typeof j==="function"?j(void 0):j;if(K(Y))throw Error("Fallback must be truthy");return Y}}}}}var P=null;function _(G){P=G}function S(G){let B=Symbol(G),D=Object(B),J=(Q)=>{if(!P)throw Error("Converter not initialized");return P(B,Q)};return D.to=J,D}var T=(G)=>G!=null&&typeof G==="object"&&("isSome"in G)&&("isNone"in G);function V(G,B){if(G&&(G.type==="Ok"||G.type==="Err"))throw Error("Cannot convert a Result to any other type");switch(B){case"option":{if(T(G))return G;if(typeof G==="symbol")return U(G.description);return U(G)}case"atom":{if(T(G)){if(G.isNone)throw Error("Cannot convert None to Atom");if(typeof G.value!=="string")throw Error("Only string values can be converted to Atom");return S(G.value)}if(typeof G==="symbol")return G;throw Error(`Cannot convert type ${typeof G} to Atom`)}case"result":{if(T(G))return G.isSome?L(G.value):I("Value is None");if(typeof G==="symbol")return L(G.description);return L(G)}default:throw Error(`Invalid target: ${B}`)}}M(V);_(V);function w(G,B){let D=B[G.type];if(!D)throw Error(`Non-exhaustive match — missing handler for '${G.type}'`);return D(G)}var b=(G)=>{return typeof G==="string"||typeof G==="number"||typeof G==="boolean"||typeof G==="symbol"};function k(G,B){let D=(X)=>typeof X?.valueOf==="function"?X.valueOf():X,J=(X)=>typeof X==="symbol"?X.description:void 0,Q=D(G);if(!b(Q))throw Error(`Unsupported match all value type: ${typeof Q}`);let H=J(Q)??Q,$=typeof H==="boolean"||typeof H==="number"?String(H):H;if($!=null&&$ in B)return B[$](G);return B._()}function h(G,B=!1){if(!B&&!Array.isArray(G))throw Error("Only arrays allowed when includeValues=false");if(Array.isArray(G))return G;if(G instanceof Set)return Array.from(G);return Object.values(G)}function A(G,B){let{fillValue:D,includeValues:J=!1}=B||{};if(G.length===0)return[];let Q=G.map((Y)=>h(Y,J)),H=Math.max(...Q.map((Y)=>Y.length)),$=Math.min(...Q.map((Y)=>Y.length)),X=D===void 0?$:H,j=[];for(let Y=0;Y<X;Y++)j.push(Q.map((Z)=>Y<Z.length?Z[Y]:D));return j}function y(G,B,D){return A(G,D).map(B)}function f(G){if(G.length===0)return[];let B=G[0]?.length??0,D=Array.from({length:B},()=>[]);for(let J of G)J.forEach((Q,H)=>D[H]?.push(Q));return D}async function m(G,B){let D=B?.throw??!1;try{let J=await G(),Q=q(J);if(Q.ok)return L(Q.value);return I(Q.error)}catch(J){let Q=J instanceof Error?J.message:String(J);if(D)throw J instanceof Error?J:Error(Q);return I(Q)}}function x(G){return G.error??"Unknown error"}function d(G){let B=q(G);if(B.ok)return L(B.value);return I(B.error)}async function c(G,B){try{let D=await G(B);if(!C(D))return I("Pipeline function must return a Result");return D}catch(D){let J=D instanceof Error?D.message:String(D);return I(J)}}function p(G,...B){return{async run(D){let{onEach:J,onSuccess:Q,onError:H,allowErrors:$=!1}=D??{},X=d(G);for(let j=0;j<B.length;j++){let Y=B[j],Z=B[j+1];if(X.isErr&&!$)return H?.(Error(x(X))),X;X=await c(Y,X),J?.({prevResult:X,currentFn:Y.name||`fn${j+1}`,nextFn:Z?Z.name||`fn${j+2}`:void 0})}if(X.isOk)Q?.(X.value);else H?.(Error(x(X)));return X}}}export{y as zipWith,A as zip,f as unzip,W as scheduleMicrotask,m as safeTry,O as println,p as pipe,E as panic,U as option,k as matchAll,w as match,K as isFalsy,S as atom,V as _to,L as Ok,I as Err};

package/dist/src/atom.d.ts

@@ -0,0 +1,40 @@
+import type { Option } from "./option";
+import type { Result } from "./result";
+/** Unique symbol to brand atoms */
+declare const __atom__: unique symbol;
+/** Atom type carrying the original name for hover/type info */
+export type Atom<T extends string = string> = symbol & {
+    readonly [__atom__]: T;
+};
+/** Methods available on an Atom */
+export interface AtomMethods<T extends string> {
+    /** Returns the same atom */
+    to(target: "atom"): Atom<T>;
+    /**
+     * Returns `Option<string>` using the atom description.
+     * @example atom("ready").to("option") // Some("ready")
+     */
+    to(target: "option"): Option<string>;
+    /**
+     * Returns `Ok<string>` using the atom description.
+     * @example atom("ready").to("result") // Ok("ready")
+     */
+    to(target: "result"): Result<string, string>;
+}
+/**
+ * Sets the _to converter function (called from to.ts to break circular dep).
+ * @internal
+ */
+export declare function setToConverter(fn: (value: any, target: string) => any): void;
+/**
+ * Creates a new, unique atom (non-interned).
+ * - Atoms are symbols with additional methods for type-safe conversions.
+ * @param name - Name of the atom (used for hover/description).
+ * @returns `Atom<T>` with chainable `to()` method for conversions.
+ * @example
+ * const ready = atom("ready");
+ * ready.to("option"); // Some("ready")
+ * ready.to("result"); // Ok("ready")
+ */
+export declare function atom<const T extends string>(name: T): Atom<T> & AtomMethods<T>;
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+export { scheduleMicrotask } from "./internals";
+export { println } from "./println";
+export { panic } from "./panic";
+export { Ok, Err } from "./result";
+export type { Result, ResultMethods, Ok as OkType, Err as ErrType } from "./result";
+export { option, isFalsy } from "./option";
+export type { Option, OptionMethods, Some, None, NonTruthy } from "./option";
+export { atom } from "./atom";
+export type { Atom, AtomMethods } from "./atom";
+import "./to";
+export { _to } from "./to";
+export { match, matchAll } from "./match";
+export { zip, zipWith, unzip } from "./zip";
+export { safeTry } from "./safe-try";
+export { pipe } from "./pipe";
+export type { PipeFn, PipeEachContext, PipeRunOptions, Pipeline } from "./pipe";

package/dist/src/internals.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from "./result";
+import type { Option } from "./option";
+/**
+ * Schedules a microtask; falls back to Promise if unavailable.
+ * Used internally for deferred error handling in unwrap chains.
+ */
+export declare const scheduleMicrotask: (fn: () => void) => void;
+/** Type guard for Result */
+export declare const isResult: (value: unknown) => value is Result<unknown, unknown>;
+/** Type guard for Option */
+export declare const isOption: (value: unknown) => value is Option<unknown>;
+/** Type guard for Atom (boxed symbol) */
+export declare const isAtom: (value: unknown) => boolean;
+/** Evaluated value result type */
+export type EvaluatedValue = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Extracts inner value from Slang types (Atom, Result, Option) or plain values.
+ * Returns a discriminated union indicating success or failure.
+ */
+export declare function evaluateValue<T>(value: T): EvaluatedValue;

package/dist/src/match.d.ts

@@ -0,0 +1,51 @@
+import type { Ok, Err, Result, ResultMethods } from "./result";
+import type { Some, None } from "./option";
+/**
+ * Pattern matching for `Result` and `Option` — exhaustiveness enforced.
+ *
+ * Returns the value returned by the selected handler. If all handlers return
+ * `Result` or `Option`, TypeScript will infer that automatically.
+ */
+export declare function match<T, E, R>(value: Result<T, E> | (Result<any, any> & ResultMethods<any>), patterns: {
+    Ok: ((v: Ok<T>) => R) | (() => R);
+    Err: ((e: Err<E>) => R) | (() => R);
+}): R;
+export declare function match<T, R>(value: Some<T> | None, patterns: {
+    Some: ((v: Some<T>) => R) | (() => R);
+    None: ((v: None) => R) | (() => R);
+}): R;
+/**
+ * Allowed keys in matchAll patterns.
+ * - Strings, numbers, and Atom descriptions.
+ * - Booleans are represented as "true" | "false" strings
+ */
+type MatchKey = string | number | symbol;
+/**
+ * Type-safe pattern object: must always have `_` fallback.
+ */
+type MatchPatterns<V, R> = {
+    [K in MatchKey]?: (v: V) => R;
+} & {
+    _: () => R;
+};
+/**
+ * Matches a value against literal or Atom cases by *semantic name*.
+ * - Supports string, number, booleans and Atom (symbol) values.
+ * - Unsupported will throw an error. (objects, arrays, functions, etc)
+ * - For Atoms, uses their description as a key (e.g. atom("ready") → "ready").
+ * - Requires a `_` default handler.
+ *
+ * @example
+ * matchAll(ready, {
+ *   1: () => println("One"),
+ *   2: () => println("Two"),
+ *   0: () => println("Zero"),
+ *   true: () => println("True"),
+ *   false: () => println("False"),
+ *   ready: () => println("Ready!"),
+ *   failed: () => println("Failed!"),
+ *   _: () => println("Unknown!"),
+ * });
+ */
+export declare function matchAll<T extends MatchKey | boolean, R>(value: T, patterns: MatchPatterns<T, R>): R;
+export {};

package/dist/src/option.d.ts

@@ -0,0 +1,85 @@
+import type { Atom } from "./atom";
+import type { Result } from "./result";
+declare const __option__: unique symbol;
+export type Some<T> = {
+    type: "Some";
+    value: T;
+    readonly isSome: true;
+    readonly isNone: false;
+    readonly [__option__]: true;
+};
+export type None = {
+    type: "None";
+    readonly isSome: false;
+    readonly isNone: true;
+    readonly [__option__]: true;
+};
+export type Option<T> = (Some<T> | None) & OptionMethods<T>;
+/** Values treated as falsy by Option */
+export type NonTruthy = null | undefined | "";
+/** Methods available on an Option */
+export interface OptionMethods<T> {
+    /** Returns the same option */
+    to(target: "option"): Option<T>;
+    /** Converts `Some<string>` to `Atom<string>`; throws for `None` or non-string */
+    to(target: "atom"): Atom<T & string>;
+    /** Converts to `Result<T, string>`; `None` becomes `Err("Value is None")` */
+    to(target: "result"): Result<T | (T extends string ? never : Atom<string>), string>;
+    /**
+     * Unwraps the option, throwing if `None`.
+     * @throws Error with provided message or default.
+     * @example
+     * option(42).expect(); // 42
+     * option("").expect("must be present"); // throws
+     */
+    expect(msg?: string): T;
+    /**
+     * Returns an unwrap chain that MUST be completed with `.else(...)`.
+     * If `.else(...)` is not chained, an error is thrown ("Expected else").
+     * - If `Some`, `.else(...)` is required but ignored for outcome; returns the inner value.
+     * - If `None`, `.else(...)` provides fallback; if a function, it is called with `undefined`.
+     * - Fallback result must be truthy; otherwise, throws ("Fallback must be truthy").
+     */
+    unwrap(): {
+        /**
+         * Fallback value or transformer to recover from `None`.
+         * - Function form receives `undefined` and must return a truthy value.
+         * - Direct value must be truthy.
+         * Returns the inner value for `Some`, or the validated fallback for `None`.
+         */
+        else(fallback: T | ((value: T | undefined) => T)): T;
+    };
+}
+/**
+ * Checks if a value is falsy for Option purposes.
+ * Falsy: null, undefined, empty string, NaN, Infinity, -Infinity
+ */
+export declare const isFalsy: (value: any) => boolean;
+/**
+ * Creates a new truthy option.
+ * @param value - the value of the option
+ * @throws Error if value is falsy
+ * @example
+ * const a = Some("hello");
+ * typeof a; // Some<"hello">
+ */
+declare function Some<T>(value: T): Some<T>;
+/** Singleton None value */
+declare const None: None;
+/**
+ * Sets the _to converter function (called from to.ts to break circular dep).
+ * @internal
+ */
+export declare function setToConverter(fn: (value: any, target: string) => any): void;
+/**
+ * Creates a new option type from a value.
+ * - Truthy values become `Some<T>`; `null|undefined|""` become `None`.
+ * - Provides chainable `.to()`, `.expect()`, and `.unwrap()` helpers.
+ * @example
+ * option("hi").expect(); // "hi"
+ * option("").expect("cannot be empty"); // throws Error("cannot be empty")
+ * option("state").to("atom"); // Atom<"state">
+ * option(null).to("result"); // Err("Value is None")
+ */
+export declare function option<T>(value: T | NonTruthy): Option<T> & OptionMethods<T>;
+export { Some, None };

package/dist/src/panic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Throws an error immediately.
+ * Use for unrecoverable failures or guard clauses.
+ * @param message - Error message
+ * @example
+ * panic("Critical!");
+ *
+ * // Guard clause pattern
+ * if (!config.apiKey) panic("API key required");
+ */
+export declare function panic(message: string): never;

package/dist/src/pipe.d.ts

@@ -0,0 +1,47 @@
+import type { Result } from "./result";
+/** Function that transforms one Result into another */
+export type PipeFn<T = any, E = any> = (input: Result<T, E>) => Result<any, any> | Promise<Result<any, any>>;
+/** Context passed to onEach callback */
+export type PipeEachContext = {
+    prevResult: Result<any, any>;
+    currentFn: string;
+    nextFn: string | undefined;
+};
+/** Options for pipeline execution */
+export type PipeRunOptions = {
+    /** Called after each function executes */
+    onEach?: (ctx: PipeEachContext) => void;
+    /** Called when pipeline completes successfully */
+    onSuccess?: (value: any) => void;
+    /** Called when pipeline encounters an error (only when allowErrors is false) */
+    onError?: (error: Error) => void;
+    /** If true, continues pipeline even when a function returns Err */
+    allowErrors?: boolean;
+};
+/** Pipeline object returned by pipe() */
+export type Pipeline<T, E> = {
+    run: (options?: PipeRunOptions) => Promise<Result<T, E>>;
+};
+/**
+ * Creates a pipeline for sequential function composition.
+ * Each function receives the previous Result and returns a new Result.
+ *
+ * @param initial - Starting value (plain value, Option, Result, or Atom)
+ * @param fns - Pipeline functions that transform Results
+ * @returns Pipeline object with `.run()` method
+ *
+ * @example
+ * const add = (x: number) => (res: Result<number, string>) =>
+ *   res.isOk ? Ok(res.value + x) : res;
+ *
+ * const result = await pipe(5, add(3), add(2)).run();
+ * // result.value === 10
+ *
+ * @example
+ * const result = await pipe(option(5), add(3)).run({
+ *   onEach: ({ currentFn, prevResult }) => console.log(currentFn, prevResult),
+ *   onSuccess: (value) => console.log("Done:", value),
+ *   allowErrors: false,
+ * });
+ */
+export declare function pipe<T, E = string>(initial: T, ...fns: PipeFn[]): Pipeline<any, E>;

package/dist/src/println.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Logs the provided arguments to the console.
+ * - Uses `globalThis.console.log` if available.
+ * - Supports variadic arguments.
+ * @param args - The arguments to log. Can be of any type.
+ */
+export declare const println: (...args: unknown[]) => void;

package/dist/src/result.d.ts

@@ -0,0 +1,56 @@
+declare const __result__: unique symbol;
+export type Ok<T> = {
+    type: "Ok";
+    value: T;
+    readonly isOk: true;
+    readonly isErr: false;
+    readonly [__result__]: true;
+};
+export type Err<E> = {
+    type: "Err";
+    error: E;
+    readonly isOk: false;
+    readonly isErr: true;
+    readonly [__result__]: true;
+};
+/** Discriminated union: mutually exclusive Ok or Err */
+export type Result<T, E> = (Ok<T> | Err<E>) & ResultMethods<T>;
+/** Methods available on a Result */
+export interface ResultMethods<T> {
+    /**
+     * Unwraps the value, throwing for Err.
+     * @example maybeFail().expect("must succeed")
+     */
+    expect(msg?: string): T;
+    /**
+     * Returns an unwrap chain that throws if no else is provided.
+     * Use `.else(valueOrFn)` to supply a fallback for Err.
+     * - If `Ok`, `.else(...)` returns the inner value and ignores fallback.
+     * - If `Err`, `.else(...)` returns the fallback; if a function, it receives the error.
+     */
+    unwrap(): {
+        /**
+         * Fallback value or function to recover from Err.
+         * If a function is provided, it is called with the Err's error.
+         * Returns the unwrapped value (Ok) or the provided fallback (Err).
+         */
+        else(fallback: T | ((error: any) => T)): T;
+    };
+}
+/**
+ * Creates a new, successful result.
+ * @param value Value of the result
+ * @example
+ * const a = Ok("hello");
+ * typeof a; // Ok<"hello">
+ */
+export declare function Ok<T>(value: T): Ok<T> & ResultMethods<T>;
+/**
+ * Creates a new, failed result with a string error message.
+ * @param error Error message (must be a string)
+ * @example
+ * const a = Err("something went wrong");
+ * typeof a; // Err<string>
+ */
+export declare function Err(error: string): Err<string> & ResultMethods<never>;
+export {};

package/dist/src/safe-try.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from "./result";
+/** Options for safeTry behavior */
+type SafeTryOptions = {
+    /** If true, re-throws the error instead of capturing it */
+    throw?: boolean;
+};
+/**
+ * Wraps a function in try-catch, returns `Result<T, string>`.
+ * - Always returns a Promise resolving to Ok or Err.
+ * - Internally evaluates return values from Atom, Result, or Option types.
+ * - Use `{ throw: true }` to re-throw errors instead of capturing.
+ *
+ * @param fn - Function to execute (sync or async)
+ * @param options - `{ throw?: boolean }`
+ * @returns Promise of `Result<T, string>`
+ *
+ * @example
+ * const result = await safeTry(() => "Hello");
+ * if (result.isOk) println(result.value);
+ *
+ * @example
+ * const result = await safeTry(() => {
+ *   throw new Error("Oops!");
+ * });
+ * if (result.isErr) println(result.error);
+ */
+export declare function safeTry<T>(fn: () => T | Promise<T>, options?: SafeTryOptions): Promise<Result<T, string>>;
+export {};

package/dist/src/to.d.ts

@@ -0,0 +1,15 @@
+import type { Atom } from "./atom";
+import type { Option } from "./option";
+import type { Result } from "./result";
+/**
+ * Converts between Slang types.
+ * - `option`: Wraps primitive or symbol description into `Option`
+ * - `atom`: Converts `Some<string>` to `Atom` or returns symbol Atom
+ * - `result`: Wraps values into `Ok`, `None` into `Err`
+ */
+export declare function _to<T>(value: Option<T>, target: "option"): Option<T>;
+export declare function _to<T extends string>(value: Option<T>, target: "atom"): Atom<T>;
+export declare function _to<T extends string>(value: Atom<T>, target: "option"): Option<string>;
+export declare function _to<T extends string>(value: Atom<T>, target: "atom"): Atom<T>;
+export declare function _to<T, E = string>(value: Option<T>, target: "result"): Result<T, E>;
+export declare function _to<E = string>(value: Atom<any>, target: "result"): Result<string, E>;

package/dist/src/zip.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Combines multiple collections element-wise into tuples.
+ * - All inputs must be the same type (all arrays, all Sets, or all objects).
+ * - By default, only arrays are allowed; set `includeValues: true` to extract values from Sets/Objects.
+ * - Stops at shortest collection by default; use `fillValue` to extend to longest.
+ * - Transforms columns into rows for parallel iteration.
+ * @param inputs Collections of the same type to combine
+ * @param options Configuration: `fillValue` extends to longest, `includeValues` extracts values from Sets/Objects (default: false)
+ * @returns Array of tuples, one per index position
+ * @example
+ * zip([[1, 2], ['a', 'b']]); // [[1, 'a'], [2, 'b']]
+ * zip([[1, 2], ['a']], { fillValue: 'x' }); // [[1, 'a'], [2, 'x']]
+ * const s1 = new Set([1, 2]); const s2 = new Set([3, 4]);
+ * zip([s1, s2], { includeValues: true }); // [[1, 3], [2, 4]]
+ */
+export declare function zip<T extends readonly any[]>(inputs: {
+    [K in keyof T]: Iterable<T[K]> | {
+        [key: string]: T[K];
+    };
+}, options?: {
+    fillValue?: T[number];
+    includeValues?: boolean;
+}): T[number][][];
+/**
+ * Combines multiple collections element-wise and transforms each tuple.
+ * - All inputs must be the same type (all arrays, all Sets, or all objects).
+ * - By default, only arrays are allowed; set `includeValues: true` to extract values from Sets/Objects.
+ * - Applies a function to each set of corresponding elements.
+ * - Useful for aggregating, computing, or transforming aligned data.
+ * @param inputs Collections of the same type to combine
+ * @param fn Transform function applied to each tuple
+ * @param options Configuration: `fillValue` extends to longest, `includeValues` extracts values from Sets/Objects (default: false)
+ * @returns Array of transformed results
+ * @example
+ * zipWith([[1, 2], [3, 4]], (t) => t[0] + t[1]); // [4, 6]
+ * zipWith([[1, 2], [10]], (t) => t.reduce((a, b) => a + b, 0), { fillValue: 0 }); // [11, 2]
+ */
+export declare function zipWith<T extends readonly any[], R>(inputs: {
+    [K in keyof T]: Iterable<T[K]> | {
+        [key: string]: T[K];
+    };
+}, fn: (tuple: T[number][]) => R, options?: {
+    fillValue?: T[number];
+    includeValues?: boolean;
+}): R[];
+/**
+ * Unzips an array of tuples back into separate arrays.
+ * - Reverses the zip operation: transforms rows to columns.
+ * - Useful for separating previously combined collections.
+ * @param zipped Array of tuples (rows) to transpose
+ * @returns Array of arrays (columns), one per tuple position
+ * @example
+ * const zipped = [[1, 'a'], [2, 'b'], [3, 'c']];
+ * unzip(zipped); // [[1, 2, 3], ['a', 'b', 'c']]
+ */
+export declare function unzip<T>(zipped: T[][]): T[][];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slang-ts",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Functional programming library for TypeScript",
   "type": "module",
   "main": "dist/index.js",