Boolean

This module provides utility functions and type class instances for working with the boolean type in TypeScript. It includes functions for basic boolean operations, as well as type class instances for Equivalence and Order.

14 exports Since v2.0.0 Source

Combinators

and

Since v2.0.0

Combines two boolean using AND: self && that.

Signature

declare const and: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { and } from "effect/Boolean"

assert.deepStrictEqual(and(true, true), true)
assert.deepStrictEqual(and(true, false), false)
assert.deepStrictEqual(and(false, true), false)
assert.deepStrictEqual(and(false, false), false)

eqv

Since v2.0.0

Combines two booleans using EQV (aka XNOR): !xor(self, that).

Signature

declare const eqv: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { eqv } from "effect/Boolean"

assert.deepStrictEqual(eqv(true, true), true)
assert.deepStrictEqual(eqv(true, false), false)
assert.deepStrictEqual(eqv(false, true), false)
assert.deepStrictEqual(eqv(false, false), true)

implies

Since v2.0.0

Combines two booleans using an implication: (!self || that).

Signature

declare const implies: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { implies } from "effect/Boolean"

assert.deepStrictEqual(implies(true, true), true)
assert.deepStrictEqual(implies(true, false), false)
assert.deepStrictEqual(implies(false, true), true)
assert.deepStrictEqual(implies(false, false), true)

nand

Since v2.0.0

Combines two boolean using NAND: !(self && that).

Signature

declare const nand: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { nand } from "effect/Boolean"

assert.deepStrictEqual(nand(true, true), false)
assert.deepStrictEqual(nand(true, false), true)
assert.deepStrictEqual(nand(false, true), true)
assert.deepStrictEqual(nand(false, false), true)

nor

Since v2.0.0

Combines two booleans using NOR: !(self || that).

Signature

declare const nor: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { nor } from "effect/Boolean"

assert.deepStrictEqual(nor(true, true), false)
assert.deepStrictEqual(nor(true, false), false)
assert.deepStrictEqual(nor(false, true), false)
assert.deepStrictEqual(nor(false, false), true)

not

Since v2.0.0

Negates the given boolean: !self

Signature

declare function not(self: boolean): boolean

Example

import * as assert from "node:assert"
import { not } from "effect/Boolean"

assert.deepStrictEqual(not(true), false)
assert.deepStrictEqual(not(false), true)

or

Since v2.0.0

Combines two boolean using OR: self || that.

Signature

declare const or: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { or } from "effect/Boolean"

assert.deepStrictEqual(or(true, true), true)
assert.deepStrictEqual(or(true, false), true)
assert.deepStrictEqual(or(false, true), true)
assert.deepStrictEqual(or(false, false), false)

xor

Since v2.0.0

Combines two booleans using XOR: (!self && that) || (self && !that).

Signature

declare const xor: {
  (that: boolean): (self: boolean) => boolean;
  (self: boolean, that: boolean): boolean;
}

Example

import * as assert from "node:assert"
import { xor } from "effect/Boolean"

assert.deepStrictEqual(xor(true, true), false)
assert.deepStrictEqual(xor(true, false), true)
assert.deepStrictEqual(xor(false, true), true)
assert.deepStrictEqual(xor(false, false), false)

Guards

isBoolean

Since v2.0.0

Tests if a value is a boolean.

Signature

declare const isBoolean: (input: unknown) => input is boolean

Example

import * as assert from "node:assert"
import { isBoolean } from "effect/Boolean"

assert.deepStrictEqual(isBoolean(true), true)
assert.deepStrictEqual(isBoolean("true"), false)

Instances

Equivalence

Since v2.0.0

Signature

declare const Equivalence: equivalence.Equivalence<boolean>

Order

Since v2.0.0

Signature

declare const Order: order.Order<boolean>

Other

every

Since v2.0.0

This utility function is used to check if all the elements in a collection of boolean values are true.

Signature

declare function every(collection: Iterable<boolean>): boolean

Example

import * as assert from "node:assert"
import { every } from "effect/Boolean"

assert.deepStrictEqual(every([true, true, true]), true)
assert.deepStrictEqual(every([true, false, true]), false)

some

Since v2.0.0

This utility function is used to check if at least one of the elements in a collection of boolean values is true.

Signature

declare function some(collection: Iterable<boolean>): boolean

Example

import * as assert from "node:assert"
import { some } from "effect/Boolean"

assert.deepStrictEqual(some([true, false, true]), true)
assert.deepStrictEqual(some([false, false, false]), false)

Pattern Matching

match

Since v2.0.0

This function returns the result of either of the given functions depending on the value of the boolean parameter. It is useful when you have to run one of two functions depending on the boolean value.

Signature

declare const match: {
  <A, B = A>(options: {
    readonly onFalse: LazyArg<A>;
    readonly onTrue: LazyArg<B>;
  }): (value: boolean) => A | B;
  <A, B>(value: boolean, options: {
    readonly onFalse: LazyArg<A>;
    readonly onTrue: LazyArg<B>;
  }): A | B;
}

Example

import * as assert from "node:assert"
import { Boolean } from "effect"

assert.deepStrictEqual(Boolean.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")