Function toTaggedUnion

packages/effect/src/Schema.ts:6272–6331

(tag: Tag)

 * @since 4.0.0
 */
export function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag) {
  return <const Members extends ReadonlyArray<Constraint & { readonly Type: { readonly [K in Tag]: PropertyKey } }>>(
    self: Union<Members>
  ): toTaggedUnion<Tag, Members> => {
    const cases: Record<PropertyKey, unknown> = {}
    const discriminants: Array<PropertyKey> = []
    const discriminantKeys = new Set<string | symbol>()
    const guards: Record<PropertyKey, (u: unknown) => boolean> = {}
    const isAnyOf = (keys: ReadonlyArray<PropertyKey>) => (value: Members[number]["Type"]) => keys.includes(value[tag])

    walk(self)

    return Object.assign(self, { cases, discriminants, isAnyOf, guards, match }) as any

    function walk(schema: Constraint) {
      const ast = schema.ast

      if (
        SchemaAST.isUnion(ast) && "members" in schema && globalThis.Array.isArray(schema.members) &&
        schema.members.every(isSchema)
      ) {
        return schema.members.forEach(walk)
      }

      const sentinels = SchemaAST.collectSentinels(ast)
      if (sentinels.length > 0) {
        const literal = sentinels.find((s) => s.key === tag)?.literal
        if (Predicate.isPropertyKey(literal)) {
          const key = typeof literal === "number" ? globalThis.String(literal) : literal
          if (discriminantKeys.has(key)) {
            throw new globalThis.Error(`Duplicate discriminant: ${globalThis.String(literal)}`)
          }
          discriminantKeys.add(key)
          discriminants.push(literal)
          InternalRecord.assignProperty(cases, literal, schema)
          InternalRecord.assignProperty(guards, literal, is(toType(schema)))
          return
        }
      }

      throw new globalThis.Error("No literal or unique symbol found")
    }

    function match() {
      if (arguments.length === 1) {
        const cases = arguments[0]
        return function(value: any) {
          const key = value[tag]
          const handler = Object.hasOwn(cases, key) ? cases[key] : undefined
          return handler(value)
        }
      }
      const value = arguments[0]
      const cases = arguments[1]
      const key = value[tag]
      const handler = Object.hasOwn(cases, key) ? cases[key] : undefined
      return handler(value)
    }