Esiste un nome tipico per una funzione come "map" che opera su un elenco di elenchi di argomenti anziché su più elenchi di argomenti?

Question

(ho finalmente inviato e accettato una risposta all'effetto "no, non c'è, e la domanda non è in realtà quella generale".)

Considerare la funzione Common map Lisp 'mapcar'. Prende una funzione e alcune liste come argomenti, e chiama la funzione con argomenti estratti dalla stessa posizione in ogni lista.

Le librerie standard hanno in genere una funzione simile che accetta un singolo elenco, in cui ogni elemento dell'elenco è un elenco di argomenti per la funzione? Che cosa è una funzione come quella che si chiama in genere "standard" o no? (Questo non vuole essere una domanda Lisp, ma è l'unico linguaggio funzionale + libreria che metà so.)

Credo che sto chiedendo se un'operazione come (in pseudo-Lisp):

(mapcar (curry #'apply function-to-map) list-of-arg-lists) 

ha già un nome comune in più lingue o librerie (nello stesso modo in cui 'mappa' e 'reduce' sono nomi per operazioni comuni, non solo funzioni di libreria specifiche).

Grazie.

Answer 1

Non c'è davvero un tipico "programmazione funzionale" nome per la suddetta operazione specifica. In effetti, il modo in cui ho formulato la domanda presuppone un linguaggio che funzioni come Lisp, in cui le funzioni vengono applicate agli elenchi di argomenti. Assume anche che la "mappatura" in primo luogo significhi fare qualcosa come la "mappa" di Lisp.

Non tutte le lingue funzionano in questo modo. Ad esempio, le funzioni Haskell accettano solo un argomento tipizzato (vedere le altre risposte e i commenti e http://www.haskell.org/tutorial/index.html). Mappare una funzione che prende un tipo di tupla su un elenco di quel tipo è concettualmente simile all'operazione che stavo chiedendo, e in quel caso la funzione rilevante è ... 'mappa'.

Per quanto riguarda il Lisp è interessato, questo è solo il modo in cui la versione 'mapcar' di mappare una funzione più di argomenti funziona - zip gli elenchi che prende come input e applica la funzione per mappare le liste di argomenti che ne derivano. Alcune altre funzioni potrebbero invece prendere facilmente gli elenchi degli argomenti compressi e comunque essere chiamate alcune varianti di "mappa".

Grazie a tutti coloro che hanno contribuito a quello che per me è stato educativo.

Answer 2

Nominare map-apply o forse mapply se si desidera utilizzarlo da soli o in un piccolo gruppo.

(defun map-apply (fn arg-lists) 
    (mapcar (lambda (arg-list) (apply fn arg-list)) 
      arg-lists)) 

(map-apply #'+ '((1 2) (3 4 5))) 
    => 
(3 12) 

EDIT Naturalmente il vostro non è solo pseudo-Lisp se avete curry:

(defun curry (f &rest values) 
    (lambda (&rest more-values) 
     (apply f (append values more-values)))) 

Answer 3

Si consideri la funzione Common Lisp 'mapcar'. Prende una funzione e alcune liste come argomenti, e chiama la funzione con argomenti estratti dalla stessa posizione in ogni lista.

Le librerie standard hanno in genere una funzione simile che accetta un singolo elenco, in cui ogni elemento dell'elenco è un elenco di argomenti per la funzione?

Beh, Haskell definisce una serie di zipWithN -Funzioni che hanno effetti simili a mapcar per il conteggio degli argomenti costanti.

zipWith (\a b -> a + b) [1, 2, 3] [1, 2, 3]     => [2, 4, 6] 
zipWith3 (\a b c -> a + b + c) [1, 2, 3] [1, 2, 3] [4, 5, 6] => [6, 9, 12] 

Generalizzando questo concetto per una lista di liste si tradurrà in questa funzione (ingenuamente implementata) zipWithMany

zipWithMany :: ([a] -> b) -> [[a]] -> [b] 
zipWithMany f lists 
    | any null lists = [] 
    | otherwise  = (f $ map head lists) : zipWithMany f (map tail lists) 

Esempio:

zipWithMany sum [[1, 2, 3], [1, 2, 3], [1, 2]] => [3, 6]