F # Conceptos básicos: Plegar 2 listas juntas en una cadena

Question

un poco oxidado desde mis días de Scheme, me gustaría tomar 2 listas: una de números y una de cadenas, y doblarlas juntas en una sola secuencia donde está cada par escrito como "{(ushort) 5," bla bla bla "}, \ n". Yo tengo la mayor parte de ella, pero no estoy seguro de cómo escribir la Fold correctamente:

let splitter = [|","|] 
let indexes = 
    indexStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 
let values = 
    valueStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 

let pairs = List.zip indexes values 
printfn "%A" pairs 

let result = pairs |> Seq.fold 
    (fun acc a -> String.Format("{0}, \{(ushort){1}, \"{2}\"\}\n", 
           acc, (List.nth a 0), (List.nth a 1))) 

Answer 1

Sus dos cosas faltantes. El estado inicial del doblez que es una cadena vacía y no se puede usar la comprensión de la lista en las tuplas en F #.

let splitter = [|","|] 
let indexes = 
    indexStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 
let values = 
    valueStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 

let pairs = List.zip indexes values 
printfn "%A" pairs 

let result = 
    pairs 
    |> Seq.fold (fun acc (index, value) -> 
     String.Format("{0}{{(ushort){1}, \"{2}\"}},\n", acc, index, value)) "" 

fold2 versión

let result = 
    List.fold2 
     (fun acc index value -> 
      String.Format("{0}{{(ushort){1}, \"{2}\"}},\n", acc, index, value)) 
     "" 
     indexes 
     values 

Si usted se refiere a la velocidad que puede que quiera usar constructor de cadena, ya que no crea una nueva cadena cada vez que se anexa.

let result = 
    List.fold2 
     (fun (sb:StringBuilder) index value -> 
      sb.AppendFormat("{{(ushort){0}, \"{1}\"}},\n", index, value)) 
     (StringBuilder()) 
     indexes 
     values 
    |> string 

Answer 2

Creo que desee List.fold2. Por algún motivo, el módulo List tiene un miembro fold2 pero Seq no. Entonces puede prescindir completamente del zip.

Los tipos de variables con nombre y el tipo del resultado que esperas son todos implícita, por lo que es difícil ayudar, pero si usted está tratando de acumular una lista de cadenas que podrían considerar algo en la línea de

let result = pairs |> Seq.fold 
    (fun prev (l, r) -> 
      String.Format("{0}, \{(ushort){1}, \"{2}\"\}\n", prev, l, r) 
    "" pairs 

Mi F #/Caml está muy oxidado, por lo que es posible que el orden de los argumentos sea incorrecto. También tenga en cuenta que su formación de cuerda es cuadrática; en mi propio código me gustaría ir con algo más a lo largo de estas líneas:

let strings = 
    List.fold2 (fun ss l r -> 
       String.format ("\{(ushort){0}, \"{1}\"\}\n", l, r) :: ss) 
       [] indexes values 

let result = String.concat ", " strings 

Esto no le costará tiempo cuadrática y es un poco más fácil de seguir. Revisé MSDN y creo que tengo el orden correcto de argumentos en fold2.

Recuerda que conozco Caml not F # y puedo tener detalles o el orden de los argumentos incorrecto.

Answer 3

Doblar probablemente no sea el mejor método para esta tarea. Es mucho más fácil para mapear y concat así:

let l1 = "a,b,c,d,e".Split([|','|]) 
let l2 = "1,2,3,4,5".Split([|','|]) 
let pairs = 
    Seq.zip l1 l2 
    |> Seq.map (fun (x, y) -> sprintf "(ushort)%s, \"%s\"" x y) 
    |> String.concat "\n" 

Answer 4

Tal vez esto:

let strBuilder = new StringBuilder() 
for (i,v) in Seq.zip indexes values do 
    strBuilder.Append(String.Format("{{(ushort){0}, \"{1}\"}},\n", i,v)) 
    |> ignore 

con F # A veces es mejor ir imprescindible ...

Answer 5

map2 o fold2 es la manera correcta de ir. Esta es mi opinión, el uso de la (||>) operador:

let l1 = [| "a"; "b"; "c"; "d"; "e" |] 
let l2 = [| "1"; "2"; "3"; "4"; "5" |] 
let pairs = (l1, l2) ||> Seq.map2 (sprintf ("(ushort)%s, \"%s\"")) 
         |> String.concat "\n"