@nicolastoulemont/std 0.4.0 → 0.5.0

package/dist/pipeable-DYNrUps7.mjs

@@ -1,92 +0,0 @@
-import { t as flow } from "./flow-D4cE0EAg.mjs";
-
-//#region src/shared/dual.ts
-/**
-* Dual function utility for creating functions that support both
-* data-first and data-last (curried) calling styles.
-*
-* This pattern is inspired by Effect's dual function implementation.
-* It enables better ergonomics by allowing direct function calls
-* without requiring pipe() for simple operations.
-*
-* @example
-* ```ts
-* // Define a dual function
-* const map = dual<
-*   <T, U>(self: Option<T>, fn: (value: T) => U) => Option<U>,
-*   <T, U>(fn: (value: T) => U) => (self: Option<T>) => Option<U>
-* >(2, (self, fn) => self.some ? some(fn(self.value)) : none())
-*
-* // Use data-first (direct call)
-* map(some(5), x => x * 2) // Option<10>
-*
-* // Use data-last (curried for pipe)
-* pipe(some(5), map(x => x * 2)) // Option<10>
-* ```
-*/
-/**
-* Creates a function that can be called with all arguments (data-first)
-* or partially applied (data-last) for use in pipe chains.
-*
-* @param arity - The number of arguments in the data-first version (including self)
-* @param body - The implementation function that receives all arguments
-* @returns A function that supports both calling styles
-*
-* @remarks
-* The arity parameter is used to determine whether the function is being
-* called in data-first mode (all arguments provided) or data-last mode
-* (partial application for piping).
-*
-* TypeScript 5.4+ NoInfer is used where appropriate in consuming code
-* to prevent inference from fallback positions.
-*/
-const dual = function(arityOrIsDataFirst, body) {
-	if (typeof arityOrIsDataFirst === "function") return function() {
-		if (arityOrIsDataFirst(arguments)) return body.apply(this, arguments);
-		return ((self) => body(self, ...arguments));
-	};
-	switch (arityOrIsDataFirst) {
-		case 0: return body;
-		case 1: return function(a) {
-			if (arguments.length > 0) return body.call(this, a);
-			return body.bind(this);
-		};
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body.call(this, a, b);
-			return (self) => body(self, a);
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body.call(this, a, b, c);
-			return (self) => body(self, a, b);
-		};
-		case 4: return function(a, b, c, d) {
-			if (arguments.length >= 4) return body.call(this, a, b, c, d);
-			return (self) => body(self, a, b, c);
-		};
-		case 5: return function(a, b, c, d, e) {
-			if (arguments.length >= 5) return body.call(this, a, b, c, d, e);
-			return (self) => body(self, a, b, c, d);
-		};
-		default: return function() {
-			if (arguments.length >= arityOrIsDataFirst) return body.apply(this, arguments);
-			const args = arguments;
-			return (self) => body(self, ...args);
-		};
-	}
-};
-
-//#endregion
-//#region src/shared/pipeable.ts
-/**
-* Create a pipe method implementation.
-* Returns a function that pipes the value through provided functions.
-* This is designed to be used as an object method, so it uses `this` binding.
-*/
-function pipeMethod(...fns) {
-	if (fns.length === 0) return this;
-	return flow(...fns)(this);
-}
-
-//#endregion
-export { dual as n, pipeMethod as t };
-//# sourceMappingURL=pipeable-DYNrUps7.mjs.map

package/dist/predicate-Dt9Qsbav.mjs

@@ -1,293 +0,0 @@
-//#region src/predicate/predicate.ts
-/**
-* Negate a predicate.
-* Returns true when the original predicate returns false, and vice versa.
-*
-* @template T - The type being tested
-* @param predicate - The predicate to negate
-* @returns A new predicate that returns the opposite boolean
-*
-* @example
-* ```ts
-* const isEven = (n: number) => n % 2 === 0
-* const isOdd = Predicate.not(isEven)
-*
-* isOdd(3) // true
-* isOdd(4) // false
-*
-* // Works in filter
-* [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]
-* ```
-*/
-const not = (predicate) => {
-	return (value) => !predicate(value);
-};
-/**
-* Combine predicates with logical AND.
-* Returns true only when ALL predicates return true.
-* Short-circuits on first false (lazy evaluation).
-*
-* @template T - The type being tested
-* @param predicates - The predicates to combine
-* @returns A new predicate that returns true if all predicates pass
-*
-* @example
-* ```ts
-* const isPositive = (n: number) => n > 0
-* const isEven = (n: number) => n % 2 === 0
-* const isLessThan100 = (n: number) => n < 100
-*
-* const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)
-*
-* isValidNumber(42) // true
-* isValidNumber(-2) // false (not positive)
-* isValidNumber(101) // false (not less than 100)
-* ```
-*/
-const and = (...predicates) => {
-	return (value) => {
-		for (const predicate of predicates) if (!predicate(value)) return false;
-		return true;
-	};
-};
-/**
-* Combine predicates with logical OR.
-* Returns true when ANY predicate returns true.
-* Short-circuits on first true (lazy evaluation).
-*
-* @template T - The type being tested
-* @param predicates - The predicates to combine
-* @returns A new predicate that returns true if any predicate passes
-*
-* @example
-* ```ts
-* const isZero = (n: number) => n === 0
-* const isNegative = (n: number) => n < 0
-*
-* const isNotPositive = Predicate.or(isZero, isNegative)
-*
-* isNotPositive(0) // true
-* isNotPositive(-5) // true
-* isNotPositive(5) // false
-* ```
-*/
-const or = (...predicates) => {
-	return (value) => {
-		for (const predicate of predicates) if (predicate(value)) return true;
-		return false;
-	};
-};
-/**
-* Create a predicate that tests if ALL elements in an array match.
-* Returns true for empty arrays (vacuous truth).
-*
-* @template T - The element type
-* @param predicate - The predicate to test each element
-* @returns A predicate that takes an array and returns true if all match
-*
-* @example
-* ```ts
-* const isPositive = (n: number) => n > 0
-* const allPositive = Predicate.all(isPositive)
-*
-* allPositive([1, 2, 3]) // true
-* allPositive([1, -2, 3]) // false
-* allPositive([]) // true (vacuous truth)
-*
-* // Useful for validation
-* const areAllAdults = Predicate.all((u: User) => u.age >= 18)
-* ```
-*/
-const all = (predicate) => {
-	return (arr) => arr.every(predicate);
-};
-/**
-* Create a predicate that tests if ANY element in an array matches.
-* Returns false for empty arrays.
-*
-* @template T - The element type
-* @param predicate - The predicate to test each element
-* @returns A predicate that takes an array and returns true if any match
-*
-* @example
-* ```ts
-* const isNegative = (n: number) => n < 0
-* const hasNegative = Predicate.some(isNegative)
-*
-* hasNegative([1, -2, 3]) // true
-* hasNegative([1, 2, 3]) // false
-* hasNegative([]) // false
-* ```
-*/
-const some = (predicate) => {
-	return (arr) => arr.some(predicate);
-};
-/**
-* Create a predicate that tests if NO elements in an array match.
-* Returns true for empty arrays (vacuous truth).
-* Equivalent to `not(some(predicate))`.
-*
-* @template T - The element type
-* @param predicate - The predicate that should NOT match any element
-* @returns A predicate that takes an array and returns true if none match
-*
-* @example
-* ```ts
-* const isNegative = (n: number) => n < 0
-* const noNegatives = Predicate.none(isNegative)
-*
-* noNegatives([1, 2, 3]) // true
-* noNegatives([1, -2, 3]) // false
-* noNegatives([]) // true (vacuous truth)
-* ```
-*/
-const none = (predicate) => {
-	return (arr) => !arr.some(predicate);
-};
-/**
-* Combine refinements with logical AND, preserving type narrowing.
-* Use this instead of `and` when you need to preserve type guard behavior.
-*
-* @template T - The base type
-* @template U - The narrowed type (must extend T)
-* @param refinements - The refinements to combine
-* @returns A refinement that narrows to U if all refinements pass
-*
-* @example
-* ```ts
-* type User = { name: string; age: number; verified?: boolean }
-* type Adult = User & { age: number } // age >= 18
-* type VerifiedAdult = Adult & { verified: true }
-*
-* const isAdult = (u: User): u is Adult => u.age >= 18
-* const isVerified = (u: User): u is User & { verified: true } => u.verified === true
-*
-* // Combined refinement preserves type narrowing
-* const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)
-*
-* if (isVerifiedAdult(user)) {
-*   user.verified // TypeScript knows this is true
-* }
-* ```
-*/
-const andRefinement = (...refinements) => {
-	return (value) => {
-		for (const refinement of refinements) if (!refinement(value)) return false;
-		return true;
-	};
-};
-/**
-* Combine refinements with logical OR, preserving type narrowing.
-* Use this instead of `or` when you need to preserve type guard behavior.
-*
-* @template T - The base type
-* @template U - The narrowed type (must extend T)
-* @param refinements - The refinements to combine
-* @returns A refinement that narrows to U if any refinement passes
-*
-* @example
-* ```ts
-* const isString = (v: unknown): v is string => typeof v === "string"
-* const isNumber = (v: unknown): v is number => typeof v === "number"
-*
-* const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)
-*
-* if (isStringOrNumber(value)) {
-*   // value is string | number
-* }
-* ```
-*/
-const orRefinement = (...refinements) => {
-	return (value) => {
-		for (const refinement of refinements) if (refinement(value)) return true;
-		return false;
-	};
-};
-/**
-* Create a predicate from a constant boolean value.
-* Useful for testing or as a placeholder.
-*
-* @template T - The type (can be anything)
-* @param value - The constant boolean to return
-* @returns A predicate that always returns the given value
-*
-* @example
-* ```ts
-* const alwaysTrue = Predicate.constant(true)
-* const alwaysFalse = Predicate.constant(false)
-*
-* alwaysTrue("anything") // true
-* alwaysFalse(42) // false
-* ```
-*/
-const constant = (value) => {
-	return () => value;
-};
-/**
-* Create a predicate that checks strict equality.
-*
-* @template T - The type being compared
-* @param expected - The value to compare against
-* @returns A predicate that returns true if value === expected
-*
-* @example
-* ```ts
-* const isZero = Predicate.equals(0)
-* const isHello = Predicate.equals("hello")
-*
-* isZero(0) // true
-* isZero(1) // false
-*
-* // Works with references too
-* const obj = { a: 1 }
-* const isObj = Predicate.equals(obj)
-* isObj(obj) // true
-* isObj({ a: 1 }) // false (different reference)
-* ```
-*/
-const equals = (expected) => {
-	return (value) => value === expected;
-};
-/**
-* Predicate namespace containing composable boolean functions.
-*
-* Predicates are functions that test values and return booleans.
-* This namespace provides combinators to build complex predicates
-* from simple ones, with support for type guards (refinements).
-*
-* @example
-* ```ts
-* import { Predicate, pipe } from "@repo/std"
-*
-* // Basic predicates
-* const isPositive = (n: number) => n > 0
-* const isEven = (n: number) => n % 2 === 0
-*
-* // Combine with and/or
-* const isPositiveEven = Predicate.and(isPositive, isEven)
-* const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))
-*
-* // Array predicates
-* const allPositive = Predicate.all(isPositive)
-* const hasNegative = Predicate.some(Predicate.not(isPositive))
-*
-* // Use with filter
-* [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]
-* ```
-*/
-const Predicate = {
-	not,
-	and,
-	or,
-	all,
-	some,
-	none,
-	andRefinement,
-	orRefinement,
-	constant,
-	equals
-};
-
-//#endregion
-export { constant as a, not as c, some as d, andRefinement as i, or as l, all as n, equals as o, and as r, none as s, Predicate as t, orRefinement as u };
-//# sourceMappingURL=predicate-Dt9Qsbav.mjs.map

package/dist/result-BmqdTN5o.mjs

@@ -1 +0,0 @@
-export {  };