Haskell erwartet Typ Problem

Question

neu zu Haskell und funktionale Programmierung ... im Lernprozess. Was ist mit diesem Code falsch ist:

import System.IO 
import Data.Char 
import System.Environment 

main = do 
    args <- getArgs 
    progName <- getProgName 
    content <- readFile $ head args 
    putStrLn $ show $ getWordsInfo content 

getWordsInfo = let 
        wordList = filter (\x -> length x > 2 && all isAlpha x) . words 
       in foldl foldingFunction 0 wordList 
       where foldingFunction acc tWord = acc + length tWord 

Wenn ich es zu kompilieren versuchen, bekomme ich falsch den folgenden

Couldn't match expected type `[[a0]]' 
      with actual type `String -> [[Char]]' 
In the third argument of `foldl', namely `wordList' 
In the expression: foldl foldingFunction 0 wordList 
In the expression: 
    let 
    wordList = filter (\ x -> length x > 2 && all isAlpha x) . words 
    in foldl foldingFunction 0 wordList 

Answer 1

Sie scheinen zu sein mit Punkt frei Notation.

Die einzige Linie, das, was falsch ist, ist:

let wordList = filter (\x -> length x > 2 && all isAlpha x) . words

Die Fehlermeldung sagt, dass, wenn Sie rufen wordlist hat es nicht genügend Argumente angewendet worden ist, wird eine Liste von Listen erwarten , aber stattdessen wurde eine Funktion gegeben, die eine Zeichenkette nimmt und eine Liste von Listen erzeugt. Also müssen wir der Wortliste nur die Eingabezeichenfolge geben.

Sie können es zwei Möglichkeiten umschreiben:

Die erste durch explizite Angabe des Arguments ist:

getWordsInfo xs = let wordList = filter (\x -> length x > 2 && all isAlpha x) (words xs) 
        in foldl foldingFunction 0 wordList 
        where foldingFunction acc tWord = acc + length tWord 

Die zweite ist durch den Punkt frei Bit nicht in einer let halten Bindung:

getWordsInfo = foldl foldingFunction 0 . filter (\x -> length x > 2 && all isAlpha x) . words 
        where foldingFunction acc tWord = acc + length tWord 

Ihre Falzfunktion nimmt die Länge jedes Wortes und summiert sie, was durch die Zuordnung über die Liste und die Länge vereinfacht werden kann, dann die Liste summieren.

getWordsInfo = sum . map length . filter (\x -> length x > 2 && all isAlpha x) . words 

Und diese Linie ein bisschen zu lang ist immer, also sollten wir wahrscheinlich etwas davon in eine andere Definition Faktor uns geben schließlich:

import Data.Char (isAlpha) 

getWordsInfo = sum . map length . filter isLongWord . words 
    where isLongWord x = length x > 2 && all isAlpha x 

Verbrauch:

λ> getWordsInfo "apple banana orange a a b b punctuation!!" 
17 
λ> getWordsInfo "aa bb cc" 
0 
λ> getWordsInfo "!!!" 
0 
λ> getWordsInfo "apple" 
5 
λ>