slang-ts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hussein Kizz
+
+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

@@ -0,0 +1,307 @@
+# Slang
+
+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.
+
+## Install
+
+```bash
+npm i slang-ts
+```
+
+## Implemented Utilities
+
+- [x] Result (Ok, Err)
+- [x] Maybe (Option)
+- [ ] andThen
+- [x] Atom
+- [x] Expect
+- [x] Unwrap (on Option)
+- [x] Else (on unwrap)
+- [ ] Panic!
+- [x] Zip, Unzip, zipWith
+- [ ] Try
+- [ ] Catch
+- [x] Match
+- [x] MatchAll
+- [ ] Pipe
+- [ ] Map
+- [x] To (converters, e.g. `userAtom.to('option')`)
+- [ ] Promises and async utilities
+- [ ] Curry
+
+## Others (Planned)
+
+- Pubsub store with state locks
+
+## How It Works
+
+You can import utilities individually or together:
+
+```ts
+// Individual imports
+import { option } from "slang-ts";
+import { Ok, Err } from "slang-ts";
+
+// Or import multiple at once
+import { option, Ok, Err, atom, match } from "slang-ts";
+```
+
+### println
+
+Well there's nothing special to slang's println utility, its just who wants console.log, its not fun at all, so we instead println, clean and classic, but latter it can be made environment aware so it doesn't print in prod, but for now its just sugar for console.log.
+
+```ts
+import { println } from "slang-ts";
+
+const name = "kizz";
+println("name:", name);
+println("multiple", "args", "work", { too: true });
+```
+
+### Option
+
+Wraps values that may or may not be present. Returns `Some<T>` for truthy values, `None` for null, undefined, empty strings, NaN, or Infinity. Note that `0` and `false` are truthy as these are usually intentional.
+
+```ts
+import { option } from "slang-ts";
+
+const a = option("hi");      // Some("hi")
+const b = option(null);      // None
+const c = option(0);         // Some(0) - zero is truthy!
+const d = option("");        // None
+const e = option(false);     // Some(false) - false is truthy!
+
+if (a.isSome) {
+  println("Value:", a.value);
+}
+
+if (b.isNone) {
+  println("No value");
+}
+```
+
+### Result
+
+Represents operations that can succeed or fail. Returns `Ok<T>` on success or `Err<E>` on failure with typed error payload.
+
+```ts
+import { Ok, Err, type Result } from "slang-ts";
+
+// Simple function returning Result
+function divide(a: number, b: number): Result<number, string> {
+  if (b === 0) return Err("Cannot divide by zero");
+  return Ok(a / b);
+}
+
+const result = divide(10, 2);
+
+if (result.isOk) {
+  println("Success:", result.value); // 5
+} else {
+  println("Error:", result.error);
+}
+
+// Async API example
+interface User {
+  id: string;
+  name: string;
+}
+
+async function fetchUser(id: string): Promise<Result<User, string>> {
+  try {
+    const response = await fetch(`/api/users/${id}`);
+    if (!response.ok) return Err("User not found");
+    const user = await response.json();
+    return Ok(user);
+  } catch (error) {
+    return Err("Network error");
+  }
+}
+
+const user = await fetchUser("123");
+if (user.isOk) {
+  println("User:", user.value.name);
+}
+```
+
+### Atom
+
+Creates unique, non-interned symbols with semantic descriptions. Each call produces a distinct identity. So ideally define them in one file and import from it everywhere else, great for env variables stuff.
+
+```ts
+import { atom } from "slang-ts";
+
+const userAtom = atom("kizz");
+const user2Atom = atom("kizz");
+
+println(userAtom === atom("kizz")); // false - non interned ✅
+println(userAtom.description);      // "kizz"
+
+if (userAtom === user2Atom) {
+  println("all the same");
+} else {
+  println("not the same");          // This prints!
+}
+```
+
+### Match
+
+Exhaustive pattern matching for `Option` and `Result` types. Forces you to handle all cases.
+
+```ts
+import { match } from "slang-ts";
+
+// Matching Results
+const result = divide(10, 0);
+match(result, {
+  Ok: (v) => println("Success:", v.value),
+  Err: (e) => println("Failed:", e.error),
+});
+
+// Matching Options
+const maybePort = option(process.env.PORT);
+match(maybePort, {
+  Some: (v) => println("Port:", v.value),
+  None: () => println("No port configured"),
+});
+```
+
+### MatchAll
+
+Pattern matching for primitives and atoms with required `_` fallback.
+
+```ts
+import { matchAll } from "slang-ts";
+
+// Match atoms
+const ready = atom("ready");
+matchAll(ready, {
+  ready: () => println("Ready!"),
+  failed: () => println("Failed!"),
+  _: () => println("Unknown"),
+});
+
+// Match booleans
+const isActive = true;
+matchAll(isActive, {
+  true: () => println("Active"),
+  false: () => println("Inactive"),
+  _: () => println("Unknown"),
+});
+```
+
+### Expect
+
+Unwraps values or throws with custom message. Use when failure is unrecoverable.
+
+```ts
+const personAge = option(25).expect("a person must have age!");
+println("person age", personAge); // 25
+
+// This would throw!
+// const personAge2 = option("").expect("a person must have age!");
+```
+
+### Unwrap/Else
+
+Chainable unwrapping with mandatory fallback. Must call `.else()` or throws.
+
+```ts
+const port = option(process.env.PORT).unwrap().else(3000);
+println("Using port:", port);
+
+// Function fallbacks
+const retries = option(null).unwrap().else(() => 5);
+println("Retries:", retries);
+
+// This throws! No .else() chained
+// const nothing = option(null).unwrap();
+```
+
+### To
+
+Converts between Slang types.
+
+```ts
+const statusAtom = atom("active").to("option");
+println("Option:", statusAtom);           // Some("active")
+
+const stateOption = option("ready").to("atom");
+println("Atom:", stateOption.description); // "ready"
+
+const errResult = option(null).to("result");
+println("Result:", errResult.type);        // "Err"
+```
+
+### Zip
+
+Combines multiple collections element-wise into tuples.
+
+```ts
+import { zip } from "slang-ts";
+
+// Zip arrays
+const arr1 = [1, 2, 3];
+const arr2 = [4, 5, 6];
+const arr3 = [7, 8, 9];
+println(zip([arr1, arr2, arr3]));
+// [[1,4,7],[2,5,8],[3,6,9]]
+
+// Zip with fillValue
+println(zip([arr1, [10, 20]], { fillValue: 0 }));
+// [[1,10],[2,20],[3,0]]
+
+// Zip Sets with includeValues=true
+const s1 = new Set([10, 20, 30]);
+const s2 = new Set([100, 200, 300]);
+println(zip([s1, s2], { includeValues: true }));
+// [[10,100],[20,200],[30,300]]
+
+// Zip objects with includeValues=true
+const o1 = { a: 1, b: 2, c: 3 };
+const o2 = { x: 100, y: 200, z: 300 };
+println(zip([o1, o2], { includeValues: true }));
+// [[1,100],[2,200],[3,300]]
+```
+
+### ZipWith
+
+Combines collections and applies transform function to each tuple.
+
+```ts
+import { zipWith } from "slang-ts";
+
+const arr1 = [1, 2, 3];
+const arr2 = [4, 5, 6];
+const arr3 = [7, 8, 9];
+
+println(zipWith([arr1, arr2, arr3], (t) => t.reduce((sum, x) => sum + x, 0)));
+// [12, 15, 18]
+```
+
+### Unzip
+
+Reverses zip operation, separating tuples back into arrays.
+
+```ts
+import { unzip } from "slang-ts";
+
+const arr1 = [1, 2, 3];
+const arr2 = [4, 5, 6];
+
+const zipped = zip([arr1, arr2]);
+println(unzip(zipped));
+// [[1, 2, 3], [4, 5, 6]]
+```
+
+And more are to be implemented in coming versions...
+
+## Code Samples
+
+See [example.ts](https://github.com/Hussseinkizz/slang/blob/main/example.ts) for usage of currently implemented methods.
+
+## Contributing
+
+Contributions are welcome, I know there a lot of cool things out there we can bring in.

package/dist/index.d.ts

@@ -0,0 +1,281 @@
+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`
+ */
+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>, patterns: {
+    Ok: (v: Ok<T>) => R;
+    Err: (e: Err<E>) => R;
+}): R;
+export declare function match<T, R>(value: Option<T>, patterns: {
+    Some: (v: Some<T>) => R;
+    None: (v: None) => 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 {};

package/dist/index.js

@@ -0,0 +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};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "slang-ts",
+  "version": "0.0.1",
+  "description": "Functional programming library for TypeScript",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "typecheck": "tsc --noEmit",
+    "build": "bun run test && bun run typecheck && bun run bun-build.ts && tsc -p tsconfig.build.json"
+  },
+  "homepage": "https://github.com/Hussseinkizz/slang#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hussseinkizz/slang.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Hussseinkizz/slang/issues"
+  },
+  "keywords": [
+    "functional",
+    "typescript",
+    "option",
+    "result",
+    "pattern-matching",
+    "monad",
+    "ts-pattern",
+    "defensive programming",
+    "fp-ts",
+    "ramda",
+    "rameda",
+    "neverthrow",
+    "lodash"
+  ],
+  "author": "Hussein Kizz",
+  "license": "MIT",
+  "sideEffects": false,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@vitest/ui": "^4.0.15",
+    "vitest": "^4.0.15"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}