[xml] Allow target type to influence XmlFactory implicit search

Author: rayrobdod

XmlParser/src/main/scala/XmlFactory.scala

@@ -18,7 +18,7 @@ package name.rayrobdod.stringContextParserCombinatorExample.xml
  *  - literal
  *  - interpolation
  */
-trait XmlFactory
+trait XmlFactory[Z]
 
 object XmlFactory:
 	/** An `XmlFactory.entities` implementation that handles only the predefined entities */
@@ -29,7 +29,7 @@ object XmlFactory:
 		val quot:A = fn('"')
 		val apos:A = fn('\'')
 
-	given default:XmlFactory with
+	given default:XmlFactory[scala.xml.NodeSeq] with
 		import scala.language.dynamics
 		enum IEitherPrefixUri:
 			case PrefixOnly(prefix:String)

XmlParser/src/main/scala/XmlParser.scala

@@ -126,7 +126,7 @@ private[xml] object XmlParser {
 		)
 	}
 
-	private def interpolation(factory: Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def interpolation(factory: Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		import quotes.reflect._
 		ofType[Any]
 			.map({(value) =>
@@ -140,7 +140,7 @@ private[xml] object XmlParser {
 			})
 	}
 
-	private def attribute(factory:Expr[XmlFactory])(using Quotes):Interpolator[Attribute] = {
+	private def attribute(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[Attribute] = {
 		def valueText(excluding:Char) = (charRef <|> xmlAllowedChar("<&" + excluding)).repeat(1)
 			.map({data =>
 				import quotes.reflect._
@@ -161,7 +161,7 @@ private[xml] object XmlParser {
 			.map((k,v) => Attribute(k, v.map(_.asExpr)))
 	}
 
-	private def cdata(factory:Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def cdata(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		given typeclass.Eithered[CodePoint, String, String] with
 			def left(elem:CodePoint):String = elem.toString
 			def right(elem:String):String = elem
@@ -185,7 +185,7 @@ private[xml] object XmlParser {
 			})
 	}
 
-	private def entity(factory:Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def entity(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		(isString("&") ~> xmlName <~ isString(";"))
 			.map({name =>
 				import quotes.reflect._
@@ -196,7 +196,7 @@ private[xml] object XmlParser {
 			.attempt
 	}
 
-	private def text(factory:Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def text(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		(charRef <|> xmlAllowedChar("<&")).repeat(1)
 			.map({data =>
 				import quotes.reflect._
@@ -206,7 +206,7 @@ private[xml] object XmlParser {
 			})
 	}
 
-	private def comment(factory:Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def comment(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		(
 			isString("<!--")
 			~> (
@@ -223,7 +223,7 @@ private[xml] object XmlParser {
 			})
 	}
 
-	private def processingInstruction(factory:Expr[XmlFactory])(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def processingInstruction(factory:Expr[XmlFactory[_]])(using Quotes):Interpolator[quotes.reflect.Term] = {
 		(
 			isString("<?")
 			~> xmlName.filter(_ != "xml", "not `xml`")
@@ -242,7 +242,7 @@ private[xml] object XmlParser {
 			})
 	}
 
-	private def fragment(factory:Expr[XmlFactory], nsb: NamespaceBinding)(using Quotes):Interpolator[List[quotes.reflect.Term]] = {
+	private def fragment(factory:Expr[XmlFactory[_]], nsb: NamespaceBinding)(using Quotes):Interpolator[List[quotes.reflect.Term]] = {
 		(
 			interpolation(factory) <|>
 			entity(factory) <|>
@@ -254,7 +254,7 @@ private[xml] object XmlParser {
 		).repeat()
 	}
 
-	private def elem(factory:Expr[XmlFactory], nsb:NamespaceBinding)(using Quotes):Interpolator[quotes.reflect.Term] = {
+	private def elem(factory:Expr[XmlFactory[_]], nsb:NamespaceBinding)(using Quotes):Interpolator[quotes.reflect.Term] = {
 		import quotes.reflect._
 		(
 			isString("<") ~>
@@ -341,7 +341,7 @@ private[xml] object XmlParser {
 	}
 
 
-	def interpolate(sc:Expr[scala.StringContext], args:Expr[Seq[Any]], factory:Expr[XmlFactory])(using Quotes):Expr[Any] = {
+	def interpolate[Z](sc:Expr[scala.StringContext], args:Expr[Seq[Any]], factory:Expr[XmlFactory[Z]])(using Type[Z], Quotes):Expr[Z] = {
 		import quotes.reflect.*
 		val (factoryExpr, factoryType) = factory match {case '{ $x: t } => ((x, Type.of[t])) }
 
@@ -355,7 +355,7 @@ private[xml] object XmlParser {
 			.selectAndApplyToArgsMaybeDynamicMaybeVarargs
 				("literal")
 				((fragment(factoryExpr, initialNsb) <~> end).interpolate(sc, args))
-			.asExpr
+			.asExprOf[Z]
 	}
 
 	def classSymbolThatDoesntResultInBadSymbolicReferenceWhenLookingForAnObjectContainedClass(name:String)(using Quotes):quotes.reflect.Symbol = {

XmlParser/src/main/scala/package.scala

@@ -1,5 +1,5 @@
 package name.rayrobdod.stringContextParserCombinatorExample.xml
 
 extension (inline sc:scala.StringContext)
-	transparent inline def xml(inline args:Any*)(using factory:XmlFactory):Any =
+	transparent inline def xml[Z](inline args:Any*)(using factory:XmlFactory[Z]):Z =
 		${XmlParser.interpolate('sc, 'args, 'factory)}

XmlParser/src/test/scala/MinixmlFactoryTest.scala

@@ -10,7 +10,7 @@ package minixml:
 	final case class Text(content:String) extends Node
 	final case class Elem(name:QName, attrs: Map[QName, String], childs: Seq[Node]) extends Node
 
-object MinixmlFactory extends XmlFactory:
+object MinixmlFactory extends XmlFactory[minixml.Elem]:
 	import minixml.*
 
 	inline def literal(arg:Any):arg.type = arg

XmlParser/src/test/scala/OpmlXmlFactoryTest.scala

@@ -39,7 +39,7 @@ package Opml:
 	case class OutlineTag(text:String, typ:Option[String], children: Seq[OutlineTag])
 
 
-object OpmlXmlFactory extends XmlFactory:
+object OpmlXmlFactory extends XmlFactory[Any]:
 	import Opml.*
 	import scala.language.dynamics
 

XmlParser/src/test/scala/TargetTypingTest.scala

@@ -0,0 +1,18 @@
+package name.rayrobdod.stringContextParserCombinatorExample.xml
+
+final class TargetTypingTest extends munit.FunSuite:
+	given xml: MinixmlFactory.type = MinixmlFactory
+
+	test ("finds MinixmlFactory for target type minixml.Elem") {
+		val actual: minixml.Elem = xml"<tag-name/>"
+		import minixml.*
+		val expected = Elem(QName("", "tag-name"), Map.empty, Seq.empty)
+		assertEquals(actual, expected)
+	}
+
+	test ("finds XmlFactory.default for target type scala.xml.NodeSeq") {
+		val actual: scala.xml.NodeSeq = xml"<tag-name/>"
+		import scala.xml.*
+		val expected = Elem(null, "tag-name", Null, TopScope, true)
+		assertEquals(actual, expected)
+	}