Wie erstelle ich eine Liste mit einer Schleife in Elm?

Question

Nehmen wir an, ich habe zwei Listen, die Liste letters, die die Buchstaben A-F enthalten, und die Liste nums, die die Nummern 1-6 enthält.

In Elm, wie kann ich programmatisch eine Liste mit allen möglichen Kombination (d. H. A1, C6, F3, D2, etc.) machen?

Dies ist nur für den Zweck der Eleganz des Codes, Hardcoding wäre jede mögliche Kombination gleichwertig.

In JavaScript, wäre es von etwas darstellen wie ...

const nums = [1,2,3,4,5,6]; 
 
const letters = [`a`,`b`,`c`,`d`,`e`,`f`]; 
 

 
const combineLists = (a,b)=>{ 
 
    const newList = []; 
 
    a.forEach(aEl=>{ 
 
    b.forEach(bEl=>{ 
 
     newList.push(aEl + bEl); 
 
    }) 
 
    }) 
 
    return newList; 
 
} 
 
      
 
console.log(combineLists(letters,nums));

Wie würden Sie eine äquivalente combineLists Funktion in Elm schreiben?

Answer 1

Ich bin nicht sicher, dass dies die beste Umsetzung ist, aber man kann versuchen, diese:

import Html exposing (..) 


nums : List Int 
nums = 
    [ 1, 2, 3, 4, 5, 6 ] 


letters: List String 
letters = 
    [ "a", "b", "c", "d", "e", "f" ] 


combineLists : List a -> List b -> List String 
combineLists list1 list2 = 
    List.concatMap 
     (\elList1 -> 
      List.map 
       (\elList2 -> toString elList1 ++ toString elList2) 
       list2 
     ) 
     list1 


main = 
    text <| toString <| combineLists letters nums 

Dies ist ein weiterer Weg sein könnte, das gleiche zu tun:

import Html exposing (..) 


nums : List Int 
nums = 
    [ 1, 2, 3, 4, 5, 6 ] 


letters: List String 
letters = 
    [ "a", "b" , "c" , "d", "e", "f" ] 


combineLists : List a -> List b -> List String 
combineLists list1 list2 = 
    List.map toString list1 
     |> List.concatMap 
      (\e1 -> 
       List.map (toString >> String.append e1) list2 
      ) 


main = 
    text <| toString <| combineLists letters nums 

Answer 2

Hier ist mein Vorschlag , was ich denke, ist es, die am meisten kondensiert möglich

module Main exposing (..) 

import Html exposing (..) 


nums : List Int 
nums = 
    [ 1, 2, 3, 4, 5, 6 ] 


letters : List String 
letters = 
    [ "a", "b", "c", "d", "e", "f" ] 


main = 
    nums 
     |> List.map toString 
     |> List.concatMap (\n -> List.map (String.append n) letters) 
     -- or in point free style 
     -- |> List.concatMap (String.append >> flip List.map letters) 
     |> toString 
     |> text 

Point free style scheint nicht die gleiche pr haben ide Platz in Elm wie es funktioniert in Haskell, aber ich schließe es auf Vollständigkeit und ist die Art, wie ich meinen Code schreiben würde

Answer 3

Hier ist eine weitere Möglichkeit andThen von List.Extra

import Html exposing (text) 
import List.Extra exposing (andThen) 

nums : List Int 
nums = 
    [ 1, 2, 3, 4, 5, 6 ] 


letters : List String 
letters = 
    [ "a", "b", "c", "d", "e", "f" ] 

main = 
    andThen 
     (\num -> andThen 
       (\letter -> [(toString num) ++ letter]) 
       letters) 
     nums 
    |> toString 
    |> text