¿Usar coincidencia de patrón incompleta como filtro?

Question

Supongamos que tengo el siguiente código:

type Vehicle = 
| Car of string * int 
| Bike of string 

let xs = [ Car("family", 8); Bike("racing"); Car("sports", 2); Bike("chopper") ] 

I puede filtrar por encima de lista mediante la coincidencia de patrones incompleta en un imperativo para bucle como:

> for Car(kind, _) in xs do 
> printfn "found %s" kind;; 

found family 
found sports 
val it : unit =() 

pero causará un: warning FS0025: Incomplete pattern matches on this expression. For example, the value 'Bike (_)' may indicate a case not covered by the pattern(s). Unmatched elements will be ignored.

Como el ignorar elementos incomparables es mi intención, ¿hay alguna posibilidad de deshacerse de esta advertencia?

¿Y hay una manera de hacer que esto funcione con listas de comprensión sin causar una excepción MatchFailureException? p.ej. algo así:

> [for Car(_, seats) in xs -> seats] |> List.sum;; 
val it : int = 10 

Answer 1

dos años, su código es válido y que fue la forma estándar de hacerlo. Luego, el lenguaje se ha limpiado y la decisión de diseño fue favorecer la sintaxis explícita. Por esta razón, creo que no es una buena idea ignorar la advertencia.

La sustitución estándar para el código es:

for x in xs do 
    match x with 
    | Car(kind, _) -> printfn "found %s" kind 
    | _ ->() 

(también se puede utilizar funciones de alto orden tiene en la muestra de la almohadilla)

Por el otro, List.sumBy encajaría bien:

xs |> List.sumBy (function Car(_, seats) -> seats | _ -> 0) 

Si prefiere seguir con comprensiones, esta es la sintaxis explícita:

[for x in xs do 
    match x with 
    | Car(_, seats) -> yield seats 
    | _ ->() 
] |> List.sum 

Answer 2

Se puede silenciar ninguna advertencia a través de la directiva o #nowarn--nowarn: opción del compilador (pasar el número de advertencia, aquí como en 25FS0025).

Pero, en general, no, lo mejor es filtrar explícitamente, como en la otra respuesta (por ejemplo, con choose).

Answer 3

Para indicar explícitamente que desea ignorar casos no coincidentes, puede usar List.choose y devolver None para esos elementos no coincidentes. Sus códigos se podrían escribir de una manera más idiomáticas de la siguiente manera: hace

let _ = xs |> List.choose (function | Car(kind, _) -> Some kind 
            | _ -> None) 
      |> List.iter (printfn "found %s") 

let sum = xs |> List.choose (function | Car(_, seats)-> Some seats 
             | _ -> None) 
      |> List.sum