Scala: how to upsert field value in Monocle

Question

Given the JsonExample in the monocle project, I would like to create a lens where a set call will either replace a value in a key/value pair, or create the key/value pair if it doesnt already exist.

However this seems to represented with either an index (which can compose type safe) or an at, which does not type safe

//for replacing:
(jsObject composeOptional index("age") composePrism jsNumber).set(45)

//for creating:
(jsObject composeLens at("age")).set(JsNumber(45)) <- will accept any old json

Is what I am after possible?
Also could I extend it, such that if age was nested in another JsObject, for example:

val n = (jsObject composeOptional index("nested") composePrism 
jsObject composeOptional index("age") composePrism jsNumber).set(45)

Where the key/value pair for "nested" didnt yet exist, that it would create the object at nested and then add the field

n(JsObject(Map.empty)) -> JsObject(Map("nested" -> JsObject("age" -> JsNumber(45)))

Answer 1

let's have a look at index and at signature for JsObject:

def at(field: String): Lens[JsObject, Option[Json]]
def index(field: String): Optional[JsObject, Json]

at is a Lens so its target ('Option[Json]') is always present. It means that we can add, delete and update the Json element at any field of a JsonObject.

import argonaut._, Argonaut._
import monocle.function._

(jObjectPrism composeLens at("name")).set(Some(jString("John")))(Json())
> res0: argonaut.Json = {"name":"John"}

(jObjectPrism composeLens at("name")).set(Some(jString("Robert")))(res0)
> res1: argonaut.Json = {"name":"Robert"}

(jObjectPrism composeLens at("name")).set(None)(res0)
> res2: argonaut.Json = {}

On the other hand, index is an Optional so it is target (Json) may or may not be there. It means that index can only update values but cannot add or delete.

(jObjectPrism composeLens index("name")).set(jString("Robert"))(Json())
> res3: argonaut.Json = {}

(jObjectPrism composeLens index("name")).set(jString("Robert"))(res0)
> res4: argonaut.Json = {"name":"Robert"}

So to come back to your original question, if you want to add or update value at a particular field, you need to use at and wrap the Json in a Some (see res1), it will overwrite or create the Json at that field.

Answer 2

At the moment there is very specific behaviour in the library.

When you composing Optional with some Iso or Prism it's downgrading right hand side argument to POptional and that's trouble.

Iso[A,B] and Prism[A,B] differs from Lens[A,B] and Optional[A,B] in sense that reverseGet can create element of A totally from B while set needs original value of A

So when for Optional and Lens it's totally legit that you can not modify part of the value, while not having this value in orignal Map or JsObject, for Iso and Prism you can define another behaviour.

And while waiting for the issue to be discussed, you can use following workaround

implicit class POptStrictComposition[S, T, A, B](self: POptional[S, T, A, B]) {
  def sComposePrism[C, D](other: PPrism[A, B, C, D]) = new POptional[S, T, C, D] {
    def getOrModify(s: S): T \/ C =
      self.getOrModify(s).flatMap(a => other.getOrModify(a).bimap(self.set(_)(s), identity))

    def set(d: D): S => T =
      self.set(other.reverseGet(d))

    def getOption(s: S): Option[C] =
      self.getOption(s) flatMap other.getOption

    def modifyF[F[_] : Applicative](f: C => F[D])(s: S): F[T] =
      self.modifyF(other.modifyF(f))(s)

    def modify(f: C => D): S => T =
      self.modify(other.modify(f))
  }

  def ^!<-?[C, D](o: PPrism[A, B, C, D]) = sComposePrism(o)

  def sComposeIso[C, D](other: PIso[A, B, C, D]) = sComposePrism(other.asPrism)

  def ^!<->[C, D](o: PIso[A, B, C, D]) = sComposeIso(o)
}

now you can try to change your code to

(jsObject composeOptional index("age") sComposePrism jsNumber).set(45)

and report if it helped