I have a discriminated-union type of the form

```
type ParameterName = string
type ParameterValues =
    | String of string[]
    | Float of float[]
    | Int of int[]
type Parameter = Parameter of ParameterName * ParameterValues

```

I want to pass the ParameterValues part to a function taking generic arguments returning unit, such as 

```
let func1 (name:string) (data:'a) = printfn "%s" name

```

To deconstruct `Parameter` I could wrap `func1` like this

```
let func2 (Parameter (name, values)) =
    match values with
        | String s -> func1 name s
        | Float s -> func1 name s
        | Int s -> func1 name s

```

however this is inconvenient if I have to do this for multiple functions. Instead, I would like to define a more flexible wrapper like this:

```
let func3 (fn: ('a -> 'b -> unit)) (Parameter (name, values)) =
    match values with
        | String s -> fn name s
        | Float s -> fn name s
        | Int s -> fn name s

```

This however fails, as the type of `b` gets restricted to `string[]` in the first option of the match expression; consequently the match expression fails with the error `Type string does not match type float.`

Is this expected? How can I work around this problem?