Struct

This module provides utility functions for working with structs in TypeScript.

8 exports Added in v2.0.0 Source

Combinators

getEquivalence

Added in v2.0.0 Source

Given a struct of Equivalences returns a new Equivalence that compares values of a struct by applying each Equivalence to the corresponding property of the struct.

Alias of Equivalence.struct.

Signature

declare const getEquivalence: <R extends Record<string, Equivalence.Equivalence<any>>>(isEquivalents: R) => Equivalence.Equivalence<{ [K in keyof R]: [R[K]] extends [Equivalence.Equivalence<infer A>] ? A : never }>

Example

import * as assert from "node:assert"
import { Struct, String, Number } from "effect"

const PersonEquivalence = Struct.getEquivalence({
  name: String.Equivalence,
  age: Number.Equivalence
})

assert.deepStrictEqual(
  PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 25 }),
  true
)
assert.deepStrictEqual(
  PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 40 }),
  false
)

getOrder

Added in v2.0.0 Source

This function creates and returns a new Order for a struct of values based on the given Orders for each property in the struct.

Alias of order.struct.

Signature

declare const getOrder: <R extends {
  [x: string]: Order<any>;
}>(fields: R) => order.Order<{ [K in keyof R]: [R[K]] extends [order.Order<infer A>] ? A : never }>

Other

entries

Added in v3.17.0 Source

Retrieves the entries (key-value pairs) of an object, where keys are strings, in a type-safe manner. Symbol keys are excluded from the result.

Signature

declare function entries<R>(obj: R): Array<[keyof R & string, R[keyof R & string]]>

Example

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

const c = Symbol("c")
const value = { a: "foo", b: 1, [c]: true }

const entries: Array<["a" | "b", string | number]> = Struct.entries(value)

assert.deepStrictEqual(entries, [["a", "foo"], ["b", 1]])

evolve

Added in v2.0.0 Source

Transforms the values of a Struct provided a transformation function for each key. If no transformation function is provided for a key, it will return the original value for that key.

Signature

declare const evolve: {
  <O, T>(t: PartialTransform<O, T>): (obj: O) => { [K in string | number | symbol]: K extends keyof T ? T[K] extends (...a: any) => any ? ReturnType<any[any]> : O[K] : O[K] };
  <O, T>(obj: O, t: PartialTransform<O, T>): { [K in string | number | symbol]: K extends keyof T ? T[K] extends (...a: any) => any ? ReturnType<any[any]> : O[K] : O[K] };
}

Example

import * as assert from "node:assert"
import { pipe, Struct } from "effect"

assert.deepStrictEqual(
  pipe(
    { a: 'a', b: 1, c: 3 },
    Struct.evolve({
      a: (a) => a.length,
      b: (b) => b * 2
    })
  ),
  { a: 1, b: 2, c: 3 }
)

get

Added in v2.0.0 Source

Retrieves the value associated with the specified key from a struct.

Signature

declare function get<K extends PropertyKey>(key: K): <S extends { [P in PropertyKey]: any }>(s: S) => MatchRecord<S, S[K] | undefined, S[K]>

Example

import * as assert from "node:assert"
import { pipe, Struct } from "effect"

const value = pipe({ a: 1, b: 2 }, Struct.get("a"))

assert.deepStrictEqual(value, 1)

keys

Added in v3.6.0 Source

Retrieves the object keys that are strings in a typed manner

Signature

declare function keys<T extends {}>(o: T): Array<keyof T & string>

Example

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

const symbol: unique symbol = Symbol()

const value = {
  a: 1,
  b: 2,
  [symbol]: 3
}

const keys: Array<"a" | "b"> = Struct.keys(value)

assert.deepStrictEqual(keys, ["a", "b"])

omit

Added in v2.0.0 Source

Create a new object by omitting properties of an existing object.

Signature

declare const omit: {
  <Keys extends Array<PropertyKey>>(...keys: Keys): <S extends { [K in PropertyKey]: any }>(s: S) => Simplify<Omit<S, Keys[number]>>;
  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys): Simplify<Omit<S, Keys[number]>>;
}

Example

import * as assert from "node:assert"
import { pipe, Struct } from "effect"

assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.omit("c")), { a: "a", b: 1 })
assert.deepStrictEqual(Struct.omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })

pick

Added in v2.0.0 Source

Create a new object by picking properties of an existing object.

Signature

declare const pick: {
  <Keys extends Array<PropertyKey>>(...keys: Keys): <S extends { [K in PropertyKey]: any }>(s: S) => MatchRecord<S, { [K in PropertyKey]: S[K] }, Simplify<Pick<S, Keys[number]>>>;
  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys): MatchRecord<S, { [K in string | number | symbol]: S[K] }, Simplify<Pick<S, Keys[number]>>>;
}

Example

import * as assert from "node:assert"
import { pipe, Struct } from "effect"

assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.pick("a", "b")), { a: "a", b: 1 })
assert.deepStrictEqual(Struct.pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })