Redesign the library: Unified interpolator (#8)

Changes:
- Integrate unified interpolator model into the main branch
- Recover tests functionality

Author: ignacio-hivemind

project/metals.sbt

@@ -1,13 +1,8 @@
 // format: off
 // DO NOT EDIT! This file is auto-generated.
 
-// This plugin enables semantic information to be produced by sbt.
-// It also adds support for debugging using the Debug Adapter Protocol
+// This file enables sbt-bloop to create bloop config files.
 
-addSbtPlugin("org.scalameta" % "sbt-metals" % "1.6.2")
-
-// This plugin adds the BSP debug capability to sbt server.
-
-addSbtPlugin("ch.epfl.scala" % "sbt-debug-adapter" % "4.2.8")
+addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "2.0.13")
 
 // format: on

src/main/scala/com/hivemind/llmsdsl/CanBeEncodedAsPrompt.scala

@@ -4,60 +4,21 @@ import cats.*
 import cats.implicits.*
 import cats.effect.*
 
-sealed trait Prompt
-case object Empty                                                                                         extends Prompt
-case object NewLine                                                                                       extends Prompt
-case class Literal private[llmsdsl] (text: String, marginChar: Option[Char])                              extends Prompt
-case class Value[A] private[llmsdsl] (value: A, validator: PromptValidator[A], encoder: PromptEncoder[A]) extends Prompt
-case class Combine private[llmsdsl] (left: Prompt, right: Prompt)                                         extends Prompt
-
-object Literal:
-  def apply(text: String): Literal                        = Literal(text, None)
-  def withMargin(text: String, char: Char = '|'): Literal = Literal(text, Some(char))
+final case class Prompt(text: String)
 
 object Prompt:
-  given monoid: Monoid[Prompt] with
-    def empty: Prompt                         = Empty
-    def combine(x: Prompt, y: Prompt): Prompt = Combine(x, y)
+  val NewLine = Prompt("\n")
+  val Empty   = Prompt("")
 
-  extension (x: Prompt)
-    // todo: consider rename to "renderUnsafe"
-    // todo: consider adding a "def render:IO[String]" after rename which does validated and render in one go
-    def render: String = x match {
-      case Literal(text, marginChar) =>
-        marginChar match {
-          case None       => text                   // Preserve original formatting
-          case Some(char) => text.stripMargin(char) // Apply margin stripping at render time
-        }
-      case _: NewLine.type           => "\n"
-      case _: Empty.type             => ""
-      case Value(value, _, encoder)  => encoder.encode(value).render
-      case Combine(left, right)      => s"${left.render}${right.render}"
-    }
+  extension (prompt: Prompt)
+    def validate(using validator: Validate)   = validator(prompt)
+    def modify(f: String => String): Prompt   = Prompt(f(prompt.text))
+    def trim: Prompt                          = modify(_.trim)
+    def stripMargin: Prompt                   = stripMargin('|')
+    def stripMargin(marginChar: Char): Prompt = modify(_.stripMargin(marginChar))
 
-    def validate(using strValidator: PromptValidator[String]): IO[Boolean] = x match {
-      case Literal(text, marginChar)        =>
-        val processedText = marginChar.fold(text)(text.stripMargin)
-        strValidator.validate(processedText)
-      case _: NewLine.type                  => IO.pure(true)             // nothing to validate
-      case _: Empty.type                    => IO.pure(true)             // nothing to validate
-      case Value(value, validator, encoder) => validator.validate(value) // validate the value
-      case Combine(left, right)             =>
-        for {
-          leftValid     <- left.validate
-          rightValid    <- right.validate
-          combined       = Combine(left, right).render
-          combinedValid <- strValidator.validate(combined)
-        } yield leftValid && rightValid && combinedValid
-    }
+  extension (prompts: Seq[Prompt]) def mkPrompt: Prompt = prompts.intercalate(Empty)
 
-    // stripMargin extension methods for Prompt
-    def stripMargin: Prompt = x match {
-      case Literal(text, _) => Literal(text, Some('|'))
-      case other            => other // No-op for non-literals
-    }
-
-    def stripMargin(marginChar: Char): Prompt = x match {
-      case Literal(text, _) => Literal(text, Some(marginChar))
-      case other            => other // No-op for non-literals
-    }
+  given Monoid[Prompt] = new Monoid[Prompt]:
+    def empty: Prompt                         = Empty
+    def combine(l: Prompt, r: Prompt): Prompt = Prompt(l.text + r.text) // only time we use .text to combine, all other times we use |+|

src/main/scala/com/hivemind/llmsdsl/Prompt.scala

@@ -3,36 +3,10 @@ package com.hivemind.llmsdsl
 case class Section(title: String, value: String)
 
 object Section:
-  def safeValidator(both: PromptValidator[String]): PromptValidator[Section] = safeValidator(both, both)
-
-  def safeValidator(titleValidator: PromptValidator[String], valueValidator: PromptValidator[String]): PromptValidator[Section] =
-    import cats.syntax.all.*
-    import cats.instances.all.*
-    import PromptValidator.contravariantSemigroupal
-    ((titleValidator, valueValidator)).contramapN((s: Section) => (s.title, s.value))
-
-  def safeEncoder(
-    combinator: (String, String) => String,
-  )(using resultEncoder: PromptEncoder[String], resultValidator: PromptValidator[String]): PromptEncoder[Section] =
-    PromptEncoder.from(section => resultEncoder.encode(combinator(section.title, section.value)))
-
   object xml:
-    val combinator: (String, String) => String =
-      (t, v) => s"<$t>$v</$t>"
-
-    def safe(using resultEncoder: PromptEncoder[String], resultValidator: PromptValidator[String]) =
-      Section.safeEncoder(combinator)
-    object unsafe:
-      given sectionEncoder: PromptEncoder[Section]     = safe(using PromptEncoder.unsafe.string, PromptValidator.accept)
-      given sectionValidator: PromptValidator[Section] = safeValidator(PromptValidator.accept[String])
+    given template: Template[Section] =
+      section => prompt"<${section.title}>${section.value}</${section.title}>"
 
   object allcaps:
-    val combinator: (String, String) => String =
-      (t, v) => s"${t.toUpperCase()}: $v"
-
-    def safe(using resultEncoder: PromptEncoder[String], resultValidator: PromptValidator[String]) =
-      Section.safeEncoder(combinator)
-
-    object unsafe:
-      given sectionEncoder: PromptEncoder[Section]     = safe(using PromptEncoder.unsafe.string, PromptValidator.accept)
-      given sectionValidator: PromptValidator[Section] = PromptValidator.accept
+    given template: Template[Section] =
+      section => prompt"${section.title.toUpperCase()}: ${section.value}"

src/main/scala/com/hivemind/llmsdsl/PromptEncoder.scala

@@ -0,0 +1,33 @@
+package com.hivemind.llmsdsl
+
+import cats.*
+import cats.implicits.*
+import cats.effect.*
+
+trait Template[A]:
+  def apply(arg: A): Prompt
+
+object Template:
+  inline def apply[A](using ev: Template[A]): Template[A] = ev
+
+  given promptTemplate: Template[Prompt]   = x => Prompt(x.text)
+  given stringTemplate: Template[String]   = x => Prompt(x)
+  given intTemplate: Template[Int]         = x => Prompt(x.toString)
+  given booleanTemplate: Template[Boolean] = x => Prompt(x.toString)
+
+  given optional[A](using template: Template[A]): Template[Option[A]] =
+    (option: Option[A]) => option.map(template.apply).getOrElse(Prompt.Empty)
+
+  given list[A](using template: Template[A]): Template[List[A]] =
+    (list: List[A]) => list.map(template.apply).mkPrompt
+
+  given ContravariantMonoidal[Template] with
+    def unit: Template[Unit] = _ => Prompt.Empty
+
+    def contramap[A, B](fa: Template[A])(f: B => A): Template[B] =
+      (b: B) => fa(f(b))
+
+    def product[A, B](fa: Template[A], fb: Template[B]): Template[(A, B)] =
+      (a, b) => fa(a) |+| fb(b)
+
+  def from[A](f: A => String): Template[A] = (a: A) => Prompt(f(a))

src/main/scala/com/hivemind/llmsdsl/PromptValidator.scala

@@ -0,0 +1,22 @@
+package com.hivemind.llmsdsl
+
+import cats.*
+import cats.implicits.*
+import cats.effect.*
+
+trait Validate:
+  def apply(p: Prompt): IO[Boolean]
+
+object Validate:
+  def accept: Validate                                 = prompt => IO.pure(true)
+  def reject: Validate                                 = prompt => IO.pure(false)
+  def from(validator: String => IO[Boolean]): Validate = prompt => validator(prompt.text)
+  def pure(validator: String => Boolean): Validate     = prompt => IO.pure(validator(prompt.text))
+
+  given Monoid[Validate] = new Monoid[Validate]:
+    def empty: Validate                                                    = _ => IO.pure(true)
+    def combine(leftValidate: Validate, rightValidate: Validate): Validate = (prompt: Prompt) =>
+      for {
+        leftResult  <- leftValidate(prompt)
+        rightResult <- rightValidate(prompt)
+      } yield leftResult && rightResult

src/main/scala/com/hivemind/llmsdsl/Section.scala

@@ -0,0 +1,72 @@
+package com.hivemind.llmsdsl.interpolator
+
+import scala.Tuple.*
+import scala.util.NotGiven
+import com.hivemind.llmsdsl.*
+import scala.annotation.implicitNotFound
+
+@implicitNotFound(
+  "No implicit instance of Template[${Arguments}] available.\n" +
+    "Make sure to provide an implicit instance of Template for every type in ${Arguments}.\n" +
+    "It will fail from left to right, starting looking for the first missing instance in the error message.",
+)
+// Filter out the values that are not templates from the hlist
+// (A0, Template[B0], A1, Template[B1], ...) => (Template[B0], Template[B1], ...)
+trait ArgumentReducer[Arguments, O]:
+  def apply(args: Arguments, lits: Seq[Prompt]): (O, Seq[Prompt])
+
+// uses + variants to filter and reduce the hlist
+object ArgumentReducer:
+  given emptyTuple: ArgumentReducer[EmptyTuple, EmptyTuple] = (args, lits) => (EmptyTuple, lits)
+
+  given singleTemplate[A]: ArgumentReducer[Template[A], Template[A]] =
+    (template, lits) => (lits.head + template, lits.tail)
+
+  given singleNonTemplate[A](using
+    notATemplate: NotGiven[A <:< Template[?]],
+    notATuple: NotGiven[A <:< Tuple],
+    template: Template[A],
+  ): ArgumentReducer[A, EmptyTuple] =
+    (args, lits) =>
+      val rendered: Prompt = template(args)
+      val newHead: Prompt  = lits.head + rendered
+      val lastLit: Prompt  = newHead + lits.tail.mkPrompt
+      (EmptyTuple, Seq(lastLit))
+
+  given recursiveTemplateHeadToSingle[H, T <: Tuple](using
+    tailReducer: ArgumentReducer[T, EmptyTuple],
+  ): ArgumentReducer[Template[H] *: T, Template[H]] =
+    (args, lits) =>
+      val (_, tailLits)         = tailReducer(args.tail, lits.tail)
+      val template: Template[H] = lits.head + args.head
+      (template, tailLits)
+
+  given recursiveTemplateHeadToTuple[H, T <: Tuple, TOut](using
+    tailReducer: ArgumentReducer[T, Template[TOut]],
+    notEmptyTuple: NotGiven[Template[TOut] =:= EmptyTuple],
+  ): ArgumentReducer[Template[H] *: T, (Template[H], Template[TOut])] =
+    (args, lits) =>
+      val (tailOut, tailLits)  = tailReducer(args.tail, lits.tail)
+      val newHead: Template[H] = lits.head + args.head
+      ((newHead, tailOut), tailLits)
+
+  given recursiveTemplateHeadPrependToTuple[H, T <: Tuple, TOut <: Tuple](using
+    tailReducer: ArgumentReducer[T, TOut],
+    notSingle: NotGiven[TOut <:< Template[?]],
+    notEmptyTuple: NotGiven[TOut =:= EmptyTuple],
+  ): ArgumentReducer[Template[H] *: T, Template[H] *: TOut] =
+    (args, lits) =>
+      val (tailOut, tailLits)   = tailReducer(args.tail, lits.tail)
+      val template: Template[H] = lits.head + args.head
+      (template *: tailOut, tailLits)
+
+  given recursiveNonTemplateHead[H, T <: Tuple, TOut](using
+    tailReducer: ArgumentReducer[T, TOut],
+    notTemplate: NotGiven[H <:< Template[?]],
+    template: Template[H],
+  ): ArgumentReducer[H *: T, TOut] =
+    (args, lits) =>
+      val rendered: Prompt         = template(args.head)
+      val combinedWithNext: Prompt = lits.head + rendered + lits.tail.head
+      val modifiedLits             = combinedWithNext +: lits.tail.tail
+      tailReducer(args.tail, modifiedLits)

src/main/scala/com/hivemind/llmsdsl/Template.scala

@@ -0,0 +1,15 @@
+package com.hivemind.llmsdsl.interpolator
+
+case class MarginStripper(marginChar: Option[Char])
+object MarginStripper extends LowPriorityMarginStripper:
+  val none = MarginStripper(Option.empty[Char])
+  val pipe = MarginStripper(Some('|'))
+  val hash = MarginStripper(Some('#'))
+  object None extends LowPriorityMarginStripper
+  object Pipe:
+    given MarginStripper = pipe
+  object Hash:
+    given MarginStripper = hash
+
+trait LowPriorityMarginStripper:
+  given MarginStripper = MarginStripper.none