Haskell - Großschreibung aller Buchstaben in einer Liste [String] mit toUpper

Zuordnung eine Ebene tiefer

Müssen Sie map (map toUpper).

Dies ist, weil Sie haben [String] statt String.

toUpper           :: Char -> Char
map toUpper       :: [Char] -> [Char]

d.h.

map toUpper       :: String -> String
map (map toUpper) :: [String] -> [String]

map toUpper nutzt eine Zeichenfolge, indem Sie jeden Buchstaben in Großbuchstaben, so map (map toUpper) profitiert jeder String in eine Liste von Strings.

Ihre Funktion wird

delAndUpper myList = map (map toUpper) (filter (\x -> not('p' `elem` x || 'q' `elem` x)) myList)

dave4420 gemacht guter Vorschlag, dass (map.map) toUpper ist eine nette Art zu schreiben map (map toUpper), die Ihnen hilft, denken Sie zwei Listen von Ebenen ganz einfach und natürlich - haben Sie einen Blick auf seine Antwort zu.

Können wir un-hardwire p und q?

Sie fragte, ob es nicht einen kürzeren Weg zu schreiben, den Zustand, und wusste nicht, wie schwer die Kodierung der `q` und `p`. Ich Stimme denen mehreren `elem` bits sind nicht schön. Wir übergeben die Liste der unzulässigen Buchstaben-und Aufräumen ein bisschen:

delAndUpper omit strings = map (map toUpper) (filter ok strings) where
            ok xs = not (any (`elem` omit) xs)

Hier (`elem` omit) prüft ein Zeichen, wenn es in der Liste der diejenigen, die uns dazu führen würden, auslassen das Wort, so (any (`elem` omit) xs) überprüft, ob die Zeichen der xs sind verboten. Natürlich ist dies nicht verboten, es ist ok.

Ihre ursprüngliche delAndUpper wäre jetzt delAndUpper "pq", oder wenn Sie wollen auch verbieten, Kapital P und Q, delAndUpper "pqPQ". (Mehr dazu später.)

Können wir es präziser?

Lasst uns sehen, ob wir nicht schreiben können ok ein wenig kürzer. Mein Erster Gedanke war der Einsatz von pointfree auf (siehe meine Antwort auf eine andere Frage für details, wie es läuft im ghci), aber es schien zu hängen, so dass die Verwendung von standard-Transformations-tricks, wir können Komponieren not mit einer Funktion, die zwei Argumente nimmt, bevor er uns einen Bool-by-doing - (not.).f statt not.f als würden wir mit einer Funktion, die Gaben uns ein Boolescher Wert, der nach der ersten Eingabe. any ist unter (`elem` omit) als erstes argument. Dies gibt uns

ok xs = ((not.).any) (`elem` omit) xs

aus, die wir können, entfernen Sie die nachfolgende xs:

ok = ((not.).any) (`elem` omit) 

- und inline:

delAndUpper omit strings = map (map toUpper) (filter (((not.).any) (`elem` omit)) strings)

Bin ich nicht scharf auf die nachfolgende strings entweder:

delAndUpper omit = map (map toUpper).filter (((not.).any) (`elem` omit))

(Wir könnten loszuwerden, die omit argument als gut und gehen völlig point frei, aber das Recht etwas zu weit nach unten in den hart-zu-Lesen-road für meinen Geschmack.)

Wohin F?

> delAndUpper "pq" $ words "The Queen has probably never had a parking ticket."
["THE","QUEEN","HAS","NEVER","HAD","A","TICKET."]

Ist dies die erforderliche Verhalten? Es scheint seltsam, um gezielt ausschließen das kleingeschriebene Varianten und dann alles in Großbuchstaben. Wir könnten es tun, die andere Weise Runde:

upperAndDel omit = filter (((not.).any) (`elem` omit)).map (map toUpper)

geben

> upperAndDel "PQ" $ words "The Queen has probably never had a parking ticket."
["THE","HAS","NEVER","HAD","A","TICKET."]

Du bist fast da, Sie brauchen nur eine zweite map.

map (map toUpper) (filter (\x -> not('p' `elem` x || 'q' `elem` x)) myList)

Dies ist, weil String ist völlig gleichbedeutend mit [Char] in Vanille haskell. Da ist der Typ von map ist die

(a->b) -> [a] -> b

und wir haben

toUpper :: Char -> Char
String  :: [Char]

Bekommen wir wieder ein anderes String außer großgeschrieben.

Durch die Art und Weise, dass hässliche-ish-filter ersetzt werden kann, aus schöner, indem Sie es mit den Pfeiltasten 🙂 (Denken Sie an diese, wie mehrere strukturierte Funktionen)

map (map toUpper) . filter $ elem 'p' &&& elem 'q' >>> arr (not . uncurry (||))

Unentgeltlichkeit? Vielleicht, aber irgendwie cool.