Skip to main content Link Search Menu Expand Document (external link)
effect

Struct.ts overview

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

Since v2.0.0

Exports Grouped by Category

combinators

getEquivalence

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.

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)

Signature

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

Source

Since v2.0.0

getOrder

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 { readonly [x: string]: order.Order<any> }>(
  fields: R
) => order.Order<{ [K in keyof R]: [R[K]] extends [order.Order<infer A>] ? A : never }>

Source

Since v2.0.0

utils

entries

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.

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]
])

Signature

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

Source

Since v3.17.0

evolve

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.

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

Signature

declare const evolve: {
  <O, T>(t: PartialTransform<O, T>): (obj: O) => Transformed<O, T>
  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T>
}

Source

Since v2.0.0

get

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

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)

Signature

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

Source

Since v2.0.0

keys

Retrieves the object keys that are strings in a typed manner

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"])

Signature

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

Source

Since v3.6.0

omit

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

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

Signature

declare const omit: {
  <Keys extends Array<PropertyKey>>(
    ...keys: Keys
  ): <S extends { [K in Keys[number]]?: 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]>>
}

Source

Since v2.0.0

pick

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

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

Signature

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

Source

Since v2.0.0