Maybe we can have a function that returns possibly multiple types, what do you think no

[Xyncgas]

Our program is powering the real world machines that's processing fruits, depending on what you want, it either gives you meat or juice.

A program is like a function, in which you ask it to do something then it gives you a result, irl the result is usually multiple types.

You can say that it's all the 0 and 1 and sort of the same, you can say that regardless of whether a function returning an integer or a string it's gonna be treated the same as paints on the GUI, however for the better of living in an imaginary world we think meat and juice is different thing.

we can prove they are different :

type Fruit =
| Meat
| Juice

let ProcessFruit want =
    match want with
    | Meat _ -> 0
    | Juice _ -> "drip"

ProcessFruit Meat |> printfn "%d"
ProcessFruit Juice |> printfn "%d" //this shouldn't compile because we can see it returns a string instead of integer

we can prove that the function returns a string when the type of the argument 'want' is known at the call site at compile time, you can't use this function without saying if you want meat or juice

[Happypig375]

Are you referring to having ProcessFruit as Fruit -> (int|string)? That's #538

[Xyncgas]

yes

[Xyncgas]

I just want to clarify that I came up with this idea independently

[Xyncgas]

In other worlds, you can specialize the function with type parameter therefore the template produce different functions that returns different things

[kerams]

we can prove that the function returns a string when the type of the argument 'want' is known at the call site at compile time

In other words, only when you use a DU case constructor - basically a constant. At that point you might as well create processMeat and processJuice, and call those as necessary.

[kerams]

type Fruit =
    | Meat
    | Juice

let processMeat () = 0
let processJuice () = "drip"

let ProcessFruit want =
    match want with
    | Meat _ -> processMeat ()
    | Juice _ -> processJuice ()

// this can't work
let process fruit = ProcessFruit fruit

let meat = Meat
let integer = ProcessFruit meat
// that could work, but you too do know the fruit type (because you have just created it above), so why not call processMeat directly
let integer = processMeat ()

[Xyncgas]

I want the compiler to do that for me

[Xyncgas]

Perhaps casting it into object is acceptable.. maybe in the end that's the solution that people had the foresight back in the day