Tutti questi termini - espressioni, valori e "classe" - sono concetti PL generali che non hanno legami specifici con Haskell e sono meglio compresi in un quadro più generale. Per mantenere le cose brevi, descriverò queste idee solo informalmente, sebbene sia importante rendersi conto che possono essere tutte rigorosamente definite all'interno di un quadro logico formale.

Espressioni

Le espressioni sono le unità di base della programmazione; in un certo senso, i programmi sono espressioni . Ecco alcuni esempi di espressioni (in un piccolo linguaggio inventato):

• 1 + 3 * 3
• concat("hello", "world")
• let x = pow(2, 2) in pow(x, x)
• lambda x. x

Si noti che lambda x. x (la funzione di identità) è un'espressione in questa lingua. Può essere usato in modo intercambiabile in qualsiasi contesto in cui è prevista un'espressione; per esempio, invece di 1 + 1 possiamo scrivere 1 + lambda x. x *. In particolare, poiché gli argomenti di una funzione sono espressioni e le funzioni stesse sono espressioni, possiamo passare funzioni a funzioni come argomenti, ad esempio map(lambdax. x, [1, 2, 3]) .

Quindi, le funzioni di ordine superiore sono solo una conseguenza del trattamento di funzioni come espressioni. Al contrario, in una lingua che non lo fa, come C, tale espressione non è nemmeno un programma in quella lingua.

* Questo è valido secondo la sintassi astratta della lingua, ma il codice non controllerà il tipo. Maggiori informazioni su questo più tardi.

Dinamica e valori

Le espressioni sono statiche . È il lavoro delle dinamiche di un linguaggio per dirci come devono essere valutate le espressioni durante l'esecuzione. La dinamica (operativa) consiste in un insieme di semplici regole di transizione per trasformare una forma di espressione in un'altra. Ad esempio, le nostre dinamiche possono avere una regola che, informalmente, dice " n1 + 0 transizioni a n1 ".

I valori in una lingua sono un sottoinsieme di espressioni che consideriamo essere pienamente valutate; scriviamo programmi (espressioni) per calcolare i valori. Le espressioni sopra riportate valgono per:

• 7
• "hello world"
• 256
• lambda x. x

Tangente: Dovrebbe essere il caso che un valore non possa passare a un'altra espressione, ma generalmente non vale l'opposto; ci sono alcune espressioni (ad esempio 7 + "hello world" ) che non possono essere valutate ulteriormente, ma non sono valori. Lo scopo di un sistema di tipi è evitare tali situazioni.

Quindi, per dichiarare che "le funzioni sono valori" dobbiamo a priori insistere sul fatto che le funzioni siano espressioni. Nella nostra lingua, consideriamo le funzioni come valori; quindi, lambda x. x è un valore e map(lambda x. x, [1 2 3]) è un'espressione valida.

Per quanto ne so, sarebbe inutile creare una lingua in cui le funzioni siano espressioni ma non valori.

Un valore in Haskell è praticamente uguale a un valore in qualsiasi altra lingua.

Esempi di valori:

numbers     - e.g. 1, 2, 3, etc.
characters  - e.g. 'a', 'Z', '$', ...
strings     - e.g. "Hello", "foobar", ...
tuples      - e.g. (14, 'S') - a tuple of a number and the letter 'S'
functions   - e.g. \x -> x + 1
lists       - e.g. [6,5,4]
booleans    - e.g. True, False

E include anche i record definiti dall'utente e qualsiasi altra cosa tu considererebbe come "dati".

Inoltre, proprio come in Java, C #, C ++ e altri linguaggi tipizzati, ogni valore ha un tipo Alcuni esempi:

value        type
1            Integer
"Hello"      String
'X'          Char
(3,'z')      (Int, Char)

Essere un "valore di prima classe" significa che è possibile assegnare il valore a a variabile, passa come parametro a una funzione - in pratica ci sono nessuna restrizione su come è possibile crearlo o usarlo. La maggior parte dei valori in moderno le lingue sono "di prima classe" in questi giorni, ma non è sempre stato il Astuccio. Nelle prime versioni del linguaggio C l'unico le funzioni che potrebbero esistere nel tuo programma dovevano essere dichiarate a nell'ambito globale. Non c'era modo di creare una funzione con ambito locale.

Ad esempio, in questo frammento Python ho creato una nuova funzione add1 che esiste solo nell'ambito della subroutine main :

def main():
  def add1(x):
    return x+1
  print add1(5)

Questo non è possibile in K & R. Nelle prime versioni di Java non lo era possibile creare una funzione che non era una chiamata al metodo. Ma tempi sono cambiati e la maggior parte dei linguaggi di programmazione non ha questo tipo di restrizioni sulle funzioni.

Un valore è il risultato della valutazione di un'espressione.

In Haskell non c'è distinzione tra espressioni il cui risultato è una funzione e quelle che restituiscono alcuni valori di dati. Un nome di funzione è già un'espressione valida, è facile costruire funzioni anonime ecc. Questo è ciò che si intende dicendo che le funzioni sono valori di prima classe - è possibile avere espressioni che valutano le funzioni. Ma in alcune (la maggior parte?) Lingue che funzionano con le funzioni è molto più difficile.

Non direi che mai valore ha un tipo, piuttosto che ogni espressione ha un tipo. La proprietà importante è che quando viene valutata un'espressione, il valore ha lo stesso tipo dell'espressione originale. Ad esempio, se la tua funzione ha il tipo di ritorno int , ti aspetti che, in effetti, quando viene valutato, il risultato sarà un valore int .