Effect TS

// TypeScript: separate validation lib + manual types + manual serialization
import { z } from "zod"

// 1. Define Zod schema for validation
const UserSchema = z.object({
  name: z.string(),
  age: z.number().int().positive(),
  email: z.string().email(),
  role: z.enum(["admin", "user"]),
  tags: z.array(z.string()).default([])
})

// 2. Extract type (at least Zod gives you this)
type User = z.infer<typeof UserSchema>

// 3. Parse (throws on failure — no typed errors)
const user = UserSchema.parse(apiResponse)

// 4. Serialize? Zod doesn't help — manual JSON.stringify
// 5. Transform for API response? Write another function
// 6. Different encoded vs decoded shapes? More manual work

import { Schema } from "effect"

// ── 1. Define schema — types are inferred automatically ──
const User = Schema.Struct({
  name: Schema.String,
  age: Schema.Number.pipe(Schema.int(), Schema.positive()),
  email: Schema.String.pipe(Schema.pattern(/@/)),
  role: Schema.Literal("admin", "user"),
  tags: Schema.optionalWith(Schema.Array(Schema.String), {
    default: () => []        // default value if missing
  })
})

// Type is inferred — no manual interface needed
type User = typeof User.Type
// { name: string; age: number; email: string; role: "admin" | "user"; tags: string[] }

// ── 2. Decode (effectful — ParseError is a typed error) ──
const parseUser = Schema.decodeUnknown(User)
const program = Effect.gen(function* () {
  const user = yield* parseUser(apiResponse)
  //    ^? User — fully typed
  return user
})

// ── 3. Decode (sync — throws on failure) ──
const user = Schema.decodeUnknownSync(User)(apiResponse)

// ── 4. Encode — serialize back to encoded form ──
const encoded = Schema.encodeSync(User)(user)

// ── 5. Compose schemas ──
const CreateUser = Schema.Struct({
  ...User.fields,
  password: Schema.String.pipe(Schema.minLength(8))
})

// TypeScript: separate class, validation, and type definitions
interface UserData {
  id: string
  name: string
  createdAt: string  // ISO string from API
}

class User {
  readonly id: string
  readonly name: string
  readonly createdAt: Date  // Parsed to Date internally

  constructor(data: UserData) {
    // Manual validation
    if (!data.id) throw new Error("id required")
    if (!data.name) throw new Error("name required")
    this.id = data.id
    this.name = data.name
    this.createdAt = new Date(data.createdAt)  // Manual transform
  }
}

// Problems:
// - No type-safe error handling (throws generic Error)
// - No encode back to API format
// - UserId and PostId are both just "string" — easy to mix up
// - Two users with same data are !== (reference equality)
type UserId = string   // ← nothing stops you passing a PostId here
type PostId = string

import { Schema } from "effect"

// ── Schema.Class: schema + class in one ──
class User extends Schema.Class<User>("User")({
  id: Schema.String,
  name: Schema.NonEmptyString,
  createdAt: Schema.Date         // decodes ISO string → Date, encodes Date → string
}) {
  // Access fields via this — just like a normal class
  greet(): string {
    return `Hi, I'm ${this.name} (id: ${this.id})`
  }

  get displayName(): string {
    return this.name.toUpperCase()
  }
}

const user = new User({ id: "1", name: "Alice", createdAt: new Date() })
user.name         // "Alice" — access fields directly
user.greet()      // "Hi, I'm Alice (id: 1)"
user.displayName  // "ALICE"
// ✓ Constructor validates fields
// ✓ Structural equality: new User({...}) === new User({...}) if same data

// ── Schema.TaggedClass: auto _tag for discriminated unions ──
class Circle extends Schema.TaggedClass<Circle>()("Circle", {
  radius: Schema.Number
}) {}

class Square extends Schema.TaggedClass<Square>()("Square", {
  side: Schema.Number
}) {}

const Shape = Schema.Union(Circle, Square)
type Shape = typeof Shape.Type
// { _tag: "Circle", radius: number } | { _tag: "Square", side: number }

// ── Schema.TaggedError: typed errors with schema ──
class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
  message: Schema.String,
  resourceId: Schema.String
}) {}
// Use: Effect<User, NotFound, Deps>

// ── Branded types: prevent ID mixups ──
const UserId = Schema.String.pipe(Schema.brand("UserId"))
const PostId = Schema.String.pipe(Schema.brand("PostId"))
type UserId = typeof UserId.Type  // string & Brand<"UserId">
type PostId = typeof PostId.Type  // string & Brand<"PostId">

// const oops: UserId = "abc" as PostId  // ← compile error!

// ── Transform: different shapes for decode vs encode ──
const DateFromString = Schema.transform(
  Schema.String,                              // encoded (API)
  Schema.DateFromSelf,                        // decoded (app)
  {
    strict: true,
    decode: (s) => new Date(s),               // string → Date
    encode: (d) => d.toISOString()            // Date → string
  }
)

// ── Constructor defaults ──
class Post extends Schema.Class<Post>("Post")({
  title: Schema.String,
  published: Schema.Boolean.pipe(
    Schema.propertySignature,
    Schema.withConstructorDefault(() => false)  // optional in constructor
  ),
  createdAt: Schema.Number.pipe(
    Schema.propertySignature,
    Schema.withConstructorDefault(() => Date.now())
  )
}) {}

const post = new Post({ title: "Hello" })
// { title: "Hello", published: false, createdAt: 1712345678901 }

// TypeScript: null/undefined — implicit, easy to forget
function findUser(id: string): User | null {
  return db.get(id) ?? null
}

const user = findUser("123")
// Oops — forgot to check for null!
console.log(user.name) // 💥 runtime error

// TypeScript: union types for branching
type Result = { ok: true; data: User } | { ok: false; error: string }
function fetchUser(id: string): Result { ... }

const result = fetchUser("123")
if (result.ok) {
  result.data  // User
} else {
  result.error // string
}
// Works, but:
// - No standard API (map, flatMap, match)
// - Every team invents their own Result type
// - Doesn't compose with pipe

import { Option, Either, pipe } from "effect"

// ── Option: explicit absence ──
const user: Option.Option<User> = Option.fromNullable(db.get("123"))
// Option.some({ name: "Alice" }) or Option.none()

// Transform with map (only runs on Some)
const name = user.pipe(
  Option.map((u) => u.name),
  Option.getOrElse(() => "Anonymous")
)
// "Alice" or "Anonymous"

// Chain with flatMap (can return None)
const email = user.pipe(
  Option.flatMap((u) => Option.fromNullable(u.email)),
  Option.getOrElse(() => "no-email")
)

// Pattern match — exhaustive, can't forget a case
const greeting = Option.match(user, {
  onNone: () => "Hello, stranger",
  onSome: (u) => `Hello, ${u.name}`
})

// Interop: convert back to nullable
const nullable: User | null = Option.getOrNull(user)

// Type guards
if (Option.isSome(user)) {
  user.value.name  // narrowed to User
}

// ── Either: explicit branching ──
const parsed: Either.Either<number, string> = pipe(
  "42",
  (s) => {
    const n = parseInt(s)
    return isNaN(n)
      ? Either.left("not a number")   // Left = failure
      : Either.right(n)                // Right = success
  }
)

// Transform the success side
const doubled = parsed.pipe(Either.map((n) => n * 2))

// Transform the error side
const withContext = parsed.pipe(
  Either.mapLeft((e) => `Parse failed: ${e}`)
)

// Pattern match
Either.match(parsed, {
  onLeft: (err) => console.log(`Error: ${err}`),
  onRight: (val) => console.log(`Value: ${val}`)
})