Согласование образцов на общем контейнере Дискриминационного союза

Ответ 1

Кажется, что это работает:

let format x =
    match x.Item with
    | CaseA r  ->             
        let v = mapEnvelope (fun _ -> r) x 
        sprintf "%O: %s: %O" v.Id v.Item.Text v.Item.Number
    | CaseB r  -> 
        let v = mapEnvelope (fun _ -> r) x 
        sprintf "%O: %s: %O" v.Id v.Item.Text v.Item.Version

Возможно, я не полностью понял ваш вопрос, но если вам нужно в конце концов вызвать функцию с Envelope< RecA> , вы можете с тех пор, что v содержит.

UPDATE

Вот некоторые мысли, поняв, что это была ваша первая попытка.

В идеале вы сможете использовать синтаксис записи следующим образом:

let v = {x with Item = r}

к сожалению, он не будет компилироваться, потому что общий параметр имеет другой тип.

Однако вы можете имитировать эти выражения с именованными аргументами и играть с перегрузками, вы можете заставить компилятор решить конечный тип:

#nowarn "0049"
open System

type Envelope<'a> = 
    {Id :Guid; ConversationId :Guid; Created :DateTimeOffset; Item :'a}
    with
    member this.CloneWith(?Id, ?ConversationId, ?Created, ?Item) = {
            Id = defaultArg Id this.Id
            ConversationId = defaultArg ConversationId this.ConversationId
            Created = defaultArg Created this.Created
            Item = defaultArg Item this.Item}

    member this.CloneWith(Item, ?Id, ?ConversationId, ?Created) = {
            Id = defaultArg Id this.Id
            ConversationId = defaultArg ConversationId this.ConversationId
            Created = defaultArg Created this.Created
            Item = Item}

type RecA = { Text : string; Number : int }
type RecB = { Text : string; Version : Version }
type MyDU = | CaseA of RecA | CaseB of RecB

Теперь вы можете клонировать аналогичный синтаксис и в конечном итоге изменять общий тип

let x = {
    Id = Guid.NewGuid()
    ConversationId = Guid.NewGuid()
    Created = DateTimeOffset.Now
    Item = CaseA  { Text = "";  Number = 0 }}

let a = x.CloneWith(Id = Guid.NewGuid())
let b = x.CloneWith(Id = Guid.NewGuid(), Item = CaseB {Text = ""; Version = null })
let c = x.CloneWith(Id = Guid.NewGuid(), Item =       {Text = ""; Version = null })

Тогда ваш матч можно записать следующим образом:

let format x =
    match x.Item with
    | CaseA r  ->             
        let v =  x.CloneWith(Item = r)
        sprintf "%O: %s: %O" v.Id v.Item.Text v.Item.Number
    | CaseB r  -> 
        let v =  x.CloneWith(Item = r)
        sprintf "%O: %s: %O" v.Id v.Item.Text v.Item.Version

Конечно, вы должны указать каждое поле в методе CloneWith (в этом случае дважды). Но на вызывающем сайте синтаксис лучше. Могут быть решения, не упоминающие все поля, содержащие отражение.

Ответ 2

Будет ли это делать то, что вы хотите?

open System

type Envelope<'a> = 
    { Id : Guid
      ConversationId : Guid
      Created : DateTimeOffset
      Item : 'a }

type RecA = { Text : string; Number : int }
type RecB = { Text : string; Version : Version }
type MyDU = | CaseA of RecA | CaseB of RecB

let e = 
    { Id = Guid.NewGuid(); 
      ConversationId = Guid.NewGuid(); 
      Created = DateTimeOffset.MinValue; 
      Item = CaseA {Text = ""; Number = 1  } }

match e with
| { Item = CaseA item } as x -> sprintf "%O: %s: %O" x.Id item.Text item.Number 
| { Item = CaseB item } as x -> sprintf "%O: %s: %O" x.Id item.Text item.Version

x - это исходное значение, а "item" - это RecA или RecB.

Ответ 3

Чтобы перефразировать ваш вопрос, если я правильно понял, вы хотите включить содержимое конверта, все еще имея доступ к заголовку конверта?

В этом случае, почему бы не просто извлечь содержимое, а затем передать как содержимое, так и заголовок в виде пары?

Вспомогательная функция для создания пары может выглядеть так:

let extractContents envelope = 
    envelope.Item, envelope 

И тогда ваш код форматирования будет изменен для обработки заголовка и содержимого:

let formatA header (contents:RecA) = 
    sprintf "%O: %s: %O" header.Id contents.Text contents.Number
let formatB header (contents:RecB) = 
    sprintf "%O: %s: %O" header.Id contents.Text contents.Version

Используя это место, вы можете использовать сопоставление шаблонов обычным способом:

let format envelope =
    match (extractContents envelope) with
    | CaseA recA, envA -> formatA envA recA
    | CaseB recB, envB -> formatB envB recB

Здесь полный код:

open System

type Envelope<'a> = {
    Id : Guid
    ConversationId : Guid
    Created : DateTimeOffset
    Item : 'a }

type RecA = { Text : string; Number : int }
type RecB = { Text : string; Version : Version }
type MyDU = | CaseA of RecA | CaseB of RecB


let extractContents envelope = 
    envelope.Item, envelope 

let formatA header (contents:RecA) = 
    sprintf "%O: %s: %O" header.Id contents.Text contents.Number
let formatB header (contents:RecB) = 
    sprintf "%O: %s: %O" header.Id contents.Text contents.Version

let format envelope =
    match (extractContents envelope) with
    | CaseA recA, envA -> formatA envA recA
    | CaseB recB, envB -> formatB envB recB

Если бы я делал это много, я бы, вероятно, создал отдельный тип записи для заголовка, что сделало бы это еще проще.

let extractContents envelope = 
    envelope.Item, envelope.Header 

Кстати, я бы написал немного mapEnvelope:)

let mapEnvelope f envelope =
    {envelope with Item = f envelope.Item}

Ответ 4

Итак, сначала это было немного запутанно, но вот более простая версия того, что у вас есть (это явно не идеально из-за частичного соответствия, но я пытаюсь его улучшить):

open System

type Envelope<'a> = {
    Item : 'a }

type RecA = { Text : string; Number : int }
type RecB = { Text : string; Version : Version }
type MyDu = |A of RecA |B of RecB

let (|UnionA|_|) x = 
    match x.Item with
    |A(a) -> Some{Item=a}
    |B(b) -> None

let (|UnionB|_|) x = 
    match x.Item with
    |A(_) -> None
    |B(b) -> Some{Item=b}


let test (t:Envelope<MyDu>) =
    match t with
    |UnionA(t) -> () //A case - T is a recA
    |UnionB(t) -> () //B case - T is a recB

Общая проблема заключается в том, что мы хотим получить функцию, которая возвращает как Envelope<RecA>, так и Envelope<RecB> (что не очень просто).

ИЗМЕНИТЬ

Оказывается, это на самом деле легко:

let (|UnionC|UnionD|) x =
    match x.Item with
    |A(a) -> UnionC({Item=a})
    |B(b) -> UnionD{Item=b}

let test (t:Envelope<MyDu>) =
    match t with
    |UnionC(t) -> () //A case - T is a recA
    |UnionD(t) -> () //B case - T is a recB;;