Haskell Language
Syntax för funktionssamtal
Sök…
Introduktion
Haskells funktionssamtalssyntax, förklarad med jämförelser med språk i C-stil där det är tillämpligt. Detta riktar sig till personer som kommer till Haskell med bakgrund i språk i C-stil.
Anmärkningar
I allmänhet är regeln för att konvertera ett C-stil-funktionssamtal till Haskell, i vilket sammanhang som helst (tilldelning, återvändande eller inbäddat i ett annat samtal), att ersätta kommatecken i C-stil-argumentlistan med vitrum och flytta öppningen parentes från C-stilsamtalet för att innehålla funktionsnamnet och dess parametrar.
Om några uttryck är helt inslagna i parenteser kan dessa (yttre) parparenteser tas bort för läsbarhet, eftersom de inte påverkar betydelsen av uttrycket.
Det finns vissa andra omständigheter där parenteser kan tas bort, men det påverkar bara läsbarheten och underhållningsförmågan.
Paretheses i ett grundläggande funktionssamtal
För en C-stilfunktion, t.ex.
plus(a, b); // Parentheses surrounding only the arguments, comma separated
Då kommer motsvarande Haskell-kod att vara
(plus a b) -- Parentheses surrounding the function and the arguments, no commas
I Haskell krävs inte uttryckligen parenteser för funktionsapplikation och används bara för att otvetydiga uttryck, som i matematik; så i fall där parenteserna omger hela texten i uttrycket behövs inte parenteserna, och följande är också lika:
plus a b -- no parentheses are needed here!
Det är viktigt att komma ihåg att funktionen är C-stil
Parenteser i inbäddade funktionssamtal
I det föregående exemplet slutade vi inte med parenteserna eftersom de inte påverkade meningen med uttalandet. Men de är ofta nödvändiga i mer komplexa uttryck, som den nedan.
I C:
plus(a, take(b, c));
I Haskell blir detta:
(plus a (take b c))
-- or equivalently, omitting the outermost parentheses
plus a (take b c)
Observera att detta inte motsvarar:
plus a take b c -- Not what we want!
Man kan tro att kompilatorn vet att take är en funktion, den skulle kunna veta att du vill använda den på argumenten b och c och överföra resultatet till plus .
Men i Haskell tar funktioner ofta andra funktioner som argument, och liten faktisk skillnad görs mellan funktioner och andra värden; och kompilatorn kan inte anta din avsikt bara för att take är en funktion.
Och så är det sista exemplet analogt med följande C-funktionskall:
plus(a, take, b, c); // Not what we want!
Delvis ansökan - Del 1
I Haskell kan funktioner delvis tillämpas; vi kan tänka på alla funktioner som att ta ett enda argument och returnera en modifierad funktion som argumentet är konstant för. För att illustrera detta kan vi fäste funktioner enligt följande:
(((plus) 1) 2)
Här tillämpas funktionen (plus) på 1 vilket ger funktionen ((plus) 1) , som tillämpas på 2 , vilket ger funktionen (((plus) 1) 2) . Eftersom plus 1 2 är en funktion som inte tar några argument kan du betrakta det som ett rent värde; Men i Haskell är det liten skillnad mellan funktioner och värden.
För att gå mer i detalj är funktionen plus en funktion som lägger till sina argument.
Funktionen plus 1 är en funktion som lägger till 1 till dess argument.
Funktionen plus 1 2 är en funktion som lägger till 1 till 2 , vilket alltid är värdet 3 .
Delvis tillämpning - del 2
Som ett annat exempel, har vi funktionen map , som tar en funktion och en lista med värden, och gäller funktionen att varje värde i listan:
map :: (a -> b) -> [a] -> [b]
Låt oss säga att vi vill öka varje värde i en lista. Du kan besluta att definiera din egen funktion, som lägger till en i dess argument, och map den funktionen över din lista
addOne x = plus 1 x
map addOne [1,2,3]
men om du tittar på addOne : s definition, med parenteser tillagda för betoning:
(addOne) x = ((plus) 1) x
Funktionen addOne , när den tillämpas på något värde x , är densamma som den delvis tillämpade funktionen plus 1 tillämpas på x . Detta innebär att funktionerna addOne och plus 1 är identiska, och vi kan undvika att definiera en ny funktion genom att bara ersätta addOne med plus 1 , kom ihåg att använda parenteser för att isolera plus 1 som subexpression:
map (plus 1) [1,2,3]