ts
import { Schema } from "@effect/schema"
 
// Define a transformation that doubles the input number
const transformedSchema = Schema.transform(
  // Source schema
  Schema.Number,
  // Target schema
  Schema.Number,
  {
    // optional but you get better error messages from TypeScript
    strict: true,
    // Transformation function to double the number
    decode: (n) => n * 2,
    // Reverse transformation to revert to the original number
    encode: (n) => n / 2
  }
)

ts
import { Schema } from "@effect/schema"
 
const ReadonlySetFromArray = <A, I, R>(
  itemSchema: Schema.Schema<A, I, R>
): Schema.Schema<ReadonlySet<A>, ReadonlyArray<I>, R> =>
  Schema.transform(
    Schema.Array(itemSchema),
    Schema.ReadonlySetFromSelf(Schema.typeSchema(itemSchema)),
    {
      strict: true,
      decode: (items) => new Set(items),
      encode: (set) => Array.from(set.values())
    }
  )

ts
import { Schema } from "@effect/schema"
 
const transformedSchema = Schema.transform(
  // Source schema: accepts any string
  Schema.String,
  // Target schema: also accepts any string
  Schema.String,
  {
    strict: true,
    // Trim the string during decoding
    decode: (s) => s.trim(),
    // No change during encoding
    encode: (s) => s
  }
)

ts
import { Schema } from "@effect/schema"
 
const transformedSchema = Schema.transform(
  // Source schema: accepts any string
  Schema.String,
  // Target schema now only accepts strings that are trimmed
  Schema.String.pipe(Schema.filter((s) => s === s.trim())),
  {
    strict: true,
    // Trim the string during decoding
    decode: (s) => s.trim(),
    // No change during encoding
    encode: (s) => s
  }
)

ts
import { Schema } from "@effect/schema"
import { Number } from "effect"
 
const clamp =
  (minimum: number, maximum: number) =>
  <A extends number, I, R>(self: Schema.Schema<A, I, R>) =>
    Schema.transform(
      self,
      self.pipe(
        Schema.typeSchema,
        Schema.filter((a) => a <= minimum || a >= maximum)
      ),
      {
Argument of type '{ strict: true; decode: (a: A) => number; encode: (a: A) => A; }' is not assignable to parameter of type '{ readonly decode: (fromA: A, fromI: I) => A; readonly encode: (toI: A, toA: A) => A; readonly strict?: true | undefined; } | { readonly decode: (fromA: A, fromI: I) => unknown; readonly encode: (toI: A, toA: A) => unknown; readonly strict: false; }'.
  The types returned by 'decode(...)' are incompatible between these types.
    Type 'number' is not assignable to type 'A'.
      'number' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'number'.2345Argument of type '{ strict: true; decode: (a: A) => number; encode: (a: A) => A; }' is not assignable to parameter of type '{ readonly decode: (fromA: A, fromI: I) => A; readonly encode: (toI: A, toA: A) => A; readonly strict?: true | undefined; } | { readonly decode: (fromA: A, fromI: I) => unknown; readonly encode: (toI: A, toA: A) => unknown; readonly strict: false; }'.
  The types returned by 'decode(...)' are incompatible between these types.
    Type 'number' is not assignable to type 'A'.
      'number' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'number'.
        strict: true,
        decode: (a) => Number.clamp(a, { minimum, maximum }),
        encode: (a) => a
      }
    )

ts
import { ParseResult, Schema } from "@effect/schema"
 
export const NumberFromString = Schema.transformOrFail(
  Schema.String, // Source schema: accepts any string
  Schema.Number, // Target schema: expects a number
  {
    strict: true, // optional but you get better error messages from TypeScript
    decode: (input, options, ast) => {
      const parsed = parseFloat(input)
      if (isNaN(parsed)) {
        return ParseResult.fail(
          new ParseResult.Type(
            ast,
            input,
            "Failed to convert string to number"
          )
        )
      }
      return ParseResult.succeed(parsed)
    },
    encode: (input, options, ast) => ParseResult.succeed(input.toString())
  }
)

ts
import { ParseResult, Schema, TreeFormatter } from "@effect/schema"
import { Effect } from "effect"
 
// Define an API call function
const api = (url: string): Effect.Effect<unknown, Error> =>
  Effect.tryPromise({
    try: () =>
      fetch(url).then((res) => {
        if (res.ok) {
          return res.json() as Promise<unknown>
        }
        throw new Error(String(res.status))
      }),
    catch: (e) => new Error(String(e))
  })
 
const PeopleId = Schema.String.pipe(Schema.brand("PeopleId"))
 
// Define a schema with async transformation
const PeopleIdFromString = Schema.transformOrFail(Schema.String, PeopleId, {
  strict: true,
  decode: (s, _, ast) =>
    Effect.mapBoth(api(`https://swapi.dev/api/people/${s}`), {
      onFailure: (e) => new ParseResult.Type(ast, s, e.message),
      onSuccess: () => s
    }),
  encode: ParseResult.succeed
})
 
const decode = (id: string) =>
  Effect.mapError(Schema.decodeUnknown(PeopleIdFromString)(id), (e) =>
    TreeFormatter.formatErrorSync(e)
  )
 
Effect.runPromiseExit(decode("1")).then(console.log)
/*
Output:
{ _id: 'Exit', _tag: 'Success', value: '1' }
*/
 
Effect.runPromiseExit(decode("fail")).then(console.log)
/*
Output:
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Fail',
    failure: '(string <-> string & Brand<"PeopleId">)\n' +
      '└─ Transformation process failure\n' +
      '   └─ Error: 404'
  }
}
*/

ts
import { ParseResult, Schema, TreeFormatter } from "@effect/schema"
import { Context, Effect, Layer } from "effect"
 
const Fetch = Context.GenericTag<"Fetch", typeof fetch>("Fetch")
 
// API call function with dependency
const api = (url: string): Effect.Effect<unknown, Error, "Fetch"> =>
  Fetch.pipe(
    Effect.flatMap((fetch) =>
      Effect.tryPromise({
        try: () =>
          fetch(url).then((res) => {
            if (res.ok) {
              return res.json() as Promise<unknown>
            }
            throw new Error(String(res.status))
          }),
        catch: (e) => new Error(String(e))
      })
    )
  )
 
const PeopleId = Schema.String.pipe(Schema.brand("PeopleId"))
 
const PeopleIdFromString = Schema.transformOrFail(Schema.String, PeopleId, {
  strict: true,
  decode: (s, _, ast) =>
    Effect.mapBoth(api(`https://swapi.dev/api/people/${s}`), {
      onFailure: (e) => new ParseResult.Type(ast, s, e.message),
      onSuccess: () => s
    }),
  encode: ParseResult.succeed
})
 
const decode = (id: string) =>
  Effect.mapError(Schema.decodeUnknown(PeopleIdFromString)(id), (e) =>
    TreeFormatter.formatErrorSync(e)
  )
 
const FetchLive = Layer.succeed(Fetch, fetch)
 
Effect.runPromiseExit(decode("1").pipe(Effect.provide(FetchLive))).then(
  console.log
)
/*
Output:
{ _id: 'Exit', _tag: 'Success', value: '1' }
*/
 
Effect.runPromiseExit(decode("fail").pipe(Effect.provide(FetchLive))).then(
  console.log
)
/*
Output:
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Fail',
    failure: '(string <-> string & Brand<"PeopleId">)\n' +
      '└─ Transformation process failure\n' +
      '   └─ Error: 404'
  }
}
*/

ts
import { Schema } from "@effect/schema"
import { Effect } from "effect"
 
async function validateUsername(username: string) {
  return Promise.resolve(username === "gcanti")
}
 
const ValidUsername = Schema.String.pipe(
  Schema.filterEffect((username) =>
    Effect.promise(() =>
      validateUsername(username).then((valid) => valid || "Invalid username")
    )
  )
).annotations({ identifier: "ValidUsername" })
 
Effect.runPromise(Schema.decodeUnknown(ValidUsername)("xxx")).then(
  console.log
)
/*
ParseError: ValidUsername
└─ Transformation process failure
   └─ Invalid username
*/

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.split(",")
 
const decode = Schema.decodeUnknownSync(schema)
 
console.log(decode("")) // [""]
console.log(decode(",")) // ["", ""]
console.log(decode("a,")) // ["a", ""]
console.log(decode("a,b")) // ["a", "b"]

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Trim)
 
console.log(decode("a")) // "a"
console.log(decode(" a")) // "a"
console.log(decode("a ")) // "a"
console.log(decode(" a ")) // "a"

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Lowercase)
 
console.log(decode("A")) // "a"
console.log(decode(" AB")) // " ab"
console.log(decode("Ab ")) // "ab "
console.log(decode(" ABc ")) // " abc "

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Uppercase)
 
console.log(decode("a")) // "A"
console.log(decode(" ab")) // " AB"
console.log(decode("aB ")) // "AB "
console.log(decode(" abC ")) // " ABC "

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Capitalize)
 
console.log(decode("aa")) // "Aa"
console.log(decode(" ab")) // " ab"
console.log(decode("aB ")) // "AB "
console.log(decode(" abC ")) // " abC "

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Uncapitalize)
 
console.log(decode("AA")) // "aA"
console.log(decode(" AB")) // " AB"
console.log(decode("Ab ")) // "ab "
console.log(decode(" AbC ")) // " AbC "

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.parseJson()
const decode = Schema.decodeUnknownSync(schema)
 
// Parse valid JSON strings
console.log(decode("{}")) // Output: {}
console.log(decode(`{"a":"b"}`)) // Output: { a: "b" }
 
// Attempting to decode an empty string results in an error
decode("")
/*
throws:
ParseError: (JsonString <-> unknown)
└─ Transformation process failure
   └─ Unexpected end of JSON input
*/

ts
import { Schema } from "@effect/schema"
 
// Schema<{ readonly a: number; }, string, never>
const schema = Schema.parseJson(Schema.Struct({ a: Schema.Number }))

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.StringFromBase64)
 
console.log(decode("Zm9vYmFy")) // "foobar"

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.StringFromBase64Url)
 
console.log(decode("Zm9vYmFy")) // "foobar"

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.StringFromHex)
 
console.log(new TextEncoder().encode(decode("0001020304050607")))
/*
Output:
Uint8Array(8) [
  0, 1, 2, 3,
  4, 5, 6, 7
]
*/

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.NumberFromString
 
const decode = Schema.decodeUnknownSync(schema)
 
// success cases
console.log(decode("1")) // 1
console.log(decode("-1")) // -1
console.log(decode("1.5")) // 1.5
console.log(decode("NaN")) // NaN
console.log(decode("Infinity")) // Infinity
console.log(decode("-Infinity")) // -Infinity
 
// failure cases
decode("a")
/*
throws:
ParseError: NumberFromString
└─ Transformation process failure
   └─ Expected NumberFromString, actual "a"
*/

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.Number.pipe(Schema.clamp(-1, 1)) // clamps the input to -1 <= x <= 1
 
const decode = Schema.decodeUnknownSync(schema)
 
console.log(decode(-3)) // -1
console.log(decode(0)) // 0
console.log(decode(3)) // 1

ts
import { Schema } from "@effect/schema"
 
const schema = Schema.String.pipe(Schema.parseNumber)
 
const decode = Schema.decodeUnknownSync(schema)
 
console.log(decode("1")) // 1
console.log(decode("Infinity")) // Infinity
console.log(decode("NaN")) // NaN
console.log(decode("-"))
/*
throws
ParseError: (string <-> number)
└─ Transformation process failure
   └─ Expected (string <-> number), actual "-"
*/

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Not)
 
console.log(decode(true)) // false
console.log(decode(false)) // true

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.Symbol)
 
console.log(decode("a")) // Symbol(a)

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.BigInt)
 
// success cases
console.log(decode("1")) // 1n
console.log(decode("-1")) // -1n
 
// failure cases
decode("a")
/*
throws:
ParseError: bigint
└─ Transformation process failure
   └─ Expected bigint, actual "a"
*/
decode("1.5") // throws
decode("NaN") // throws
decode("Infinity") // throws
decode("-Infinity") // throws

ts
import { Schema } from "@effect/schema"
 
const decode = Schema.decodeUnknownSync(Schema.BigIntFromNumber)
const encode = Schema.encodeSync(Schema.BigIntFromNumber)
 
// success cases
console.log(decode(1)) // 1n
console.log(decode(-1)) // -1n
console.log(encode(1n)) // 1
console.log(encode(-1n)) // -1
 
// failure cases
decode(1.5)
/*
throws:
ParseError: BigintFromNumber
└─ Transformation process failure
   └─ Expected BigintFromNumber, actual 1.5
*/
decode(NaN) // throws
decode(Infinity) // throws
decode(-Infinity) // throws
encode(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // throws
encode(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // throws

ts
import { Schema } from "@effect/schema"
 
// clamps the input to -1n <= x <= 1n
const schema = Schema.BigIntFromSelf.pipe(Schema.clampBigInt(-1n, 1n))
 
const decode = Schema.decodeUnknownSync(schema)
 
console.log(decode(-3n)) // -1n
console.log(decode(0n)) // 0n
console.log(decode(3n)) // 1n