It offers special functions to more easily access deeper parts of a very nested

JsonElement

.

The API is stable, and tested.

Is there a reference for the JsonPath select syntax you're using there?

Ok, I think I got it JsonPath["..."]["..."]...

Another thing... to modify

"value"

I'd have to map my set of strings to `JsonElement`s I guess... I wouldn't be able to create a function that allows me to set the list from a collection of strings directly?

It currently it's possible to escape

.

, but that is something we could quite easily add. We can parameterise splitting on a parameterised

Char

rather than hardcoding

.

Otherwise using

[][]

can currently be used as a workaround. Feel free to open a issue, and I'll try to get to is asap ☺️ A PR fixing it is of course also very welcomed. The codebase is quite small, so it's less intimidating to approach than Arrow itself.

Would give a good excuse to bump to 1.0.0 I guess 😄

Not sure how to do that conveniently

JsonPath["some.key"]["other-key"].jsonArray().modify(jsonElem) {
  listOf(JsString("other-value"))
}

this definitely works

Not sure if it'd be easy to make that better, since JsonArray can contain JsElement of different types

Maybe Gradle 8 changed something for KMM projects?

I wanted to give a PR a shot... but with my little knowledge of optics (I was hoping to learn more about optics along the way...), and no code navigation... I guess I'll wait until there's a solution for this...

I currently don't have time to investigate this

@simon.vergauwen Can regular optics be combined with that libraries optics?

@JvmInline
value class Bar(val json: JsonObject) {
  companion object {
     val path = JsonPath....
  }
}

@optics data class Foo(val bar: Bar)

foo.copy { Foo.Bar.path set ... }

Not sure if

+

is still available as alias for

compose

.

None of the following functions can be called with the arguments supplied. compose(Fold<in CustomRestrictions, out TypeVariable(C)>) where C = TypeVariable(C) for fun <C> compose(other: Fold<in CustomRestrictions, out C>): Fold<RestrictionAction, C> defined in arrow.optics.POptional compose(PEvery<in CustomRestrictions, out CustomRestrictions, out TypeVariable(C), in TypeVariable(D)>) where C = TypeVariable(C), D = TypeVariable(D) for fun <C, D> compose(other: PEvery<in CustomRestrictions, out CustomRestrictions, out C, in D>): PEvery<RestrictionAction, RestrictionAction, C, D> defined in arrow.optics.POptional compose(POptional<in CustomRestrictions, out CustomRestrictions, out TypeVariable(C), in TypeVariable(D)>) where C = TypeVariable(C), D = TypeVariable(D) for infix fun <C, D> compose(other: POptional<in CustomRestrictions, out CustomRestrictions, out C, in D>): POptional<RestrictionAction, RestrictionAction, C, D> defined in arrow.optics.POptional compose(POptionalGetter<in CustomRestrictions, RestrictionAction, out TypeVariable(C)>) where C = TypeVariable(C) for fun <C> compose(other: POptionalGetter<in CustomRestrictions, RestrictionAction, out C>): POptionalGetter<RestrictionAction, RestrictionAction, C> defined in arrow.optics.POptional compose(PSetter<in CustomRestrictions, out CustomRestrictions, out TypeVariable(C), in TypeVariable(D)>) where C = TypeVariable(C), D = TypeVariable(D) for fun <C, D> compose(other: PSetter<in CustomRestrictions, out CustomRestrictions, out C, in D>): PSetter<RestrictionAction, RestrictionAction, C, D> defined in arrow.optics.POptional compose(PTraversal<in CustomRestrictions, out CustomRestrictions, out TypeVariable(C), in TypeVariable(D)>) where C = TypeVariable(C), D = TypeVariable(D) for fun <C, D> compose(other: PTraversal<in CustomRestrictions, out CustomRestrictions, out C, in D>): PTraversal<RestrictionAction, RestrictionAction, C, D> defined in arrow.optics.POptional

Ohh... the value class.

It should have been Optional<Bar, List<JsonElement>>

But how do I adapt that? value classes can't have optics.

And it's a bit overkill.

So I could also make such an Iso for my previous List<JsonElement> to List<String>, no?

TL;DR it will requires an unsafe cast, which violates the type system but yes anything is possible in code 😄

If there would be a way to implement only reverseGet and just use the setter part of optics for such cases.

Or alternatively, even possibly have some kind of Either to return for the get case which would just return Left if the cast wasn't successful

But I guess that would make things much more complex

You can still compose

.every

after you go from

List<JsonElement>

to

List<String>

though, and it should be possible to write a Prism for that

Something like val baz = Optional<Bar, List<String>>

that allows

baz.set(bar, listOf("one", "two"))

But whatever gives that set(...)

Maybe I'm mixing up Optional here... but there IS getOption on Prism... 🤔, Maybe I'm not doing this correctly? Or maybe the better practice would be the Either alternative...?

Couldn't I have just used Optional instead of Prism in the same way?

Or would that be abusing Optional...