Совместные дела в 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с в Dot (а не 2 с плавающей запятой), потому что это облегчает генерацию выражений, но они не могут быть Exp, просто численное.

РЕДАКТИРОВАТЬ: то, что я действительно хотел знать, можно ли рассматривать два случая в двух ОУ как один и тот же объект (вроде как 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

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

РЕДАКТИРОВАТЬ: Что касается совместного использования дел - нет автоматического способа сделать это, но вы могли бы иметь дело в вашем 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 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"

Answer 3

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

Answer 4

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

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

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 сейчас.