F# Using Discrimated Union Types

Question

I want to return a discriminated union type from a function - it conflicts with type inference - how should I change my code so that getKeyA returning KeyA gets changed into Key?

      type KeyA = {keyString:string}
type KeyB = {keyInt:int}
type Key = KeyA | KeyB

let getKeyA id =
         {keyString="123"}
let getKeyB id = 
         {keyInt=2}

let getKey (id) :Key = 
     match id with 
      | 1 -> getKeyA id 
      | _ -> getKeyB id

can you give the type and it's definition of `id`? What are the `getKeyA` and `getKeyB` functions (their types)? — Carsten, Mar 18 '15 at 10:08
ok thanks - I think I know what you are trying - can you give the type of `id` as well? What is `id.type`? — Carsten, Mar 18 '15 at 10:13
try my answer - I guess you want `Key` to carry information about either `KeyA` or `KeyB` and you can do this. — Carsten, Mar 18 '15 at 10:15

Carsten · Accepted Answer · 2015-03-18T10:17:35.740

To make this short: I don't know the definitions of most parts you gave but to return something of type Key you have to use KeyA or KeyB in your example here.

Try this:

type Key = KeyA of KeyA | KeyB of KeyB

let getKey id : Key = 
    match id with 
    | 1 -> KeyA (getKeyA id)
    | _ -> KeyB (getKeyB id)

or maybe this looks better for you

type KeyA = {keyString:string}
type KeyB = {keyInt:int}
type Key = KeyA of KeyA | KeyB of KeyB

let getKeyA id =
    { keyString="123" }
    |> KeyA

let getKeyB id = 
    { keyInt=2 }
    |> KeyB

let getKey id : Key = 
     match id with 
      | 1 -> getKeyA id 
      | _ -> getKeyB id

You might notice that you only wrap a string or an int into a record - if it's really only one type/value or if you can live with tuples I would strip the additional record:

type Key = KeyA of string | KeyB of int

let getKeyA id = KeyA "123"

let getKeyB id = KeyB 2

let getKey id : Key = 
     match id with 
      | 1 -> getKeyA id 
      | _ -> getKeyB id

F# Using Discrimated Union Types

1 Answers1