Bool

const Bool: object

Defined in: Data/Bool.ts:85

Type Declaration

all

all: (booleans) => boolean

N-ary AND aggregation across an array of booleans. Returns true if every boolean is true, or for an empty array (vacuous truth). Short-circuits on the first false.

Parameters

booleans

readonly boolean[]

Returns

boolean

Example

Bool.all([true, true, true]);  // true
Bool.all([true, false, true]); // false
Bool.all([]);                  // true

and

and: (that) => (self) => boolean

Logical AND combinator. Returns true only if both self and that are true.

Data-last: pipe(self, Bool.and(that)).

Parameters

that

boolean

Returns

(self) => boolean

Example

pipe(true, Bool.and(true));  // true
pipe(true, Bool.and(false)); // false

andLazy

andLazy: (that) => (self) => boolean

Lazy logical AND combinator. If self is false, the that computation is never evaluated.

Data-last: pipe(self, Bool.andLazy(that)).

Parameters

that

() => boolean

Returns

(self) => boolean

Example

pipe(
  isCached,
  Bool.andLazy(() => checkPermissions())
);

any

any: (booleans) => boolean

N-ary OR aggregation across an array of booleans. Returns true if at least one boolean is true. Returns false for an empty array. Short-circuits on the first true.

Parameters

booleans

readonly boolean[]

Returns

boolean

Example

Bool.any([false, true, false]); // true
Bool.any([false, false]);       // false
Bool.any([]);                   // false

fold

fold: <A, B>(onFalse, onTrue) => (b) => A | B

Catamorphism for boolean: evaluates onFalse() when false and onTrue() when true.

Positional ordering: onFalse first, onTrue second. Aligned with Result.fold(onErr, onOk) and Maybe.fold(onNone, onSome).

Type Parameters

A

A

B

B

Parameters

onFalse

() => A

onTrue

() => B

Returns

(b) => A | B

Example

pipe(
  isDarkMode,
  Bool.fold(
    () => "light-theme",
    () => "dark-theme"
  )
);

from

from: object

from.number

number: (n) => Maybe<boolean> = fromNumber

Converts a number into a Maybe<boolean>. Returns Some(true) for 1, Some(false) for 0, and None for any other number.

Parameters

n

number

Returns

Maybe<boolean>

Example

Bool.from.number(1);  // Some(true)
Bool.from.number(0);  // Some(false)
Bool.from.number(42); // None

from.string

string: (s) => Maybe<boolean> = fromString

Parses a string into a Maybe<boolean>. Returns Some(true) for "true", Some(false) for "false" (case-insensitive & trimmed), and None for any other string.

Parameters

s

string

Returns

Maybe<boolean>

Example

Bool.from.string("true");  // Some(true)
Bool.from.string("FALSE"); // Some(false)
Bool.from.string("yes");   // None

from.truthy

truthy: (value) => boolean = fromTruthy

Coerces any unknown value into a boolean via standard JS Boolean(value).

Parameters

value

unknown

Returns

boolean

Example

Bool.from.truthy("hello"); // true
Bool.from.truthy(0);       // false

is

is: object

is.boolean

boolean: (u) => u is boolean = isBoolean

Type guard — checks if a value is a primitive boolean.

Parameters

u

unknown

Returns

u is boolean

Example

Bool.is.boolean(true);      // true
Bool.is.boolean(false);     // true
Bool.is.boolean("true");    // false
Bool.is.boolean(null);      // false

is.false

false: (u) => u is false = isFalse

Narrowing guard — checks if a value is strictly false.

Parameters

u

unknown

Returns

u is false

Example

Bool.is.false(false); // true
Bool.is.false(true);  // false

is.falsy

falsy: (u) => u is false | “” | 0 | 0n | null | undefined = isFalsy

Type guard — checks if a value is falsy (false, 0, 0n, "", null, undefined, or NaN).

Parameters

u

unknown

Returns

u is false | “” | 0 | 0n | null | undefined

Example

Bool.is.falsy("");        // true
Bool.is.falsy(null);      // true
Bool.is.falsy("content"); // false

is.true

true: (u) => u is true = isTrue

Narrowing guard — checks if a value is strictly true.

Parameters

u

unknown

Returns

u is true

Example

Bool.is.true(true);  // true
Bool.is.true(false); // false

is.truthy

truthy: <T>(u) => u is Exclude<T, false | “” | 0 | 0n | null | undefined> = isTruthy

Type guard — checks if a value is truthy (not false, 0, 0n, "", null, undefined, or NaN).

Type Parameters

T

T

Parameters

u

T

Returns

u is Exclude<T, false | “” | 0 | 0n | null | undefined>

Example

Bool.is.truthy("hello"); // true
Bool.is.truthy(42);      // true
Bool.is.truthy(0);       // false
Bool.is.truthy(null);    // false

match

match: <A, B>(cases) => (b) => A | B

Pattern matching on boolean using named cases { true, false }.

Type Parameters

A

A

B

B

Parameters

cases

BoolMatchCases<A, B>

Returns

(b) => A | B

Example

pipe(
  isEnabled,
  Bool.match({
    true: () => "Feature Active",
    false: () => "Feature Disabled",
  })
);

not

not: (b) => boolean

Unary boolean negation: inverts the given boolean value.

Parameters

b

boolean

Returns

boolean

Example

Bool.not(true);  // false
Bool.not(false); // true

or

or: (that) => (self) => boolean

Logical OR combinator. Returns true if either self or that is true.

Data-last: pipe(self, Bool.or(that)).

Parameters

that

boolean

Returns

(self) => boolean

Example

pipe(false, Bool.or(true));  // true
pipe(false, Bool.or(false)); // false

orLazy

orLazy: (that) => (self) => boolean

Lazy logical OR combinator. If self is true, the that computation is never evaluated.

Data-last: pipe(self, Bool.orLazy(that)).

Parameters

that

() => boolean

Returns

(self) => boolean

Example

pipe(
  isAdmin,
  Bool.orLazy(() => hasAccess(userId))
);

to

to: object

to.Maybe

Maybe: <A>(onTrue) => (b) => Maybe<A> = toMaybe

Lifts a boolean condition into a Maybe. Returns Some(onTrue()) when true, and None when false.

Type Parameters

A

A

Parameters

onTrue

() => A

Returns

(b) => Maybe<A>

Example

pipe(
  user.isVerified,
  Bool.to.Maybe(() => user.profile)
); // Some(profile) or None

to.number

number: (b) => 0 | 1 = toNumber

Converts a boolean to numeric 1 or 0.

Parameters

b

boolean

Returns

0 | 1

Example

Bool.to.number(true);  // 1
Bool.to.number(false); // 0

to.Result

Result: <E, A>(onErr, onOk) => (b) => Result<E, A> = toResult

Lifts a boolean condition into a Result. Returns Ok(onOk()) when true, and Err(onErr()) when false.

Type Parameters

E

E

A

A

Parameters

onErr

() => E

onOk

() => A

Returns

(b) => Result<E, A>

Example

pipe(
  hasPermission,
  Bool.to.Result(
    () => "Permission denied",
    () => sessionData
  )
); // Ok(sessionData) or Err("Permission denied")

to.string

string: (b) => "false" | "true" = toString

Converts a boolean to literal string "true" or "false".

Parameters

b

boolean

Returns

"false" | "true"

Example

Bool.to.string(true);  // "true"
Bool.to.string(false); // "false"

xor

xor: (that) => (self) => boolean

Logical XOR (exclusive OR) combinator. Returns true if exactly one of self and that is true.

Data-last: pipe(self, Bool.xor(that)).

Parameters

that

boolean

Returns

(self) => boolean

Example

pipe(true, Bool.xor(false)); // true
pipe(true, Bool.xor(true));  // false