Freccia destra significati a Scala

Question

nel capitolo 9 della Programmazione In Scala, c'è un metodo di esempio come questo:

def twice(op: Double => Double, x: Double) = op(op(x)) 

L'autore ha detto nel libro:

Il tipo di op in questo esempio è Double => Double, che significa che è una funzione che accetta un argomento Double come argomento e restituisce un altro Double.

non capisco ciò che è "Doppia => Doulbe" qui, nei capitoli precedenti, in cui "=>" appare solo significa letterale funzione, e mai scritto come questo "Type => Tipo", perché secondo a scala funzione letterale definizione della sintassi, la parte destra della funzione letterale è il corpo della funzione, come può un corpo funzione essere "Double"?

Answer 1

Perché ha due usi.

Innanzitutto, è possibile utilizzare => per definire la funzione letterale.

scala> val fun = (x: Double) => x * 2 
fun: (Double) => Double = <function1> 

scala> fun (2.5) 
res0: Double = 5.0 

È abbastanza facile. Ma la domanda qui è, che tipo è fun? È una "funzione che accetta un doppio come argomento e restituisce un doppio", giusto?

Quindi, come ho potuto commentare divertente con il suo tipo? Questo è (Double) => (Double). Bene, l'esempio precedente potrebbe essere riscritto a:

scala> val fun: Double => Double = (x: Double) => x * 2 
fun: (Double) => Double = <function1> 

scala> fun (2.5)          
res1: Double = 5.0 

OK, allora cosa fa il seguente codice?

def twice(op: Double => Double, x: Double) = op(op(x)) 

Beh, si dice che è un op (Double => Double), il che significa che ha bisogno di una funzione che prende un doppio e restituire un doppio.

Quindi è possibile passare la precedente funzione fun al primo argomento.

scala> def twice(op: Double => Double, x: Double) = op(op(x))  
twice: (op: (Double) => Double,x: Double)Double 

scala> twice (fun, 10) 
res2: Double = 40.0 

e sarà equivalente a sostituire op con fun, e sostituire x con 10, cioè fun(fun(10)) e il risultato sarà 40.

Answer 2

Oltre a separare la lista parametri dal corpo funzione in una funzione letterale, la freccia doppia può essere utilizzato come zucchero sintattico per un tipo di funzione personalizzataN:

T => R significa Function1[T, R]

(T1, T2) => R significa Function2[T1, T2, R]

...

Nel tuo esempio, questo significa che op è una funzione che richiede un Doub le e restituisce un doppio (come spiegato dall'autore).

Come altro esempio, è possibile scrivere

// declare len as a function that takes a String and returns an Int, 
// and define it as returning the length of its argument 
val len: String => Int = { _.length } 

// or, a more verbose version that uses '=>' in both ways 
val len: String => Int = { (s: String) => s.length } 

len("apple") // returns 5 

Answer 3

Quella è una funzione che prende un doppio e restituisce un double.

scala> def d2d = (d:Double) => d 
d2d: (Double) => Double 

tipo di E 'Function1[Double,Double]