¿Por qué el tipo de tupla no puede inferirse en la recursividad de la lista?

Question

Quiero refinar el texto sin formato utilizando expresiones regulares, dada una lista de tuplas (patten, reemplazo).

Intenté usar la coincidencia de patten en el elemento de la lista, pero fallé, el error mostró que " Se esperaba que esta expresión tuviera tipo string * string list pero aquí tiene el tipo 'a list " ;.

¿Cómo puedo solucionar este problema? Muchas gracias.

Los códigos son los siguientes:

let rec refine (raw:string) (rules:string*string list) = 
    match rules with
    | (pattern,replacement) :: rest ->
        refine <| Regex.Replace(raw,pattern,replacement) rest
    | [] -> raw

Answer 1

El problema es que una cadena * lista de cadenas es un par que consiste en una cadena y una lista de cadenas, mientras que desea una lista (cadena * cadena) :

let rec refine (raw:string) (rules:(string*string) list) =
    match rules with
    | (pattern,replacement) :: rest ->
        refine (Regex.Replace(raw,pattern,replacement)) rest
    | [] -> raw

Alternativamente, la única razón por la que necesita esa anotación particular es porque Regex.Replace está sobrecargado. Es por eso que su otra solución funciona, pero hay otros lugares (más mínimos) en los que puede poner una anotación que funcionará:

let rec refine (raw:string) rules =
    match rules with
    | (pattern,replacement:string) :: rest ->
        refine (Regex.Replace(raw,pattern,replacement)) rest
    | [] -> raw

Answer 2

Finalmente funciona cuando intento esto:

let rec refine (raw:string) rules = 
    match rules with
    | rule :: rest ->
        //get tuple values beyond the patten matching
        let (pattern:string,replacement:string) = rule 
        refine (Regex.Replace(raw,pattern,replacement)) rest
    | [] -> raw