Failure to parse Array of Tuples of Tuples

[z0isch]

I think I have found a bug in encoding/decoding things of this shape:

Array (Tuple (Tuple Int Int) Int)

Running this program:

type A = Array (Tuple (Tuple Int Int) Int)
a = [Tuple (Tuple 1 2) 3]
main = log $ stringify $ encodeJson a

returns the string [[1,2,3]] which I believe should be [[[1,2],3]]

There seems to also be an error when decoding:

type A = Array (Tuple (Tuple String Unit) Unit)
a = "[[[1,2],3]]"
main = logShow $ (jsonParser (stringify $ encodeJson a) >>= decodeJson) :: Either String A

which gives (Left "Generic json decoding failed: Expected an array: '\"[[[1,2],3]]\"'")

I'm trying to decode values from Haskell that look like [((Int,Int), Int)] but maybe Array (Tuple (Tuple Int Int) Int) isn't the correct PureScript representation.

[eskimor]

Oh my. The behaviour is actually as desired. Because There are only pairs in PureScript and triples are encoded like you did above. If you actually have a nested tuple on the Haskell side, this of course is a problem. I believe the correct way of dealing with this would be to allow the encoding [1,2,3] for nested a Haskell triples as well.

[eskimor]

So that at decoding [[1,2],3] and [1,2,3] are treated equally. I am pretty busy as usual, but I would gladly merge a PR implementing this behaviour.

[z0isch]

Good point, although for my use case I would still need the encoded version from Purescript to be [[1,2],3] so that the Haskell would be decoded correctly. It seems to me like the types just really aren't compatible enough for using nested tuples from Haskell. If you really want the behavior described above, I could try to put something together, but I don't know that it will really help for my use case.

[eskimor]

Gosh! You are right of course, the changed decoding does not change the Haskell decoding. A solution could be to add a separate Tuple type on the PS side, which has the desired encoding. I will think about it a bit more, maybe I'll find a better solution.

Another solution for your problem of course could be, to simply not using a nested tuple but a flattened tuple on the Haskell side, if this is an option.