Brand

import { Brand } from "effect"

type UserId = number & Brand.Brand<"UserId">
type ProductId = number & Brand.Brand<"ProductId">

// These are different types even though both are numbers

const nominal: <A extends Brand<any>>() => Brand.Constructor<A>

import { Brand } from "effect"

type UserId = number & Brand.Brand<"UserId">

const UserId = Brand.nominal<UserId>()

const id = UserId(123) // UserId

// Type error: can't assign UserId to ProductId
type ProductId = number & Brand.Brand<"ProductId">
const ProductId = Brand.nominal<ProductId>()
const productId: ProductId = id // Error!

function refined<A extends Brand<any>>(
  refinement: Predicate<Brand.Unbranded<A>>,
  onFailure: (unbranded: Brand.Unbranded<A>) => Brand.BrandErrors
): Brand.Constructor<A>

import { Brand } from "effect"

type Int = number & Brand.Brand<"Int">

const Int = Brand.refined<Int>(
  (n) => Number.isInteger(n),
  (n) => Brand.error(`Expected ${n} to be an integer`)
)

const value = Int(42) // Int
Int(1.5) // throws BrandErrors

import { Brand, Either } from "effect"

type Positive = number & Brand.Brand<"Positive">

const Positive = Brand.refined<Positive>(
  (n) => n > 0,
  (n) => Brand.error(`Expected ${n} to be positive`)
)

const result = Positive.either(5)
if (Either.isRight(result)) {
  console.log(result.right) // 5 as Positive
}

import { Brand, Option } from "effect"

const result = Positive.option(-5)
// Option.none()

const result2 = Positive.option(10)
// Option.some(10 as Positive)

interface Constructor<in out A extends Brand<any>> {
  readonly [RefinedConstructorsTypeId]: RefinedConstructorsTypeId

  // Construct or throw
  (args: Brand.Unbranded<A>): A

  // Construct or return None
  option(args: Brand.Unbranded<A>): Option.Option<A>

  // Construct or return Left with errors
  either(args: Brand.Unbranded<A>): Either.Either<A, Brand.BrandErrors>

  // Type guard
  is(a: Brand.Unbranded<A>): a is Brand.Unbranded<A> & A
}

const all: <Brands extends readonly [Brand.Constructor<any>, ...Array<Brand.Constructor<any>>]>(
  ...brands: Brand.EnsureCommonBase<Brands>
) => Brand.Constructor<...>

import { Brand } from "effect"

type Int = number & Brand.Brand<"Int">
const Int = Brand.refined<Int>(
  (n) => Number.isInteger(n),
  (n) => Brand.error(`Expected ${n} to be an integer`)
)

type Positive = number & Brand.Brand<"Positive">
const Positive = Brand.refined<Positive>(
  (n) => n > 0,
  (n) => Brand.error(`Expected ${n} to be positive`)
)

const PositiveInt = Brand.all(Int, Positive)

PositiveInt(5) // number & Brand<"Int"> & Brand<"Positive">
PositiveInt(-5) // throws
PositiveInt(1.5) // throws

interface BrandErrors extends Array<RefinementError> {}

interface RefinementError {
  readonly meta: unknown
  readonly message: string
}

const error: (message: string, meta?: unknown) => Brand.BrandErrors

const errors: (...errors: Array<Brand.BrandErrors>) => Brand.BrandErrors

type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P

type UserId = number & Brand.Brand<"UserId">

type Base = Brand.Unbranded<UserId> // number

type FromConstructor<A> = A extends Brand.Constructor<infer B> ? B : never

const unbranded: <A extends Brand<any>>(branded: A) => Brand.Unbranded<A>

import { Brand } from "effect"

type UserId = number & Brand.Brand<"UserId">
const UserId = Brand.nominal<UserId>()

const id = UserId(123)
const raw = Brand.unbranded(id) // number