ahoy-jon

The Rebirth of Tagless Final: An Ergonomic Approach in Kyo

For years, the Tagless Final pattern has been a cornerstone of functional programming in Scala, offering unparalleled compositionality and a clean separation between program definition and interpretation. Yet, for many, its power came at the cost of ergonomic friction: a world of F[_] context bounds, implicit parameters, and boilerplate that could obscure the business logic it was meant to clarify.

I recently went on a fun journey with Kyo, a new effect system for Scala, and stumbled upon a discovery. After initially trying to replace Tagless Final with custom effects, I found a novel approach that doesn't kill the pattern but revitalizes it, making it more intuitive and human-friendly than ever before.

What is Tagless Final? A Quick Refresher

Tagless Final is a technique used for encoding programs with effects. Instead of using a concrete data type like IO[A], effects are abstracted over a type parameter, typically F[_]. This a

ahoy-jon

//> using scala "3.7.1-RC2"

//> using dep io.getkyo::kyo-core:0.19.0+40-6e6cea21+20250603-1734-SNAPSHOT
//> using dep io.getkyo::kyo-prelude:0.19.0+40-6e6cea21+20250603-1734-SNAPSHOT
//> using dep io.getkyo::kyo-direct:0.19.0+40-6e6cea21+20250603-1734-SNAPSHOT

//> using dep org.scalatest::scalatest:3.2.19


//> using option -Wvalue-discard

ahoy-jon

import scala.annotation.{ nowarn, tailrec }

import kyo.*

val a = 1

def doSomething(): Unit = {
  println("do")
  println("something")
}

ahoy-jon

//> using scala 3.4.2

//> using dep "io.swagger.core.v3:swagger-annotations-jakarta:2.2.22"
//> using dep "com.softwaremill.sttp.tapir:tapir-core_3:1.11.0"

import io.swagger.v3.oas.annotations.media.{Schema => OpenApiSchema}
import sttp.tapir.*
import sttp.tapir.generic.auto.*

ahoy-jon

#awk '
function chunk_mod(s) {
    len = 6 # 6 digits in case of 32-bit awk version
    result = 0
    while (length(s) > 0) {
        chunk = substr(s, 1, len)
        s = substr(s, len + 1)
        result = (result * (10 ^ length(chunk)) + chunk) % 97
    }
    return result

ahoy-jon

import org.apache.kafka.clients.consumer.{ConsumerConfig, KafkaConsumer}
import org.apache.kafka.common.serialization.{StringDeserializer, StringSerializer}
import io.confluent.kafka.serializers.AbstractKafkaSchemaSerDeConfig
import org.apache.avro.generic.GenericRecord
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerConfig, ProducerRecord}

import java.util.Properties
import scala.jdk.CollectionConverters._

ahoy-jon

Keybase proof

I hereby claim:

• I am ahoy-jon on github.
• I am ahoy_jon (https://keybase.io/ahoy_jon) on keybase.
• I have a public key whose fingerprint is 2D1F 3333 68BF 23E6 0B5F 97EC AA13 2117 84F5 5FCC

To claim this, I am signing this object:

ahoy-jon

sealed abstract class Cont[Result, +H] {

  final def map[H2](fn: H => H2): Cont[Result, H2]                   = flatMap(h => Cont.pure(fn(h)))
  final def flatMap[H2](fn: H => Cont[Result, H2]): Cont[Result, H2] = Cont.FlatMapped(this, fn)

  def apply(fn: H => Result): Result
}

object Cont {
  case class Wrap[Result, H](f: (H => Result) => Result) extends Cont[Result, H] {

ahoy-jon

  def toIterator[R, E, A](
    stream: ZStream[R, E, A]
  ): ZManaged[R, Nothing, Iterator[Either[E, A]]] = {
    /*
     * Internal state of a Iterator pulling from a ZStream
     *
     * It starts as Running
     *
     * when Running  , on pull (hasNext), pull the ZStream and switch to Closed or Value
     * when Value    , on consume (next), return the Value and switch to Running

ahoy-jon

sealed trait Path

case class Field(name: String, child: Option[Path]) extends Path {
  override def toString: String = child match {
    case None       => name
    case Some(path) => s"$name.$path"
  }
}