Explicit typing for context functions

[Adam-Vandervorst]

I wrote some helper functions like

def li(init: dom.html.LI ?=> Unit)(using l: dom.html.OList | dom.html.UList): dom.html.LI =
  given i: dom.html.LI = dom.document.createElement("li").asInstanceOf[dom.html.LI]
  init
  l.appendChild(i)
  i

to allow for a builder pattern approach to Scala.js dom

  ol {
    li { N"f"; cls("atom") }
    ol {
      li { N"p" }
      li { N"a" }
    }
    ol {
      li { N"p" }
      li { N"b" }
    }
  }

To avoid the repetition for each element, I thought about writing

def spawn(tag: String)(init: TagOf[tag.type] ?=> Unit): ParentsOf[tag.type] ?=> TagOf[tag.type] =
  (p: ParentsOf[tag.type]) ?=>
    val e = createElement(tag)
    init(using e)
    p.appendChild(e)
    e

to be used as

val li = spawn("li")

given

type ParentsOf[X <: String] <: dom.html.Element = X match
  case "li" => dom.html.UList | dom.html.OList | dom.html.Menu
  ...

and

type TagOf[X <: String] <: dom.html.Element = X match
  case "li" => dom.html.LI
  ...

However, this context is tried to be resolved immediately, requiring the explicit annotation:

val li: <full type> = spawn("li")

which ultimately doesn't abstract away that much.

Is there some way to prevent this?

For ADT's I use a helper like

extension [X](x: X)
  def specific: x.type = x

that avoids widening a case to the enum, maybe something similar can be used here?

[Adam-Vandervorst]

Moving away from the partial function solved this...

def spawn(tag: String) =
  (init: TagOf[tag.type] ?=> Unit) => (p: ParentsOf[tag.type]) ?=>
    val e = createElement(tag)
    init(using e)
    p.appendChild(e)
    e