ReactorFutures.run { r =>
  while buf.hasRemaining() do
    perform(r,
      r.ops.write(socket, buf))
  var running = true
  while running do
    buf.clear()
    perform(r, r.ops.read(socket, buf))
    running = buf.position() != 0
    if running then
      buf.flip()
      drainTo(buf, response)
}

ReactorFutures.run { r =>
  while buf.hasRemaining() do
    perform(r,
      r.ops.write(socket, buf))
  var running = true
  while running do
    buf.clear()
    perform(r, r.ops.read(socket, buf))
    running = buf.position() != 0
    if running then
      buf.flip()
      drainTo(buf, response)
}

import steps.result.Validation
import Validation.{scope, Validated}

case class Form(
  name: String, age: String, email: String)

def checkFields(f: Form): Validated[Unit, String] =
  Validation.validated:
    scope.test(f.name.nonEmpty, "Name: required")
    scope.test(f.age.nonEmpty, "Age: required")
    scope.test(f.email.nonEmpty, "Email: required")

case class Account(name: String, age: Int, email: Email)

def validateForm(f: Form): Validated[Account, String] =
  Validation.validated:
    // stage 0
    scope.testAll(checkFields(f)).ok
    // stage 1
    val n = scope.test(parseName(f.name))
    val a = scope.test(parseInt(f.age))
    val e = scope.test(parseEmail(f.email))
    // stage 2
    val age = a.ok
    scope.require(age >= 18, "Age: must be 18+")
    Account(n.ok, age, e.ok)

def checkEmailConflict(a: Form, b: Form)(
    aErrors: Validation[String]^,
    bErrors: Validation[String]^
): Unit =
  val dupMsg = "Email: duplicated in batch"
  val distinct = a.email != b.email
  aErrors.test(distinct, dupMsg)
  bErrors.test(distinct, dupMsg)

Validation.validated[Unit, String] {
  checkEmailConflict(a, b)(scope, scope)
}

class Validation[E]
  extends Stateful,
    ExclusiveCapability:
  // implementation omitted

@main def serve(
  host: String, port: Int = 8080, files: String*
): Unit = ...

@cmd def serve(
  host: String, port: Int = 8080, files: String*
): Unit = ...

@main def run(args: String*): Unit =
  Flagged.parseOrExit[this.type](args)

./serve.scala localhost 7777 foo.scala

@cmd def serve(
  host: String, port: Int = 8080, files: String*
): Unit = ...

case class Serve(
  host: String, port: Int = 8080, files: String*
) derives Parser.Command

@main def run(args: String*): Unit =
  val serve = Flagged.parseOrExit[Serve](args)
  ...

./serve.scala localhost 7777 foo.scala

./serve.scala localhost 7777 foo.scala

case class Serve(
  @opt host: String,
  @opt(short = 'p') port: Int = 8080,
  files: String*
) derives Parser.Command

./serve.scala -p 7777 --host localhost foo.scala
./serve.scala --host localhost foo.scala

enum Gitto derives Parser.CommandGroup:
  case Clone(repo: String,
    @opt(short = 'd') depth: Option[Int] = None)
  case Remote(action: RemoteAction)
  case Status(@opt(short = 's') short: Boolean = false)

enum RemoteAction derives Parser.CommandGroup:
  case Add(name: String, url: String)
  case Remove(name: String)

@main def gitto(args: String*): Unit =
  val cfg = Flagged.parseOrExit[Gitto](args)
  ...

./gitto.scala remote add origin \
  https://github.com/lampepfl/gears.git

transparent inline given ofProduct[T]:
    AnnotMirror.Product[T] =
  ${ macros.AnnotationMacros.annotMirrorProduct[T] }

inline def derived[A]: Defaults[A] =
  ${ macros.DefaultMacros.defaults[A] }

transparent inline given of[T]: MethodsMirror.Of[T] =
  ${ macros.MethodMacros.methodsMirror[T] }

val row = (Text("Jamie"), Number(42))
require(row(1).value >= 18) // precise per-elem type

render(row)
// Jamie,42

trait Cell { def text: String }

def render[T <: Tuple: ElemsOf[Cell]](cells: T) =
  elemsIterator[T, Cell](cells)
    .map(_.text).mkString(",")

type ElemsOf[I] =
  [T <: Tuple] =>> Tuple.Union[T] <:< I

type PersonRow = (name: Text, age: Number)

val row =
  (name = Text("Jamie"), age = Number(42))
val titles =
  (name = "Full name", age = "Age (years)")

report[PersonRow](row)(titles)

def report[
  Row <: AnyNamedTuple: FieldsOf[Cell]
](row: Row)[
  Titles <: SameFields[Row]
            : FieldsOf[String]
](titles: Titles): String =
  fieldsIterator[Titles, String](titles)
    .zip(fieldsIterator[Row, Cell](row)) …

type FieldsOf[I] = [F <: AnyNamedTuple] =>>
  ElemsOf[I][NamedTuple.DropNames[F]]

type SameFields[F <: AnyNamedTuple] =
  NamedTuple.Map[F, [_] =>> Any]

// Invoice.scala
val config = (
  invoice = (
    id = 5,
    period = (start = "2025/1/27", days = 30)
  ),
  listings = (
    items = Vector(
      (desc = "Premium Insurance (1 year)",
        qty = 2, price = 250),
      (desc = "Samsung Galaxy S13",
        qty = 1, price = 999)
    ),
    taxRate = 12
…

type SelectField[NT <: AnyNamedTuple, K <: String] =
  NT match
    case NamedTuple[ns, vs] => Search[K, ns, vs]

type SelectElem[S <: Seq[?]] = S match
  case Seq[e] => e

type Search[K <: String, Ns <: Tuple, Vs <: Tuple] =
  (Ns, Vs) match
    case (K *: _, v *: _)   => v
    case (_ *: ns, _ *: vs) => Search[K, ns, vs]

// Invoice.scala
val config = (
  invoice = (
    id = 5,
    period = (start = "2025/1/27", days = 30)
…

val parser = ParseFrom.identity[Invoice]
  .patch(
    Patch(_.invoice.period.start)
      .to[LocalDate]
  )
val application = parser.tryRead(config)

val parser = ParseFrom.identity[Invoice]
  .patch(
    Patch(_.invoice.period.start)
      .to[LocalDate]
  )

given ParseFrom[String, LocalDate]:
  def tryRead(in: String)
    : Validated[LocalDate, Err] =
  Validation.validate(…)

def parseDate(s: String):
  Result[LocalDate, DecodeError] = …

given ReadWriter[LocalDate] =
  summon[ReadWriter[String]]
    .bimapResult(parseDate)(_.toString)

type Config = (
  db: Option[(
    host: String,
    port: Int,
    replicas: Vector[(host: String, port: Int)]
  )]
)

given DefaultValues[Config] = DefaultValues.of { c =>
  Seq(
    c.db := Some(("120.0.0.1", 5432, Vector())),
    c.db.some.port := 5432,
    c.db.some.replicas.each.port := 5432
  )
}

class Path[T, AtField <: Boolean] extends Selectable:
  type Fields = NamedTuple.Map[
    NamedTuple.From[T],
    [F] =>> Path[F, true]
  ]
  def selectDynamic(name: String): Path[?, true] = ...

extension [T](path: Path[T, ?])
  def some(using r: OptionLike[T]): Path[r.Inner, false] = ...
  def each(using r: VectorLike[T]): Path[r.Inner, false] = ...

extension [T](path: Path[T, true])
  def :=(value: T): Binding = ...

def decodeField(): Result[Unit, DecodeError] =
  Result.task:
    decodeInt().check
    slots.setInt(0, pullIntValue())

object Result:
  …
  val done: Result[Unit, Nothing] = Ok(())

class Record[T <: AnyNamedTuple](private val live: T)
    extends Selectable:
  type Fields = T
  inline def selectDynamic(name: String): Any =
    live.productElement(constValue[IndexOf[Name, Fields]])

type Parent = (id: String)
def idOf(meta: Record[Parent]): String = meta.id
val parent = Record((id = "record-slide"))
val slide = parent ++ (layout = "standard")

idOf(parentView(slide)) // "record-slide"
slide.layout            // "standard"

def parentView[T <: AnyNamedTuple](r: Record[T])(
  using Record.IsSubPrefix[T, Parent]
): Record[Parent] = r.asInstanceOf[Record[Parent]]

class TemplateFunctions[T <: AnyNamedTuple](
  private val functions: Record[T]
) extends Selectable:
  type Fields = T

object TalkRevealTheme:
  def apply(fonts: DeckFonts = DeckFonts()) =
    RevealTheme.withTemplates(
      RevealTheme.defaultTemplates ++
        WhiteboardTemplates.templates,
      …
    )

case class SlideMeta(
  id: String, seconds: Int = 5, layout: String
)

class RevealTheme(...) extends Theme:
  ...
  type SiteMap = (
    deck: Directory[(
      index: Doc[DeckMeta],
      `speaker-notes`: Doc[NotesMeta],
      slides: Docs[SlideMeta]
    )]
  )

---scala
(id = "son-presentation-frontmatter", layout = "standard")
---

## Yes, even this presentation!

(db = (port = 5432, host = "db"),
 weights = Vector(2, 1))

case class Endpoint(port: Int, host: String)
case class Config(
  db: Option[Endpoint], weights: Array[Int]
)