Effect Data Types

Interop With Data

The Data module in the Effect ecosystem simplifies value comparison by automatically implementing the Equal and Hash traits. This eliminates the need for manual implementations, making equality checks straightforward.

Example (Comparing Structs with Data)

1
import { Data, Equal } from "effect"
2

3
const person1 = Data.struct({ name: "Alice", age: 30 })
4
const person2 = Data.struct({ name: "Alice", age: 30 })
5

6
console.log(Equal.equals(person1, person2))
7
// Output: true

By default, schemas like Schema.Struct do not implement the Equal and Hash traits. This means that two decoded objects with identical values will not be considered equal.

Example (Default Behavior Without Equal and Hash)

1
import { Schema } from "effect"
2
import { Equal } from "effect"
3

4
const schema = Schema.Struct({
5
  name: Schema.String,
6
  age: Schema.Number,
7
})
8

9
const decode = Schema.decode(schema)
10

11
const person1 = decode({ name: "Alice", age: 30 })
12
const person2 = decode({ name: "Alice", age: 30 })
13

14
console.log(Equal.equals(person1, person2))
15
// Output: false

The Schema.Data function can be used to enhance a schema by including the Equal and Hash traits. This allows the resulting objects to support value-based equality.

Example (Using Schema.Data to Add Equality)

1
import { Schema } from "effect"
2
import { Equal } from "effect"
3

4
const schema = Schema.Data(
5
  Schema.Struct({
6
    name: Schema.String,
7
    age: Schema.Number,
8
  }),
9
)
10

11
const decode = Schema.decode(schema)
12

13
const person1 = decode({ name: "Alice", age: 30 })
14
const person2 = decode({ name: "Alice", age: 30 })
15

16
console.log(Equal.equals(person1, person2))
17
// Output: true

Config

The Schema.Config function allows you to decode and manage application configuration settings using structured schemas. It ensures consistency in configuration data and provides detailed feedback for decoding errors.

Syntax

Config: <A, I extends string>(name: string, schema: Schema<A, I>) => Config<A>

This function takes two arguments:

name: Identifier for the configuration setting.
schema: Schema describing the expected data type and structure.

It returns a Config object that integrates with your application’s configuration system.

The Encoded type I must extend string, so the schema must be able to decode from a string, this includes schemas like Schema.String, Schema.Literal("..."), or Schema.NumberFromString, possibly with refinements applied.

Behind the scenes, Schema.Config follows these steps:

Fetch the value using the provided name (e.g. from an environment variable).
Decode the value using the given schema. If the value is invalid, decoding fails.
Format any errors using TreeFormatter.formatErrorSync, which helps produce readable and detailed error messages.

Example (Decoding a Configuration Value)

1
import { Effect, Schema } from "effect"
2

3
// Define a config that expects a string with at least 4 characters
4
const myConfig = Schema.Config("Foo", Schema.String.pipe(Schema.minLength(4)))
5

6
const program = Effect.gen(function* () {
7
  const foo = yield* myConfig
8
  console.log(`ok: ${foo}`)
9
})
10

11
Effect.runSync(program)

To test the configuration, execute the following commands:

Test (with Missing Configuration Data)

npx tsx config.ts
# Output:
# [(Missing data at Foo: "Expected Foo to exist in the process context")]

Test (with Invalid Data)

Foo=bar npx tsx config.ts
# Output:
# [(Invalid data at Foo: "a string at least 4 character(s) long
# └─ Predicate refinement failure
#    └─ Expected a string at least 4 character(s) long, actual "bar"")]

Test (with Valid Data)

Foo=foobar npx tsx config.ts
# Output:
# ok: foobar

Option

The Schema.Option function is useful for converting an Option into a JSON-serializable format.

Syntax

Schema.Option(schema: Schema<A, I, R>)

Decoding

Input	Output
`{ _tag: "None" }`	Converted to `Option.none()`
`{ _tag: "Some", value: I }`	Converted to `Option.some(a)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `{ _tag: "None" }`
`Option.some(A)`	Converted to `{ _tag: "Some", value: I }`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2
import { Option } from "effect"
3

4
const schema = Schema.Option(Schema.NumberFromString)
5

6
//     ┌─── OptionEncoded<string>
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode({ _tag: "None" }))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
console.log(decode({ _tag: "Some", value: "1" }))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
console.log(encode(Option.none()))
28
// Output: { _tag: 'None' }
29

30
console.log(encode(Option.some(1)))
31
// Output: { _tag: 'Some', value: '1' }

OptionFromSelf

The Schema.OptionFromSelf function is designed for scenarios where Option values are already in the Option format and need to be decoded or encoded while transforming the inner value according to the provided schema.

Syntax

Schema.OptionFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`Option.none()`	Remains as `Option.none()`
`Option.some(I)`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Remains as `Option.none()`
`Option.some(A)`	Converted to `Option.some(I)`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2
import { Option } from "effect"
3

4
const schema = Schema.OptionFromSelf(Schema.NumberFromString)
5

6
//     ┌─── Option<string>
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(Option.none()))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
console.log(decode(Option.some("1")))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
console.log(encode(Option.none()))
28
// Output: { _id: 'Option', _tag: 'None' }
29

30
console.log(encode(Option.some(1)))
31
// Output: { _id: 'Option', _tag: 'Some', value: '1' }

OptionFromUndefinedOr

The Schema.OptionFromUndefinedOr function handles cases where undefined is treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema.

Syntax

Schema.OptionFromUndefinedOr(schema: Schema<A, I, R>)

Decoding

Input	Output
`undefined`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `undefined`
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2
import { Option } from "effect"
3

4
const schema = Schema.OptionFromUndefinedOr(Schema.NumberFromString)
5

6
//     ┌─── string | undefined
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(undefined))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
console.log(decode("1"))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
console.log(encode(Option.none()))
28
// Output: undefined
29

30
console.log(encode(Option.some(1)))
31
// Output: "1"

OptionFromNullOr

The Schema.OptionFromUndefinedOr function handles cases where null is treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema.

Syntax

Schema.OptionFromNullOr(schema: Schema<A, I, R>)

Decoding

Input	Output
`null`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `null`
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2
import { Option } from "effect"
3

4
const schema = Schema.OptionFromNullOr(Schema.NumberFromString)
5

6
//     ┌─── string | null
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(null))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
console.log(decode("1"))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
console.log(encode(Option.none()))
28
// Output: null
29
console.log(encode(Option.some(1)))
30
// Output: "1"

OptionFromNullishOr

The Schema.OptionFromNullishOr function handles cases where null or undefined are treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema. Additionally, it allows customization of how Option.none() is encoded (null or undefined).

Syntax

Schema.OptionFromNullishOr(
  schema: Schema<A, I, R>,
  onNoneEncoding: null | undefined
)

Decoding

Input	Output
`undefined`	Converted to `Option.none()`
`null`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `undefined` or `null` based on user choice (`onNoneEncoding`)
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2
import { Option } from "effect"
3

4
const schema = Schema.OptionFromNullishOr(
5
  Schema.NumberFromString,
6
  undefined, // Encode Option.none() as undefined
7
)
8

9
//     ┌─── string | null | undefined
10
//     ▼
11
type Encoded = typeof schema.Encoded
12

13
//     ┌─── Option<number>
14
//     ▼
15
type Type = typeof schema.Type
16

17
const decode = Schema.decodeUnknownSync(schema)
18
const encode = Schema.encodeSync(schema)
19

20
// Decoding examples
21

22
console.log(decode(null))
23
// Output: { _id: 'Option', _tag: 'None' }
24

25
console.log(decode(undefined))
26
// Output: { _id: 'Option', _tag: 'None' }
27

28
console.log(decode("1"))
29
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
30

31
// Encoding examples
32

33
console.log(encode(Option.none()))
34
// Output: undefined
35

36
console.log(encode(Option.some(1)))
37
// Output: "1"

OptionFromNonEmptyTrimmedString

The Schema.OptionFromNonEmptyTrimmedString schema is designed for handling strings where trimmed empty strings are treated as Option.none(), and all other strings are converted to Option.some().

Decoding

Input	Output
`s: string`	Converted to `Option.some(s)`, if `s.trim().length > 0`
	Converted to `Option.none()` otherwise

Encoding

Input	Output
`Option.none()`	Converted to `""`
`Option.some(s: string)`	Converted to `s`

Example

1
import { Schema, Option } from "effect"
2

3
//     ┌─── string
4
//     ▼
5
type Encoded = typeof Schema.OptionFromNonEmptyTrimmedString
6

7
//     ┌─── Option<string>
8
//     ▼
9
type Type = typeof Schema.OptionFromNonEmptyTrimmedString
10

11
const decode = Schema.decodeUnknownSync(Schema.OptionFromNonEmptyTrimmedString)
12
const encode = Schema.encodeSync(Schema.OptionFromNonEmptyTrimmedString)
13

14
// Decoding examples
15

16
console.log(decode(""))
17
// Output: { _id: 'Option', _tag: 'None' }
18

19
console.log(decode(" a "))
20
// Output: { _id: 'Option', _tag: 'Some', value: 'a' }
21

22
console.log(decode("a"))
23
// Output: { _id: 'Option', _tag: 'Some', value: 'a' }
24

25
// Encoding examples
26

27
console.log(encode(Option.none()))
28
// Output: ""
29

30
console.log(encode(Option.some("example")))
31
// Output: "example"

Either

The Schema.Either function is useful for converting an Either into a JSON-serializable format.

Syntax

Schema.Either(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`{ _tag: "Left", left: LI }`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`{ _tag: "Right", right: RI }`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `{ _tag: "Left", left: LI }`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `{ _tag: "Right", right: RI }`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { Schema, Either } from "effect"
2

3
const schema = Schema.Either({
4
  left: Schema.Trim,
5
  right: Schema.NumberFromString,
6
})
7

8
//     ┌─── EitherEncoded<string, string>
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── Either<number, string>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(decode({ _tag: "Left", left: " a " }))
22
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
23

24
console.log(decode({ _tag: "Right", right: "1" }))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
console.log(encode(Either.left("a")))
30
// Output: { _tag: 'Left', left: 'a' }
31

32
console.log(encode(Either.right(1)))
33
// Output: { _tag: 'Right', right: '1' }

EitherFromSelf

The Schema.EitherFromSelf function is designed for scenarios where Either values are already in the Either format and need to be decoded or encoded while transforming the inner valued according to the provided schemas.

Syntax

Schema.EitherFromSelf(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`Either.left(LI)`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`Either.right(RI)`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `Either.left(LI)`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `Either.right(RI)`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { Schema, Either } from "effect"
2

3
const schema = Schema.EitherFromSelf({
4
  left: Schema.Trim,
5
  right: Schema.NumberFromString,
6
})
7

8
//     ┌─── Either<string, string>
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── Either<number, string>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(decode(Either.left(" a ")))
22
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
23

24
console.log(decode(Either.right("1")))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
console.log(encode(Either.left("a")))
30
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
31

32
console.log(encode(Either.right(1)))
33
// Output: { _id: 'Either', _tag: 'Right', right: '1' }

EitherFromUnion

The Schema.EitherFromUnion function is designed to decode and encode Either values where the left and right sides are represented as distinct types. This schema enables conversions between raw union types and structured Either types.

Syntax

Schema.EitherFromUnion(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`LI`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`RI`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `LI`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `RI`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { Schema, Either } from "effect"
2

3
const schema = Schema.EitherFromUnion({
4
  left: Schema.Boolean,
5
  right: Schema.NumberFromString,
6
})
7

8
//     ┌─── string | boolean
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── Either<number, boolean>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(decode(true))
22
// Output: { _id: 'Either', _tag: 'Left', left: true }
23

24
console.log(decode("1"))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
console.log(encode(Either.left(true)))
30
// Output: true
31

32
console.log(encode(Either.right(1)))
33
// Output: "1"

Exit

The Schema.Exit function is useful for converting an Exit into a JSON-serializable format.

Syntax

Schema.Exit(options: {
  failure: Schema<FA, FI, FR>,
  success: Schema<SA, SI, SR>,
  defect: Schema<DA, DI, DR>
})

Decoding

Input	Output
`{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`	Converted to `Exit.failCause(Cause<FA>)`, where `CauseEncoded<FI, DI>` is decoded into `Cause<FA>` using the inner `failure` and `defect` schemas
`{ _tag: "Success", value: SI }`	Converted to `Exit.succeed(SA)`, where `SI` is decoded into `SA` using the inner `success` schema

Encoding

Input	Output
`Exit.failCause(Cause<FA>)`	Converted to `{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`, where `Cause<FA>` is encoded into `CauseEncoded<FI, DI>` using the inner `failure` and `defect` schemas
`Exit.succeed(SA)`	Converted to `{ _tag: "Success", value: SI }`, where `SA` is encoded into `SI` using the inner `success` schema

Example

1
import { Schema, Exit } from "effect"
2

3
const schema = Schema.Exit({
4
  failure: Schema.String,
5
  success: Schema.NumberFromString,
6
  defect: Schema.String,
7
})
8

9
//     ┌─── ExitEncoded<string, string, string>
10
//     ▼
11
type Encoded = typeof schema.Encoded
12

13
//     ┌─── Exit<number, string>
14
//     ▼
15
type Type = typeof schema.Type
16

17
const decode = Schema.decodeUnknownSync(schema)
18
const encode = Schema.encodeSync(schema)
19

20
// Decoding examples
21

22
console.log(decode({ _tag: "Failure", cause: { _tag: "Fail", error: "a" } }))
23
/*
24
Output:
25
{
26
  _id: 'Exit',
27
  _tag: 'Failure',
28
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
29
}
30
*/
31

32
console.log(decode({ _tag: "Success", value: "1" }))
33
/*
34
Output:
35
{ _id: 'Exit', _tag: 'Success', value: 1 }
36
*/
37

38
// Encoding examples
39

40
console.log(encode(Exit.fail("a")))
41
/*
42
Output:
43
{ _tag: 'Failure', cause: { _tag: 'Fail', error: 'a' } }
44
 */
45

46
console.log(encode(Exit.succeed(1)))
47
/*
48
Output:
49
{ _tag: 'Success', value: '1' }
50
*/

Handling Defects in Serialization

Effect provides a built-in Defect schema to handle JavaScript errors (Error instances) and other types of unrecoverable defects.

When decoding, it reconstructs Error instances if the input has a message and optionally a name and stack.
When encoding, it converts Error instances into plain objects that retain only essential properties.

This is useful when transmitting errors across network requests or logging systems where Error objects do not serialize by default.

Example (Encoding and Decoding Defects)

1
import { Schema, Exit } from "effect"
2

3
const schema = Schema.Exit({
4
  failure: Schema.String,
5
  success: Schema.NumberFromString,
6
  defect: Schema.Defect,
7
})
8

9
const decode = Schema.decodeSync(schema)
10
const encode = Schema.encodeSync(schema)
11

12
console.log(encode(Exit.die(new Error("Message"))))
13
/*
14
Output:
15
{
16
  _tag: 'Failure',
17
  cause: { _tag: 'Die', defect: { name: 'Error', message: 'Message' } }
18
}
19
*/
20

21
console.log(encode(Exit.fail("a")))
22

23
console.log(
24
  decode({
25
    _tag: "Failure",
26
    cause: { _tag: "Die", defect: { name: "Error", message: "Message" } },
27
  }),
28
)
29
/*
30
Output:
31
{
32
  _id: 'Exit',
33
  _tag: 'Failure',
34
  cause: {
35
    _id: 'Cause',
36
    _tag: 'Die',
37
    defect: [Error: Message] { [cause]: [Object] }
38
  }
39
}
40
*/

ExitFromSelf

The Schema.ExitFromSelf function is designed for scenarios where Exit values are already in the Exit format and need to be decoded or encoded while transforming the inner valued according to the provided schemas.

Syntax

Schema.ExitFromSelf(options: {
  failure: Schema<FA, FI, FR>,
  success: Schema<SA, SI, SR>,
  defect: Schema<DA, DI, DR>
})

Decoding

Input	Output
`Exit.failCause(Cause<FI>)`	Converted to `Exit.failCause(Cause<FA>)`, where `Cause<FI>` is decoded into `Cause<FA>` using the inner `failure` and `defect` schemas
`Exit.succeed(SI)`	Converted to `Exit.succeed(SA)`, where `SI` is decoded into `SA` using the inner `success` schema

Encoding

Input	Output
`Exit.failCause(Cause<FA>)`	Converted to `Exit.failCause(Cause<FI>)`, where `Cause<FA>` is decoded into `Cause<FI>` using the inner `failure` and `defect` schemas
`Exit.succeed(SA)`	Converted to `Exit.succeed(SI)`, where `SA` is encoded into `SI` using the inner `success` schema

Example

1
import { Schema, Exit } from "effect"
2

3
const schema = Schema.ExitFromSelf({
4
  failure: Schema.String,
5
  success: Schema.NumberFromString,
6
  defect: Schema.String,
7
})
8

9
//     ┌─── Exit<string, string>
10
//     ▼
11
type Encoded = typeof schema.Encoded
12

13
//     ┌─── Exit<number, string>
14
//     ▼
15
type Type = typeof schema.Type
16

17
const decode = Schema.decodeUnknownSync(schema)
18
const encode = Schema.encodeSync(schema)
19

20
// Decoding examples
21

22
console.log(decode(Exit.fail("a")))
23
/*
24
Output:
25
{
26
  _id: 'Exit',
27
  _tag: 'Failure',
28
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
29
}
30
*/
31

32
console.log(decode(Exit.succeed("1")))
33
/*
34
Output:
35
{ _id: 'Exit', _tag: 'Success', value: 1 }
36
*/
37

38
// Encoding examples
39

40
console.log(encode(Exit.fail("a")))
41
/*
42
Output:
43
{
44
  _id: 'Exit',
45
  _tag: 'Failure',
46
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
47
}
48
*/
49

50
console.log(encode(Exit.succeed(1)))
51
/*
52
Output:
53
{ _id: 'Exit', _tag: 'Success', value: '1' }
54
*/

ReadonlySet

The Schema.ReadonlySet function is useful for converting a ReadonlySet into a JSON-serializable format.

Syntax

Schema.ReadonlySet(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converted to `ReadonlySet<A>`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`ReadonlySet<A>`	`ReadonlyArray<I>`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.ReadonlySet(Schema.NumberFromString)
4

5
//     ┌─── readonly string[]
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── ReadonlySet<number>
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14
const encode = Schema.encodeSync(schema)
15

16
// Decoding examples
17

18
console.log(decode(["1", "2", "3"]))
19
// Output: Set(3) { 1, 2, 3 }
20

21
// Encoding examples
22

23
console.log(encode(new Set([1, 2, 3])))
24
// Output: [ '1', '2', '3' ]

ReadonlySetFromSelf

The Schema.ReadonlySetFromSelf function is designed for scenarios where ReadonlySet values are already in the ReadonlySet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.ReadonlySetFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlySet<I>`	Converted to `ReadonlySet<A>`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`ReadonlySet<A>`	`ReadonlySet<I>`, where `A` is encoded into `I` using the inner schema

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.ReadonlySetFromSelf(Schema.NumberFromString)
4

5
//     ┌─── ReadonlySet<string>
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── ReadonlySet<number>
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14
const encode = Schema.encodeSync(schema)
15

16
// Decoding examples
17

18
console.log(decode(new Set(["1", "2", "3"])))
19
// Output: Set(3) { 1, 2, 3 }
20

21
// Encoding examples
22

23
console.log(encode(new Set([1, 2, 3])))
24
// Output: Set(3) { '1', '2', '3' }

ReadonlyMap

The Schema.ReadonlyMap function is useful for converting a ReadonlyMap into a JSON-serializable format.

ReadonlyMap

Syntax

Schema.ReadonlyMap(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`ReadonlyArray<readonly [KI, VI]>`	Converted to `ReadonlyMap<KA, VA>`, where `KI` is decoded into `KA` using the inner `key` schema and `VI` is decoded into `VA` using the inner `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converted to `ReadonlyArray<readonly [KI, VI]>`, where `KA` is decoded into `KI` using the inner `key` schema and `VA` is decoded into `VI` using the inner `value` schema

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.ReadonlyMap({
4
  key: Schema.String,
5
  value: Schema.NumberFromString,
6
})
7

8
//     ┌─── readonly (readonly [string, string])[]
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── ReadonlyMap<string, number>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(
22
  decode([
23
    ["a", "2"],
24
    ["b", "2"],
25
    ["c", "3"],
26
  ]),
27
)
28
// Output: Map(3) { 'a' => 2, 'b' => 2, 'c' => 3 }
29

30
// Encoding examples
31

32
console.log(
33
  encode(
34
    new Map([
35
      ["a", 1],
36
      ["b", 2],
37
      ["c", 3],
38
    ]),
39
  ),
40
)
41
// Output: [ [ 'a', '1' ], [ 'b', '2' ], [ 'c', '3' ] ]

ReadonlyMapFromSelf

The Schema.ReadonlyMapFromSelf function is designed for scenarios where ReadonlyMap values are already in the ReadonlyMap format and need to be decoded or encoded while transforming the inner values according to the provided schemas.

Syntax

Schema.ReadonlyMapFromSelf(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`ReadonlyMap<KI, VI>`	Converted to `ReadonlyMap<KA, VA>`, where `KI` is decoded into `KA` using the inner `key` schema and `VI` is decoded into `VA` using the inner `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converted to `ReadonlyMap<KI, VI>`, where `KA` is decoded into `KI` using the inner `key` schema and `VA` is decoded into `VI` using the inner `value` schema

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.ReadonlyMapFromSelf({
4
  key: Schema.String,
5
  value: Schema.NumberFromString,
6
})
7

8
//     ┌─── ReadonlyMap<string, string>
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── ReadonlyMap<string, number>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(
22
  decode(
23
    new Map([
24
      ["a", "2"],
25
      ["b", "2"],
26
      ["c", "3"],
27
    ]),
28
  ),
29
)
30
// Output: Map(3) { 'a' => 2, 'b' => 2, 'c' => 3 }
31

32
// Encoding examples
33

34
console.log(
35
  encode(
36
    new Map([
37
      ["a", 1],
38
      ["b", 2],
39
      ["c", 3],
40
    ]),
41
  ),
42
)
43
// Output: Map(3) { 'a' => '1', 'b' => '2', 'c' => '3' }

ReadonlyMapFromRecord

The Schema.ReadonlyMapFromRecord function is a utility to transform a ReadonlyMap into an object format, where keys are strings and values are serializable, and vice versa.

Syntax

Schema.ReadonlyMapFromRecord({
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>,
})

Decoding

Input	Output
`{ readonly [x: string]: VI }`	Converts to `ReadonlyMap<KA, VA>`, where `x` is decoded into `KA` using the `key` schema and `VI` into `VA` using the `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converts to `{ readonly [x: string]: VI }`, where `KA` is encoded into `x` using the `key` schema and `VA` into `VI` using the `value` schema

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.ReadonlyMapFromRecord({
4
  key: Schema.NumberFromString,
5
  value: Schema.NumberFromString,
6
})
7

8
//     ┌─── { readonly [x: string]: string; }
9
//     ▼
10
type Encoded = typeof schema.Encoded
11

12
//     ┌─── ReadonlyMap<number, number>
13
//     ▼
14
type Type = typeof schema.Type
15

16
const decode = Schema.decodeUnknownSync(schema)
17
const encode = Schema.encodeSync(schema)
18

19
// Decoding examples
20

21
console.log(
22
  decode({
23
    "1": "4",
24
    "2": "5",
25
    "3": "6",
26
  }),
27
)
28
// Output: Map(3) { 1 => 4, 2 => 5, 3 => 6 }
29

30
// Encoding examples
31

32
console.log(
33
  encode(
34
    new Map([
35
      [1, 4],
36
      [2, 5],
37
      [3, 6],
38
    ]),
39
  ),
40
)
41
// Output: { '1': '4', '2': '5', '3': '6' }

HashSet

The Schema.HashSet function provides a way to map between HashSet and an array representation, allowing for JSON serialization and deserialization.

Syntax

Schema.HashSet(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converts to `HashSet<A>`, where each element in the array is decoded into type `A` using the schema

Encoding

Input	Output
`HashSet<A>`	Converts to `ReadonlyArray<I>`, where each element in the `HashSet` is encoded into type `I` using the schema

Example

1
import { Schema } from "effect"
2
import { HashSet } from "effect"
3

4
const schema = Schema.HashSet(Schema.NumberFromString)
5

6
//     ┌─── readonly string[]
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── HashSet<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(["1", "2", "3"]))
20
// Output: { _id: 'HashSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
console.log(encode(HashSet.fromIterable([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

HashSetFromSelf

The Schema.HashSetFromSelf function is designed for scenarios where HashSet values are already in the HashSet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.HashSetFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`HashSet<I>`	Converts to `HashSet<A>`, decoding each element from type `I` to type `A` using the schema

Encoding

Input	Output
`HashSet<A>`	Converts to `HashSet<I>`, encoding each element from type `A` to type `I` using the schema

Example

1
import { Schema } from "effect"
2
import { HashSet } from "effect"
3

4
const schema = Schema.HashSetFromSelf(Schema.NumberFromString)
5

6
//     ┌─── HashSet<string>
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── HashSet<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(HashSet.fromIterable(["1", "2", "3"])))
20
// Output: { _id: 'HashSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
console.log(encode(HashSet.fromIterable([1, 2, 3])))
25
// Output: { _id: 'HashSet', values: [ '1', '3', '2' ] }

HashMap

The Schema.HashMap function is useful for converting a HashMap into a JSON-serializable format.

Syntax

Schema.HashMap(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Input	Output
`ReadonlyArray<readonly [KI, VI]>`	Converts to `HashMap<KA, VA>`, where `KI` is decoded into `KA` and `VI` is decoded into `VA` using the specified schemas

Encoding

Input	Output
`HashMap<KA, VA>`	Converts to `ReadonlyArray<readonly [KI, VI]>`, where `KA` is encoded into `KI` and `VA` is encoded into `VI` using the specified schemas

Example

1
import { Schema } from "effect"
2
import { HashMap } from "effect"
3

4
const schema = Schema.HashMap({
5
  key: Schema.String,
6
  value: Schema.NumberFromString,
7
})
8

9
//     ┌─── readonly (readonly [string, string])[]
10
//     ▼
11
type Encoded = typeof schema.Encoded
12

13
//     ┌─── HashMap<string, number>
14
//     ▼
15
type Type = typeof schema.Type
16

17
const decode = Schema.decodeUnknownSync(schema)
18
const encode = Schema.encodeSync(schema)
19

20
// Decoding examples
21

22
console.log(
23
  decode([
24
    ["a", "2"],
25
    ["b", "2"],
26
    ["c", "3"],
27
  ]),
28
)
29
// Output: { _id: 'HashMap', values: [ [ 'a', 2 ], [ 'c', 3 ], [ 'b', 2 ] ] }
30

31
// Encoding examples
32

33
console.log(
34
  encode(
35
    HashMap.fromIterable([
36
      ["a", 1],
37
      ["b", 2],
38
      ["c", 3],
39
    ]),
40
  ),
41
)
42
// Output: [ [ 'a', '1' ], [ 'c', '3' ], [ 'b', '2' ] ]

HashMapFromSelf

The Schema.HashMapFromSelf function is designed for scenarios where HashMap values are already in the HashMap format and need to be decoded or encoded while transforming the inner values according to the provided schemas.

Syntax

Schema.HashMapFromSelf(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`HashMap<KI, VI>`	Converts to `HashMap<KA, VA>`, where `KI` is decoded into `KA` and `VI` is decoded into `VA` using the specified schemas

Encoding

Input	Output
`HashMap<KA, VA>`	Converts to `HashMap<KI, VI>`, where `KA` is encoded into `KI` and `VA` is encoded into `VI` using the specified schemas

Example

1
import { Schema } from "effect"
2
import { HashMap } from "effect"
3

4
const schema = Schema.HashMapFromSelf({
5
  key: Schema.String,
6
  value: Schema.NumberFromString,
7
})
8

9
//     ┌─── HashMap<string, string>
10
//     ▼
11
type Encoded = typeof schema.Encoded
12

13
//     ┌─── HashMap<string, number>
14
//     ▼
15
type Type = typeof schema.Type
16

17
const decode = Schema.decodeUnknownSync(schema)
18
const encode = Schema.encodeSync(schema)
19

20
// Decoding examples
21

22
console.log(
23
  decode(
24
    HashMap.fromIterable([
25
      ["a", "2"],
26
      ["b", "2"],
27
      ["c", "3"],
28
    ]),
29
  ),
30
)
31
// Output: { _id: 'HashMap', values: [ [ 'a', 2 ], [ 'c', 3 ], [ 'b', 2 ] ] }
32

33
// Encoding examples
34

35
console.log(
36
  encode(
37
    HashMap.fromIterable([
38
      ["a", 1],
39
      ["b", 2],
40
      ["c", 3],
41
    ]),
42
  ),
43
)
44
// Output: { _id: 'HashMap', values: [ [ 'a', '1' ], [ 'c', '3' ], [ 'b', '2' ] ] }

SortedSet

The Schema.SortedSet function provides a way to map between SortedSet and an array representation, allowing for JSON serialization and deserialization.

Syntax

Schema.SortedSet(schema: Schema<A, I, R>, order: Order<A>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converts to `SortedSet<A>`, where each element in the array is decoded into type `A` using the schema

Encoding

Input	Output
`SortedSet<A>`	Converts to `ReadonlyArray<I>`, where each element in the `SortedSet` is encoded into type `I` using the schema

Example

1
import { Schema } from "effect"
2
import { Number, SortedSet } from "effect"
3

4
const schema = Schema.SortedSet(Schema.NumberFromString, Number.Order)
5

6
//     ┌─── readonly string[]
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── SortedSet<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(["1", "2", "3"]))
20
// Output: { _id: 'SortedSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
console.log(encode(SortedSet.fromIterable(Number.Order)([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

SortedSetFromSelf

The Schema.SortedSetFromSelf function is designed for scenarios where SortedSet values are already in the SortedSet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.SortedSetFromSelf(
  schema: Schema<A, I, R>,
  decodeOrder: Order<A>,
  encodeOrder: Order<I>
)

Decoding

Input	Output
`SortedSet<I>`	Converts to `SortedSet<A>`, decoding each element from type `I` to type `A` using the schema

Encoding

Input	Output
`SortedSet<A>`	Converts to `SortedSet<I>`, encoding each element from type `A` to type `I` using the schema

Example

1
import { Schema } from "effect"
2
import { Number, SortedSet, String } from "effect"
3

4
const schema = Schema.SortedSetFromSelf(Schema.NumberFromString, Number.Order, String.Order)
5

6
//     ┌─── SortedSet<string>
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── SortedSet<number>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15
const encode = Schema.encodeSync(schema)
16

17
// Decoding examples
18

19
console.log(decode(SortedSet.fromIterable(String.Order)(["1", "2", "3"])))
20
// Output: { _id: 'SortedSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
console.log(encode(SortedSet.fromIterable(Number.Order)([1, 2, 3])))
25
// Output: { _id: 'SortedSet', values: [ '1', '2', '3' ] }

Duration

The Duration schema family enables the transformation and validation of duration values across various formats, including hrtime, milliseconds, and nanoseconds.

Duration

Converts an hrtime(i.e. [seconds: number, nanos: number]) into a Duration.

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.Duration
4

5
//     ┌─── readonly [seconds: number, nanos: number]
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode([0, 0]))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
console.log(decode([5000, 0]))
21
// Output: { _id: 'Duration', _tag: 'Nanos', hrtime: [ 5000, 0 ] }

DurationFromSelf

The DurationFromSelf schema is designed to validate that a given value conforms to the Duration type.

Example

1
import { Schema, Duration } from "effect"
2

3
const schema = Schema.DurationFromSelf
4

5
//     ┌─── Duration
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode(Duration.seconds(2)))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 2000 }
19

20
console.log(decode(null))
21
/*
22
throws:
23
ParseError: Expected DurationFromSelf, actual null
24
*/

DurationFromMillis

Converts a number into a Duration where the number represents the number of milliseconds.

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.DurationFromMillis
4

5
//     ┌─── number
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode(0))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
console.log(decode(5000))
21
// Output: { _id: 'Duration', _tag: 'Millis', millis: 5000 }

DurationFromNanos

Converts a BigInt into a Duration where the number represents the number of nanoseconds.

Example

1
import { Schema } from "effect"
2

3
const schema = Schema.DurationFromNanos
4

5
//     ┌─── bigint
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode(0n))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
console.log(decode(5000000000n))
21
// Output: { _id: 'Duration', _tag: 'Nanos', hrtime: [ 5, 0 ] }

clampDuration

Clamps a Duration between a minimum and a maximum value.

Example

1
import { Schema, Duration } from "effect"
2

3
const schema = Schema.DurationFromSelf.pipe(Schema.clampDuration("5 seconds", "10 seconds"))
4

5
//     ┌─── Duration
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode(Duration.decode("2 seconds")))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 5000 }
19

20
console.log(decode(Duration.decode("6 seconds")))
21
// Output: { _id: 'Duration', _tag: 'Millis', millis: 6000 }
22

23
console.log(decode(Duration.decode("11 seconds")))
24
// Output: { _id: 'Duration', _tag: 'Millis', millis: 10000 }

Redacted

The Schema.Redacted function is specifically designed to handle sensitive information by converting a string into a Redacted object. This transformation ensures that the sensitive data is not exposed in the application’s output.

Example (Basic Redacted Schema)

1
import { Schema } from "effect"
2

3
const schema = Schema.Redacted(Schema.String)
4

5
//     ┌─── string
6
//     ▼
7
type Encoded = typeof schema.Encoded
8

9
//     ┌─── Redacted<string>
10
//     ▼
11
type Type = typeof schema.Type
12

13
const decode = Schema.decodeUnknownSync(schema)
14

15
// Decoding examples
16

17
console.log(decode("keep it secret, keep it safe"))
18
// Output: <redacted>

It’s important to note that when successfully decoding a Redacted, the output is intentionally obscured (<redacted>) to prevent the actual secret from being revealed in logs or console outputs.

Example (Exposure Risks During Errors)

In the example below, if the input string does not meet the criteria (e.g., contains spaces), the error message generated might inadvertently expose sensitive information included in the input.

1
import { Schema } from "effect"
2
import { Redacted } from "effect"
3

4
const schema = Schema.Trimmed.pipe(Schema.compose(Schema.Redacted(Schema.String)))
5

6
console.log(Schema.decodeUnknownEither(schema)(" SECRET"))
7
/*
8
{
9
  _id: 'Either',
10
  _tag: 'Left',
11
  left: {
12
    _id: 'ParseError',
13
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
14
      '└─ Encoded side transformation failure\n' +
15
      '   └─ Trimmed\n' +
16
      '      └─ Predicate refinement failure\n' +
17
      '         └─ Expected Trimmed (a string with no leading or trailing whitespace), actual " SECRET"'
18
  }
19
}
20
*/
21

22
console.log(Schema.encodeEither(schema)(Redacted.make(" SECRET")))
23
/*
24
{
25
  _id: 'Either',
26
  _tag: 'Left',
27
  left: {
28
    _id: 'ParseError',
29
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
30
      '└─ Encoded side transformation failure\n' +
31
      '   └─ Trimmed\n' +
32
      '      └─ Predicate refinement failure\n' +
33
      '         └─ Expected Trimmed (a string with no leading or trailing whitespace), actual " SECRET"'
34
  }
35
}
36
*/

Mitigating Exposure Risks

To reduce the risk of sensitive information leakage in error messages, you can customize the error messages to obscure sensitive details:

Example (Customizing Error Messages)

1
import { Schema } from "effect"
2
import { Redacted } from "effect"
3

4
const schema = Schema.Trimmed.annotations({
5
  message: () => "Expected Trimmed, actual <redacted>",
6
}).pipe(Schema.compose(Schema.Redacted(Schema.String)))
7

8
console.log(Schema.decodeUnknownEither(schema)(" SECRET"))
9
/*
10
{
11
  _id: 'Either',
12
  _tag: 'Left',
13
  left: {
14
    _id: 'ParseError',
15
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
16
      '└─ Encoded side transformation failure\n' +
17
      '   └─ Expected Trimmed, actual <redacted>'
18
  }
19
}
20
*/
21

22
console.log(Schema.encodeEither(schema)(Redacted.make(" SECRET")))
23
/*
24
{
25
  _id: 'Either',
26
  _tag: 'Left',
27
  left: {
28
    _id: 'ParseError',
29
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
30
      '└─ Encoded side transformation failure\n' +
31
      '   └─ Expected Trimmed, actual <redacted>'
32
  }
33
}
34
*/

RedactedFromSelf

The Schema.RedactedFromSelf schema is designed to validate that a given value conforms to the Redacted type from the effect library.

Example

1
import { Schema } from "effect"
2
import { Redacted } from "effect"
3

4
const schema = Schema.RedactedFromSelf(Schema.String)
5

6
//     ┌─── Redacted<string>
7
//     ▼
8
type Encoded = typeof schema.Encoded
9

10
//     ┌─── Redacted<string>
11
//     ▼
12
type Type = typeof schema.Type
13

14
const decode = Schema.decodeUnknownSync(schema)
15

16
// Decoding examples
17

18
console.log(decode(Redacted.make("mysecret")))
19
// Output: <redacted>
20

21
console.log(decode(null))
22
/*
23
throws:
24
ParseError: Expected Redacted(<redacted>), actual null
25
*/

It’s important to note that when successfully decoding a Redacted, the output is intentionally obscured (<redacted>) to prevent the actual secret from being revealed in logs or console outputs.