Resuse F # Active Pattern результат

Question

В следующем коде я должен повторно использовать результат Active Pattern три раза для каждой итерации. т.е.

match tree.Parent, postion with

Я обнаружил, что могу сохранить результат Active Pattern. т.е.

let pos = ((|Root|Nil|Single|First|Inner|Last|Unknown|) (tree.Parent, position)) 

Что я не мог понять, так это то, что результат Active Pattern можно использовать в выражении match. т.е.

match pos with
| ??? -> printf "("

Вопрос в том, может ли сохраненный результат активного шаблона использоваться в выражении соответствия?

Если так, то как? Если нет, нужно объяснить это так, чтобы это имело смысл.

Примеры, возможно, почему бы и нет. то есть спецификация языка, синтаксический сахар, не должен был позволять привязывать результат активного шаблона, ExprItems против PatItems

Я посмотрел в Спецификации языка F # 2.0 (апрель 2010) http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc270597500

Но я не узнал ничего, что могло бы подтвердить ответ.

EDIT

Если я изменю код на

    let pos = (|Root|Nil|Single|First|Inner|Last|Unknown|) (tree.Parent, position)  
    match pos with                                                                
    | Choice1Of7 (tree.Parent, position) -> printf "("                                                          
    | _    -> ()

Я получаю следующую ошибку для (tree.Parent, position) после Choice1Of7:

Ожидалось, что это выражение будет иметь тип unit, но здесь имеет тип 'a *' b

Как предположил Брайан, это должно быть

    match pos with                                                                
    | Choice1Of7 () -> printf "("                                                          
    | _    -> ()    

Конец РЕДАКТИРОВАТЬ

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

// An F# function to print a CommonTree as an s-expression
// 
// Note: Because the CommonTree data structure was created allowing null values,
// the null value has to be handled.
// 
let commonTreeToSExpression100 (tree : BaseTree) =
    // Define Active Pattern to create new view of node, i.e. BaseTree
    // for position in list instead of content.
    // Note: The name of the active pattern function    is "|Root|Nil|Single|First|Inner|Last|Unknown|"
    let (|Root|Nil|Single|First|Inner|Last|Unknown|) (tree : ITree , position) =
        let parent = tree :?> BaseTree
        match parent with
        | null -> Root
        | _ ->
            let list = parent.Children
            match obj.ReferenceEquals(list,null) with
            | true -> Nil  // This should never happen.
            | false ->
                let count = list.Count
                // TODO: Handle count = 0
                if (count = 1) then Single
                elif (count > 1) && (position = 0) then First
                elif (count > 1) && (position = count - 1) then Last 
                elif (count > 1) && (0 < position) && (position < count - 1) then Inner
                else Unknown  // This should never happen.

    // Define walk/print function
    let rec printTree (tree : BaseTree) (position) =

        // Start an s-expression
        match tree.Parent, position with
        | Root | Single | First -> printf "("
        | _                     -> ()

        // Note: Can save the result of an active pattern which is type Choice<uint,uint,uint,uint,uint,uint,uint>. 
        // The question is can the saved active pattern result be used in a match statement? 
        // If so, how? If not, need to explain it so that it logicaly makes sense. 
        // Give examples of possibly why not. i.e. Language Specification, syntactic sugar,
        // should not have allowed result to be bound, not in symbol table but other table.
        //let pos = ((|Root|Nil|Single|First|Inner|Last|Unknown|) (tree.Parent, position))  // This works / is allowed
        //    match pos with                                                                
        //    | ???  -> printf "("                                                          // Can this work? What should ??? be?
        //    | _    -> ()

        // Visit the node
        printf "%s" tree.Text    

        // Space out the values
        match tree.Parent, position with
        | Root | First | Inner -> printf " " 
        | _                    -> ()

        // Process the children
        // Note: BaseTree holds the ChildIndex, if this property was not available
        // then the use of Seq.iter whould have to be changed for a mechanism that
        // would allow the calculation of the child index as the list is processed.
        match tree.Children with
        | null -> ()
        | _    -> 
            tree.Children |> Seq.iter (fun x -> printTree (x :?> BaseTree) x.ChildIndex)
            printf " "

        // End an s-expression
        match tree.Parent, position with
        | Root | Single | Last -> printf ")" 
        | _                    -> ()

    // Call the walk/print function
    printTree tree 0

    // Since s-experssions print as single line, 
    // print a newline so that what is printed after this
    // is not on the same line as this s-expression.
    printfn ""

Answer 1

Это не особенно элегантно, но вы можете использовать базовый различимый союз, который используется для представления активных шаблонов.Результат активного шаблона с N опциями представлен с использованием типа Choice<'T1, .., 'Tn>, который имеет члены Choice1OfN .. ChoiceNOfN.

Вот более простой пример с тремя случаями:

let (|Pos|Neg|Zero|) n = 
  if n < 0 then Neg (-n)
  elif n = 0 then Zero
  else Pos n

let res = (|Pos|Neg|Zero|) 10

match res with
| Choice1Of3 n -> sprintf "pos %d" n
| Choice2Of3 n -> sprintf "neg %d" n
| Choice3Of3 () -> "zero"

На практике я, вероятно, не использовал бы этот подход, но вместо этого я бы определил пользовательский дискриминируемый союз:

type Number = Pos of int | Neg of int | Zero

let convertNumber n = 
  if n < 0 then Neg (-n)
  elif n = 0 then Zero
  else Pos n

let res = convertNumber 10

match res with
| Pos n -> sprintf "pos %d" n
| Neg n -> sprintf "neg %d" n
| Zero -> "zero"

Это требует явного определения дискриминируемого объединения, но делает код болеечитаемый.