Informazioni su "let 5 = 10`

Question

Se dico let 5 = 10, perché 5 + 1 restituisce 6 anziché 11?

Answer 1

Quando si dice

let 5 = 10 

non è una ridefinizione del 5, è un pattern matching, la stessa che si verifica quando si dice

foo 5 = undefined 
... foo 10 ... 

Il modello non è sufficiente se è sempre abbinato.

Nelle let-espressioni la corrispondenza è pigra. Ciò significa che la corrispondenza viene eseguita solo quando viene valutata una variabile vincolata da essa. Questo ci permette di scrivere cose come

let foo = undefined in 10 

Nella tua espressione, nessuna variabile è vincolata, quindi il modello non è mai abbinato.

Probabilmente tali modelli senza variabili non hanno senso nei legami e dovrebbero essere rilevati dal compilatore, ma il linguaggio non li vieta.

Answer 2

Fondamentalmente,

let 5 = 10 in ... 

è equivalente a

case 10 of ~5 -> ... 

nota la ~, che segna un pigro, o irrefutabile modello. Questo è un modello che corrisponde a tutto e che rimanda la corrispondenza al punto in cui è effettivamente richiesta una variabile. Non ci sono variabili nel modello 5, quindi non succede mai niente.

Questo caso d'angolo è abbastanza inutile, e probabilmente il compilatore dovrebbe emettere un avvertimento qui.

Per chiarire il significato di modelli pigri, considerare questo:

case f 3 of 
    (x,y) -> g 10 x y 

qui f 3 viene valutata per prima (a WHNF), esponendo il costruttore coppia. Quindi x,y sono associati ai componenti della coppia (non ancora valutata). Infine, viene calcolato g 10, il risultato viene applicato a x (che potrebbe essere richiesto ora), quindi a (che potrebbe richiedere x o).

In confronto,

case f 3 of 
    ~(x,y) -> g 10 x y 

non inizia a valutare f 3. Invece x è legato al valore non valorizzato fst (f 3) e è legato al valore non valutato snd (f 3). Iniziamo invece con la valutazione di g 10. Quindi, lo applichiamo a x: ciò potrebbe causare la richiesta di x, innescando la valutazione di f 3. Quindi, applichiamo il risultato a , causando una valutazione simile.La maggior parte dell'implementazione sarà in realtà condivide il risultato di f 3 tra x e in modo che venga calcolato al massimo una volta.

Answer 3

Come @ n. sta dicendo, tu sei il modello di corrispondenza. Ecco alcuni esempi.

modello corrisponde può avere successo

Prelude> let (a, 10) = (15, 10) in a 
15 

o fallire.

Prelude> let (a, 10) = (15, 15) in a 
*** Exception: <interactive>:5:5-22: Irrefutable pattern failed for pattern (a, 10) 

Poiché Haskell è pigro, il codice verrà eseguito correttamente se non si utilizza il valore risultante. Questo è in sostanza quello che stai facendo:

Prelude> let (a, 10) = (15, 15) in "Something else" 
"Something else" 

Nota che i tipi devono ancora verificare:

Prelude> let (a, 10, 999) = (15, 15) in "Something else" 

<interactive>:7:20: error: 
    • Couldn't match expected type ‘(t, Integer, Integer)’ 
        with actual type ‘(Integer, Integer)’ 
    • In the expression: (15, 15) 
     In a pattern binding: (a, 10, 999) = (15, 15) 
     In the expression: let (a, 10, 999) = (15, 15) in "Something else" 
    • Relevant bindings include a :: t (bound at <interactive>:7:6)