But I think this is really not possible. The type ?? is int32 or float32 or float.

There is no generic type.

It sounds like you may be trying to do is something that F# works very hard to prevent: storing and accessing data in an unconstrained polymorphic, but ultimately non-deterministically way.

F# containers by design only hold a single, constrained, monomorphic type of data. The idea is that rather than storing something of type "Object", one should rather define a specific set of types that the container can hold. In this way, the compiler can statically type check the container and help prevent one type of runtime error.

One could, for example, force a container to hold values of the Object type. In this case, one could put anything at all in the container, including boxed primitives such as an arbitrary mix of ints, float32, and doubles. However, the code would then need to attempt to determine the actual element types at run time, and every such case would also need to remember to handle exceptions when an unexpected type is encountered. Bear in mind that nothing would prevent one from adding, say, a string to such a container that normally expects numbers. Take the following example, which throws an exception at runtime:

1
2
3
4
5
6
7
8
9
10
11
12
13

#light
module badcode =

    let dump xs =
        let aux (x:obj) =
            match x with
            | :? int32 as x -> printfn "%i" x
            | :? float32 as i -> printfn "%f" i
            | :? double as d -> printfn "%f" d
            | _ -> failwithf "Unexpected type %s" ( x.GetType().ToString() )
        List.iter aux xs

    dump [ (1 :> obj); (3.1415f :> obj); (1.234 :> obj); ("abc" :> obj) ]

On the other hand, idiomatic F# code constrains the values in a container to a specific, and very deterministic set of types. Because of this, the compiler can flag cases where the code is not handling every potential type of data or, conversely, prevent addition of unacceptable types to such a container to begin with. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#light
module safecode =

    type Number =
        | Int of int
        | Float of float32
        | Double of double

    let incompleteDump xs =
        let aux = function
//                ^^^^^^^^
//--> warning FS0025: Incomplete pattern matches on this expression. For example, the value 'Double (_)' will not be matched
            | Int(x)    -> printfn "%i" x
            | Float(f)  -> printfn "%f" f
        List.iter aux xs

    let dump xs =
        let aux = function
            | Int(x)    -> printfn "%i" x
            | Float(f)  -> printfn "%f" f
            | Double(d) -> printfn "%f" d
        List.iter aux xs 

    dump [ Int(1); Float(3.1415f); Double(1.234); "Abc" ]
//                                                ^^^^^
//--> error FS0001: This expression has type 'string' but is here used with type 'Number'

Therefore, the type system, language, and compiler conspire together to drive your code towards correctness. As an added benefit, the compiler can often infer types more easily. For example, the type passed to "aux" can be inferred.

my naive attempt :

1
2
3
4
5
6
7

type number =
  |Nat of int32
  |Real of float32
  
type my_data =
  { data: number[]; dims: int list;status: int}