Boolean

Combines two booleans using logical AND: self && that.

When to use

Use to require both boolean operands to be true.

Details

Supports both data-first and data-last forms.

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

import { Boolean } from "effect"

Boolean.and(true, true) // => true
Boolean.and(true, false) // => false
Boolean.and(false, true) // => false
Boolean.and(false, false) // => false

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

When to use

Use to accept when both boolean operands have the same truth value.

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

import { Boolean } from "effect"

Boolean.eqv(true, true) // => true
Boolean.eqv(true, false) // => false
Boolean.eqv(false, true) // => false
Boolean.eqv(false, false) // => true

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

When to use

Use to model logical implication between a condition and a consequence.

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

import { Boolean } from "effect"

Boolean.implies(true, true) // => true
Boolean.implies(true, false) // => false
Boolean.implies(false, true) // => true
Boolean.implies(false, false) // => true

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

When to use

Use to negate a logical AND result.

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

import { Boolean } from "effect"

Boolean.nand(true, true) // => false
Boolean.nand(true, false) // => true
Boolean.nand(false, true) // => true
Boolean.nand(false, false) // => true

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

When to use

Use to accept only when both boolean operands are false.

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

import { Boolean } from "effect"

Boolean.nor(true, true) // => false
Boolean.nor(true, false) // => false
Boolean.nor(false, true) // => false
Boolean.nor(false, false) // => true

Negates the given boolean: !self

When to use

Use to invert a boolean value.

declare function not(self: boolean): boolean

import { Boolean } from "effect"

Boolean.not(true) // => false
Boolean.not(false) // => true

Combines two booleans using OR: self || that.

When to use

Use to accept when either boolean operand is true.

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

import { Boolean } from "effect"

Boolean.or(true, true) // => true
Boolean.or(true, false) // => true
Boolean.or(false, true) // => true
Boolean.or(false, false) // => false

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

When to use

Use to accept when exactly one boolean operand is true.

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

import { Boolean } from "effect"

Boolean.xor(true, true) // => false
Boolean.xor(true, false) // => true
Boolean.xor(false, true) // => true
Boolean.xor(false, false) // => false

Exposes the global boolean constructor for JavaScript truthiness coercion.

When to use

Use to access native JavaScript truthiness coercion from the Effect module namespace.

Gotchas

This follows native truthiness rules. For example, non-empty strings such as "false" coerce to true.

declare const Boolean: BooleanConstructor

import { Boolean } from "effect"

Boolean.Boolean(1) // => true
Boolean.Boolean("false") // => true
Boolean.Boolean(0) // => false

Checks whether a value is a boolean.

When to use

Use to validate unknown input and narrow it to boolean.

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

import { Boolean } from "effect"

Boolean.isBoolean(true) // => true
Boolean.isBoolean("true") // => false

Equivalence instance for booleans using strict equality (===).

When to use

Use when checking boolean equality through APIs that accept an equivalence relation.

declare const Equivalence: Equ.Equivalence<boolean>

import { Boolean } from "effect"

Boolean.Equivalence(true, true) // => true
Boolean.Equivalence(true, false) // => false

Provides an Order instance for boolean that allows comparing and sorting boolean values. In this ordering, false is considered less than true.

When to use

Use when you need to sort or compare boolean values through APIs that accept an ordering instance where false comes before true.

declare const Order: order.Order<boolean>

import { Boolean } from "effect"

Boolean.Order(false, true) // => -1
Boolean.Order(true, false) // => 1
Boolean.Order(true, true) // => 0

Reducer for combining booleans using AND.

When to use

Use to require every accumulated boolean to be true through APIs that consume a Reducer.

Details

The initialValue is true, so combineAll([]) returns true.

Gotchas

combineAll uses the default left-to-right Reducer.make fold and does not short-circuit on false.

See

• ReducerOr for reducing with OR semantics
• every for checking an iterable directly

declare const ReducerAnd: Reducer.Reducer<boolean>

Reducer for combining booleans using OR.

When to use

Use to reduce boolean values where the result should be true if any combined value is true.

Details

The initialValue is false.

See

• ReducerAnd for reducing with AND semantics
• some for checking an iterable directly

declare const ReducerOr: Reducer.Reducer<boolean>

Chooses between two lazy branches based on a boolean value.

When to use

Use to choose between two lazy branches based on a boolean value.

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;
}

import { Boolean } from "effect"

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

Checks whether every boolean in a collection is true.

When to use

Use to check that every boolean in an iterable is true.

See

• some for checking whether at least one value is true
• ReducerAnd for reducing booleans with AND through a Reducer

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

import { Boolean } from "effect"

Boolean.every([true, true, true]) // => true
Boolean.every([true, false, true]) // => false

Checks whether at least one boolean in a collection is true.

When to use

Use to check that at least one boolean in an iterable is true.

See

• every for checking whether all values are true
• ReducerOr for reducing booleans with OR through a Reducer

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

import { Boolean } from "effect"

Boolean.some([true, false, true]) // => true
Boolean.some([false, false, false]) // => false