Wie die Berechnung der Typen in Haskell ist

Question

Lets

flip :: (a->b->c) ->b->a->c 
    const ::d->e->d 

Typ (Flip const) sagen

a=d,b=e,c=d 

in

b->a->c 

so der Typ

wäre wäre

e->d->d 

Aber für (Karte take) seine

[Int]->[[a]]->[[a]] 

so dass ich nicht verstehen, wie die GHCI dieses berechnet. ich verstand die [[a]] -> [[a]] aber warum und wie [Int]?

bearbeiten: Zum Beispiel, wenn wir in GHCI

:t flip const 


it would return b->c->c 

und GHCI würde berechnen schreiben würde, dass, wie ich tat.

Aber

map :: (a->b)->[a]->[b] 
take :: Int->[c]->[c] 

also warum ist Karte nehmen

[Int]->[[a]->[a]] 

warum [Int] wie haben die GHCI berechnen, dass

Answer 1

Sie sollten die angezeigten Typen kopieren und einfügen und sie nicht in die Frage eingeben. Der Grund ist, dass du falsch gesehen hast. Der Typ für map take ist:

map take :: [Int] -> [[a] -> [a]] 

Mit anderen Worten arbeitet die Vereinigung als solche:

:t map 
map :: (a -> b) -> [a] -> [b] 
:t take 
take :: Int -> [c] -> [c] 

so, wenn take als erstes Argument zu map Anwendung erhalten Sie a ~ Int und b ~ [c] -> [c] (Hinweis, dass a Funktion). Die Durchführung dieser Ersatz in der map Art und das erste Argument Anwendung:

map take :: [a] -> [b]  (for some specific 'a' and 'b') 
-- recall a ~ Int 
map take :: [Int] -> [b]  (for some specific 'b') 
-- recall b ~ [c] -> [c] 
map take :: [Int] -> [[c] -> [c]] 

Yay, map take ist genau das, was Sie erwarten.Eine Funktion, die Listen von Inten bearbeitet und zu einer Liste von Funktionen führt, die eine bestimmte Anzahl von Elementen vom Anfang einer Liste übernehmen.

Answer 2

Lassen Sie uns die gleiche Analyse tun:

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

Und

take :: Int -> [x] -> [x] 

Aber das bedeutet eigentlich

take :: Int -> ([x] -> [x]) 

So mit a=Int und b=([x] -> [x]) Sie erhalten

map take :: [Int] -> [ [x] -> [x] ] 

Eine Liste der Listen-Funktionen!