Denominare questo costrutto del linguaggio python/ruby ​​(utilizzando i valori dell'array per soddisfare i parametri della funzione)

Question

Come viene chiamato questo linguaggio?

In Python posso dire:

def a(b,c): return b+c 
a(*[4,5]) 

e ricevere 9. Analogamente in rubino:

def a(b,c) b+c end 
a(*[4,5]) 

Come si chiama, quando si passa un singolo array ad una funzione che richieda diversamente multipla argomenti?

Qual è il nome dell'operatore *?

Quali altre lingue supportano questa interessante funzionalità?

Answer 1

I documenti Python lo chiamano Unpacking Argument Lists. È una caratteristica piuttosto utile. In Python, puoi anche usare un doppio asterisco (**) per decomprimere un dizionario (hash) in argomenti di parole chiave. Funzionano anche al contrario. Posso definire una funzione come questa:

def sum(*args): 
    result = 0 
    for a in args: 
     result += a 
    return result 

sum(1,2) 
sum(9,5,7,8) 
sum(1.7,2.3,8.9,3.4) 

Per raggruppare tutti gli argomenti in una lista di dimensioni arbitrarie.

Answer 2

L'ho chiamato "lista di espansione", ma non penso che sia la terminologia standard (non credo che ce ne sia ...). Il Lisp in tutte le versioni (Scheme included) e Haskell e altri linguaggi funzionali, possono farlo abbastanza facilmente, ma non credo sia facile da fare nelle lingue "mainstream" (forse puoi farcela come una "riflessione". in qualche!-).

Answer 3

In rubino, è spesso chiamato "splat".

Anche in ruby, è possibile utilizzarlo per indicare "tutti gli altri elementi nell'elenco".

a, *rest = [1,2,3,4,5,6] 
a  # => 1 
rest # => [2, 3, 4, 5, 6] 

Può apparire anche su entrambi i lati dell'operatore di assegnazione:

a = d, *e 

In questo utilizzo, è un po 'come CDR regime, anche se non deve essere tutto ma la testa del elenco.

Answer 4

La terminologia tipica è denominata "applicazione di una funzione a un elenco", o "apply" in breve.

Vedi http://en.wikipedia.org/wiki/Apply

E 'stato in LISP fin quasi dalla sua nascita nel 1960 dispari. pitone Glad riscoprì: -}

Apply è in genere su un lista o una rappresentazione di una lista come come un array. Tuttavia, è possibile applicare funzioni agli argomenti che provengono da altre parti, come le strutture. La nostra lingua PARLANSE ha tipi fissi (int, float, stringa, ...) e strutture. Stranamente, un elenco di argomenti funzione assomiglia molto a una definizione di struttura , e in PARLANSE, è è una definizione di struttura, ed è possibile "applicare" una funzione PARLANSE a una struttura compatibile. Si può "fare" istanze di struttura, anche, in tal modo:

 

(define S 
    (structure [t integer] 
       [f float] 
       [b (array boolean 1 3)] 
    )structure 
)define s 

    (= A (array boolean 1 3 ~f ~F ~f)) 

    (= s (make S -3 19.2 (make (array boolean 1 3) ~f ~t ~f)) 


    (define foo (function string S) ...) 

    (foo +17 3e-2 A) ; standard function call 

    (foo s) ; here's the "apply" 

PARLANSE sembra Lisp, ma non lo è.

Answer 5

Rubino chiama splat, anche se David Black ha anche venire con l'ordinata UNAR {, ra} operatore y (cioè unario operatore unarray)

Answer 6

La maggior parte delle domande sono già state risposta, ma alla domanda "Qual è il nome dell'operatore *?": il termine tecnico è "asterisco" (deriva dalla parola latina asterisco, che significa "piccola stella", che, a sua volta, proviene dal Greco 01στερίσκος). Spesso, tuttavia, verrà indicato come "stella" o, come detto sopra, "splat".

Answer 7

Haskell ha troppo (per coppie), con la funzione uncurry:

ghci> let f x y = 2*x + y 
f :: (Num a) => a -> a -> a 
ghci> f 1 2 
4 
ghci> f 10 3 
23 
ghci> uncurry f (1,2) 
4 
ghci> uncurry f (10,3) 
23 

E 'possibile fare in un operatore, quindi è più splat-simile:

ghci> f `uncurry` (1,2) 
4 
ghci> let (***) = uncurry 
(***) :: (a -> b -> c) -> (a, b) -> c 
ghci> f *** (10,3) 
23 

E anche se sarebbe facile definire funzioni simili per i casi 3-tupla, 4-tuple, etc, non c'è alcuna funzione generale per n -tuple (come splat funziona in altre lingue) a causa della rigorosa digitazione di Haskell.