Общие случаи в F # предвзято профсоюзы

Question

я хочу написать что-то вроде этого:

type NumExp = Num of float 

type Exp = 
    | Num of float 
    | Dot of NumExp * NumExp 
    | Op of string * Exp * Exp 

let getValue (Num(n) : NumExp) = n 

Компилятор жалуется на конфликт между NumExp и Exp в getValue. Даже следующий сбой:

let getValue (nn : NumExp) = match nn with | Num(n) -> n 

Есть ли способ, чтобы использовать один и тот же случай в обеих дискриминационных союзах, который работает с функциями? Определения DU сами в порядке.

Я хочу использовать тот же случай, чтобы избежать добавления уровня косвенности как

type Exp = 
    | NumExpExp of NumExp 
    | Dot of NumExp * NumExp 
    | Op of string * Exp * Exp 

в Exp определения. Я чувствую, что мне не хватает чего-то очень элементарного здесь.

Причина у меня есть NumExp, что я хочу, чтобы иметь возможность «штекер» 2 Exp s в Dot (а не 2 поплавков), потому что это делает генерацию выражения проще, но они не могут быть любой Exp, просто числовой ,

EDIT: то, что я действительно хотел бы знать, является ли эти два случая в двух ПН можно рассматривать как тот же объект (вроде как Exp «включая» NumExp). Я понимаю, что Exp.Num и NumExp.Num являются полностью отдельными объектами. Томас обеспечивает хороший способ различать два случая ниже.

Answer 1

Если у вас есть два дискриминируемых объединения с конфликтующими именами случаев, вы можете использовать полное имя в дискриминационный накидной случае:

let getValue (NumExp.Num(n)) = n 

Более полный пример будет выглядеть следующим образом:

let rec eval = function 
    | Exp.Num(f) -> f 
    | Exp.Dot(NumExp.Num(f1), NumExp.Num(f2)) -> 
     // whatever 'dot' represents 
    | Exp.Op(op, e1, e2) -> 
     // operator 

Это всегда использует полностью квалифицированные имена, что, вероятно, является хорошей идеей, если имена достаточно просты и существуют противоречивые случаи (что может привести к путанице).

EDIT: Что касается разделения случаев - нет автоматического способа сделать это, но вы могли бы иметь дело в вашем Exp, который просто включает в себя значения NumExp. Например, как это:

type NumExp = 
    | Num of float 

type Exp = 
    // first occurrence of NumExp is just a name, but F# allows us to reuse 
    // the name of the type, so we do that (you could use other name) 
    | NumExp of NumExp 
    // other cases 

При написании eval функции вы бы тогда писать (заметим, что мы больше не имеют проблемы с именем столкновений, поэтому нам не нужно полностью квалифицированные имена):

| NumExp(Num f) -> f 
| Op(op, e1, e2) -> // ... 

Answer 2

Просто наблюдение: зачем вам профсоюзы, построенные таким образом?

я выбрал бы один из двух вариантов:

type NumExp = Num of float 

type Exp = 
    | Num of float 
    | Dot of float * float 
    | Op of string * Exp * Exp 

который является более простым, или

type NumExp = Num of float 

type Exp = 
    | NumExp 
    | Dot of float * float 
    | Op of string * Exp * Exp 

В этом втором случае ваша функция

let getValue (Num(n) : NumExp) = n 

работы, как у вас есть одно определение NumExp.

Answer 3

Если это возможно (например, с использованием полиморфных вариантов в OCaml), вы можете много сделать с ним, но (к сожалению) F # не имеет этой языковой функции, поэтому в настоящее время она неспособна выразить то, что вы хотите, используя типы union. Однако вы можете использовать OOP вместо этого ...

Answer 4

Вы можете использовать interfaces as a substitute. Это добавляет немного синтаксических накладных расходов, но это лучший способ, который я нашел для этого.

type IExp = interface end 

type NumExp = 
     | Num of float 
     interface IExp 
type Exp = 
     | Dot of NumExp * NumExp 
     | Op of string * IExp * IExp 
     interface IExp 

// This function accepts both NumExp and Exp 
let f (x:IExp) = match x with 
    | :? NumExp as e -> match e with 
     | Num v -> "Num" 
    | :? Exp as e -> match e with 
     | Dot (e1,e2) -> "Dot" 
     | Op (op,e1,e2) -> "Op" 
    | _ -> invalidArg "x" "Unsupported expression type" 

// This function accepts only NumExp 
let g = function 
    | Num v -> "Num"