F# Concat two tuples without deconstructing - f#

Question

I have two tuples of unknown length which I would like to add together resulting in a third tuple.
For example:
// given two tuples
let tuple1 = (1, 2)
let tuple2 = (3, 4, 5)
// resulting in
let tuple3 = (1, 2, 3, 4, 5)
A solution I came up with was to deconstruct both tuples first and then create a new tuple like this:
let a b = tuple1
let c d e = tuple2
let tuple4 = (a, b, c, d, e)
However this will not work with a tuple of unkown length.
Another solution solution could be:
let tuple5 = tuple1, tuple2
But this results in a tuple of two tuples like this:
(int * int) * (int * int * int)
Is there a tuple function I'm missing? Is there anything else I'm overlooking? Thanks.

Answer 1

The design of F# tuples means that you need to write code that knows the length of a tuple - tuples of different lengths have different types and you cannot write code that's generic over the length of a tuple.
If you want a data structure that allows you to store arbitrary number of values and concatenate them, it is probably better to use lists, which allow concatentation using the # operator:
let list1 = [1; 2]
let list2 = [3; 4; 5]
let list3 = list1 # list2
The caveat is that lists can only store values of one type - such as int in your example. If you need to store arbitrary number of arbitrary things, you will probably need a list of discriminated unions.

Answer 2

The explanation is that tuples are not meant to be used as lists (which may have unknown length). Think of tuples instead as very simple structs or classes where the members are implicitly named "first", "second", "third", etc. So your question is like answering "how do I concat the members of two structs"? The answer could be reflection but most likely hints at some problem when modelling the data types for your program.
Typical use cases for tuples are very simple ad-hoc data types or other cases where the length and the order of the members are natural. For example:
type Point2D = float * float
type Point3D = float * float * float
type Size = int * int
type Error = int * string

Answer 3

This is not an answer, since it only demonstrates the futility of attempting to work around F# type system for tuples. But technically, it is indeed possible to combine tuples of various lengths with a generic function, which could consume its arguments in a type-safe way; alas, it will possess an unspecified return type that requires annotation. This is done by employing two features that, rightly so, do not figure prominently in functional programming:
Method overload resolution, in combination with statically resolved type parameters, for the domain
Reflection for the range
There are a couple of other limitations: We are not able to encode the 1-tuple, such an overload cannot uniquely be resolved since it may stand for an n-tuple in turn. A similar reason precludes the use of two tupled tuples of varying lengths as direct argument for the static members.
type X = X with
static member ($) (_ : X, (a, b)) = [|box a; box b|]
static member ($) (_ : X, (a, b, c)) = [|box a; box b; box c|]
let inline t2a x = X $ x
open Microsoft.FSharp.Reflection
let a2t arg : 'r =
FSharpValue.MakeTuple(arg, typeof<'r>) :?> 'r
let inline (##) a b =
Array.append (t2a a) (t2a b) |> a2t
let (t : int * char * int64 * string) = (1, 'b') ## (3L, "d")
// val t : int * char * int64 * string = (1, 'b', 3L, "d")
let (u : int * int * int * int * int) = (1, 2, 3) ## (4, 5)
// val u : int * int * int * int * int = (1, 2, 3, 4, 5)
Given the above, the concatenation of a 4-tuple with a 2-tuple will produce a compile-time error.
let (v : int * int * int * int * int * int) = (1, 2, 3, 4) ## (5, 6)
// error FS0001: No overloads match for method 'op_Dollar'.