Come è il calcolo di tipi in Haskell

Question

Diciamo

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

tipo di (const Flip) sarebbe

a=d,b=e,c=d 

in

b->a->c 

modo che il tipo sarebbe

e->d->d 

Ma per (mappa introito) la sua

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

quindi non ho capito come il ghci questo calcolo. ho capito [[a]] -> [[a]] ma perché e come [Int]?

edit: ad esempio se avessimo scriviamo in ghci

:t flip const 


it would return b->c->c 

e ghci sarebbe calcolare che come ho fatto io.

Ma

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

quindi perché è mappa prendere

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

perché [Int] come hanno fatto i ghci calcolano che

Answer 1

Dovresti copiare e incollare i tipi che vedi, non riscriverli nella domanda. La ragione è che hai visto male. Il tipo per map take è:

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

In altre parole, l'unificazione funziona come tale:

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

così quando si applica take come primo argomento a map si ottiene a ~ Int e b ~ [c] -> [c] (si noti che è un funzione). L'esecuzione di queste sostituzioni nel tipo map e applicando il primo argomento:

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 è esattamente quello che ci si aspetta.Una funzione che opera su liste di Ints e produce un elenco di funzioni che richiedono un certo numero di elementi dall'inizio di una lista.

Answer 2

Facciamo la stessa analisi:

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

E

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

Ma questo significa che in realtà

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

Quindi, con a=Int e b=([x] -> [x]) si ottiene

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

un elenco di funzioni di lista!