patrón activa roto en F # 3.0

Question

Este patrón activo compila con F # 2.0:

let (|Value|_|) value = // 'a -> 'T option 
    match box value with 
    | :? 'T as x -> Some x 
    | _ -> None 

pero, en F # 3.0, emite el error:

Active pattern '|Value|_|' has a result type containing type variables that are not determined by the input. The common cause is a [sic] when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice = A x'

Probé:

let (|Value|_|) value : 'T option = ... 

y:

let (|Value|_|) (value: 'U) = ... 

¿Cómo se puede arreglar?

entornos: Visual Studio 2012 (RTM) y v11.0.50727.1 FSI

EDIT: He aquí una repro más simple:

let (|X|) x = unbox x 

Answer 1

Hubo un error en el compilador F # 2.0 donde el compilador realizó análisis incorrectos y generación de código incorrecto para ciertos patrones activos con variables de tipo libre en el resultado; una reproducción simple es

let (|Check|) (a : int) = a, None 
//let (|Check|) (a : int) = a, (None : int option) 

let check a = 
    match a with 
    | Check (10, None) -> System.Console.WriteLine "10" 
    | Check (20, None) -> System.Console.WriteLine "20" 

check 10 
check 20 

que genera una advertencia extraña en tiempo de compilación y se compila en un código aparentemente incorrecto. Supongo que nuestro intento de arreglar este error (y restringir algunos casos locos) en F # 3.0 también rompió algunos códigos legales como daño colateral de la corrección.

Archivaré otro error, pero para F # 3.0, parece que tendrá que utilizar una de las soluciones alternativas mencionadas en otras respuestas.

Answer 2

que no ha instalado la nueva versión todavía, pero estoy de acuerdo este se ve un poco sospechoso Supongo que puede haber una buena razón para esta restricción, pero su ejemplo en la otra pregunta parece bastante convincente.

Como solución, creo que la adición de un parámetro testigo (que no se utiliza, pero que señala cuál es el tipo del resultado va a ser) podría funcionar:

let (|Value|_|) (witness:unit -> 'T) value : 'T option = 
    match box value with 
    | :? 'T as x -> Some x 
    | _ -> None 

Por supuesto, esto hace que la usa un poco más feo, porque necesitas llegar a algún argumento. En lo anterior, se utiliza testimonio de tipo unit -> 'T, con la esperanza de que el siguiente podría compilar:

let witness() : 'T = failwith "!" 

match box 1 with 
| Value witness 1 -> printfn "one" 

Si eso no funciona, entonces es probable que pueda tratar con el parámetro testigo de tipo 'T (pero luego se va a proporcionar una función real, en lugar de solo una función genérica).

Answer 3

Consulte mi answer en su otro question para obtener algunas ideas sobre cómo solucionar el problema y una razón por la que dichos patrones activos pueden ser indeseables. No estoy seguro si el cambio fue intencionado.

Answer 4

para la mayor abundamiento, una más solución:

type Box<'R> = Box of obj 

let (|Value|_|) ((Box x) : Box<'R>) : 'R option = 
    match x with 
    | :? 'R as x -> Some x 
    | _ -> None 

let check t = 
    match Box t with 
    | Value 1 -> printfn "one" 
    | Value 2 -> printfn "two" 

check 1 // one 
check 2 // two 

sin embargo, todavía van a sufrir el problema mencionado por @kvb en another thread. Personalmente preferiré la versión de @ kvb con un patrón activo parametrizado.