Remove seq_fixed_size in favor of tuple

[dtolnay]

Currently the data model uses different types for tuples like (A, B, C) and seq_fixed_size like [u64; 3]. I don't think there are any formats that treat these differently. The defining characteristic in both cases is they are heterogeneous sequences in which the length is known during deserialization without looking at the serialized data.

Let's remove seq_fixed_size and serialize fixed size arrays as tuples instead.

[dtolnay]

Fixed in #884.

[birkenfeld]

I realize this is after the fact and hard to change now, but

The defining characteristic in both cases is they are heterogeneous sequences

isn't true, and this decision has led to the unfortunate situation that &[T] is serialized differently from &[T; n]. In practice, this is mainly problematic with literals:

• b"abc" vs &b"abc"[..]
• [1, 2, 3] vs &[1, 2, 3][..]

[dtolnay]

@birkenfeld I think that statement is true. Could you clarify why you think it is not true?

In particular, the following are identical heterogeneous sequences from Serde's perspective; the first is a Rust tuple and the second is a Rust array.

let tuple: (bool, String, ()) = (true, "birkenfeld".to_owned(), ());

let array: [serde_json::Value; 3] = [json!(true), json!("birkenfeld"), json!(null)];

Keep in mind that Serde's type system is very different from Rust's type system.

Serializing &[T] differently from &[T; n] is 100% intentional and by design. For instance in Bincode the latter can be serialized without including the value of n because the deserializing end will be expected to know the type of what it is deserializing, and therefore know n without looking at the data.

[birkenfeld]

@dtolnay Thanks for the explanation! I still don't get the "heterogeneous" argument: if you put in Values, every sequence is potentially heterogeneous and there is no need to even mention that aspect.

My comment results from porting serde-pickle, where I've mapped tuples to Python tuples and sequences (fixed-size or otherwise) to Python lists. Fixed-size sequences allowed me to map them to lists as well, but now trying to serialize b"a byte string" will result in a tuple, which is not at all what would be expected on the Python side.

I'm probably stretching the serde framework with the pickle format, which is supposed to store arbitrary Python object graphs, but it is used as a serialization format containing only simple types in a lot of Python related software.

[clarfonthey]

One other thing to note is that toml can't deserialize heterogeneous tuples but it can deserialize fixed-legth sequences.