Named tuples JSON example?

[3xau1o]

Ideas on how to map back and forth JSON and scala 3.5 named tuples

[Quafadas]

@utenma I'm also curious about this - did you invest any time in it?

I think it should be possible to simply write a custom pickler for some particular named tuple, however, what would be ideal I guess, would be automatic derivation.

I suspect that is a lot harder, particularly if upickle wants to maintain compatibility with earlier scala releases?

If a maintainer were to read this and there is an obvious solution sketch, I'd be willing to try and follow the breadcrumbs...

[Quafadas]

Here's a solution sketch and the scastie.

https://scastie.scala-lang.org/Zr8hawupQsqr7C97Wr14pQ

import scala.language.experimental.namedTuples
import scala.NamedTuple.NamedTuple
import upickle.default.*
import ujson.Value

object Test:
  inline given [N <: Tuple, V <: Tuple, T <: NamedTuple[N, V]]: ReadWriter[T] =
    val names = scala.compiletime.constValueTuple[N].toList.asInstanceOf[List[String]]
    val readWriters = scala.compiletime.summonAll[Tuple.Map[V, ReadWriter]].toList.asInstanceOf[List[ReadWriter[?]]]

    def toMap(t: T): Map[String, Value] =
      val values = t.toTuple.productIterator.toList
      (0 until names.length).foldLeft(Map.empty[String, Value]): (map, i) =>
        val readWriter = readWriters(i).asInstanceOf[ReadWriter[Any]]
        map + (names(i) -> transform(values(i))(using readWriter).to(ujson.Value))


    def fromMap(map: Map[String, Value]): T =
      val namesAndRWs = names.zip(readWriters)
      val valueList = namesAndRWs.map: (name, rw) =>
        map.get(name) match
          case None => throw new Exception(s"Missing field: $name")
          case Some(v) =>
            read(v)(using rw.asInstanceOf[ReadWriter[Any]])

      val tuple = valueList.foldRight(EmptyTuple: Tuple): (v, tuple) =>
        v *: tuple

      tuple.asInstanceOf[T]

    summon[ReadWriter[Map[String, Value]]].bimap(toMap, fromMap)

type Person = (name: String, age: Int)
type book = (name: String, author: String)


import Test.given

val bookyPerson = (
  name = "simon",
  age = 40, 
  books = List(
    (name = "mistborn", author= "sanderson"),
    (name = "lotr", author = "tolkein")
  )
)

println(write(bookyPerson))

println(write((name = "Bob", age = 40)))             // {"name":"Bob","age":40}



println(read[Person]("""{"name":"Bob","age":40}""")) // (Bob, 40)

credit to those behind the discord names Fehler and arainko

[SethTisue]

thanks @arainko and @felher

[Quafadas]

Huh, they didn't come up as @ able for me, thanks :-).

[Quafadas]

Here's a shape which breaks it.

  val hmmm = List(
    (
      title = s"n"
    ),
    (
      title = "point",
      argy = 1
    )
  )

[Quafadas]

@lihaoyi Apologies to bother - I've posted a sketch of something that seems to work in a basic sort of way for named tuples above.

Is there value in attempting to PR it into the mainline?

I assume there are problems, it wouldn't compile with earlier versions of scala 3 for example, so I'm not anticipating this to be super simple. 3.6.1+ I think. I'm not what a good solution to that looks like? Publishing a separate artefact?

If you think it has value, I would be willing to give it a go. Otherwise it can exist as a local solution.

[lihaoyi]

We can put it in an optional submodule that only supports 3.6

[lihaoyi]

Feel free to open a PR

[Quafadas]

@lihaoyi I spent a little time playing with this PR #641 ; my conclusion, is that this is not worthwhile.

I don't think we can "switch scala versions" on mill module dependancies. i.e. ModuleA(scalaversion="3.3.4") cannot be a moduleDep of ModuleB(scalaversion="3.6.1"). Or at least, that didn't work for me.

I can get it to work, if I make the named tuple module depend on a published upickle artefact. I'm not aware of a way to make that build sensible / maintainable. That could be, because I'm not aware of it, but I don't see the benefit outweighing the pain right now.

Unless you tell me I've missed something, I'm going to close that PR unfinished. The code here is easy to copy paste into userland, if someone needs it. Once a new scala LTS series is declared, where the LTS is > 3.6.x, I think this could be revisited.

[3xau1o]

@Quafadas, late answer but got this fragment from scala forum similar to the one posted above

inline def pairs[N <: Tuple, V <: Tuple](nt: NamedTuple[N, V]): Unit =
  val names = constValueTuple[N]
  names.zip(nt.toTuple).toList.foreach(println)

scala> pairs((x = 3, y = 7))
(x,3)
(y,7)