Scheme Neuberechnung

Question

Motivation zu vermeiden:

Aus Gründen der Abstraktheit habe ich eine Methode eine Liste von Objekten zu behandeln. Hier zeige ich eine vereinfachte Version für Illustrationszwecke (mit python2.7 hier):

def foo(obj_lst, f): 
    return list(map(f, obj_lst)) 

jedoch in einigen Fällen könnte der Eingang foo([obj] * 1000, f) sein, dann in den Funktionsaufruf ich 1000 mal von f neu zu berechnen haben (obj). Wir könnten es möglicherweise vermeiden, weil alle diese genau dasselbe Objekt sind.

Meine Lösung:

Ich kann immer das Berechnungsergebnis zwischenzuspeichern, wie

def foo2(obj_lst, f): 
    cache_map = {} 
    def foo_single(obj): 
     if id(obj) not in cache_map: 
      cache_map[id(obj)] = f(obj) 
     return cache_map[id(obj)] 
    result_lst = [] 
    for obj in obj_lst: 
     result_lst.append(foo_single(obj)) 
    return result_lst 

Und das tut genau den Job ich will, und es kann in der Tat die erneute Berechnung Kopf Speedup.

Meine Frage:

Diese Lösung nicht genug ordentlich für mich ist, weil ich manuell tun, in jeder Funktion haben, wird eine bessere Lösung zur Vermeidung eines allgemeinen „same-Objekt-Neuberechnung“ da sein für nicht zufällige Funktionen? Eine globale cache_map mit Schlüsseln aus der Funktions-ID und allen Argumenten scheint nicht zu funktionieren, da die Objekt-IDs nur während ihrer Lebensdauer eindeutig sind.

Im Allgemeinen verstehe ich, dass dies in Python nicht zu viel Sinn macht, weil diese Objekte veränderbar sind. Darf ich fragen, ob es ein existierendes Schema in funktionalen Programmiersprachen wie Scala gibt, das dieses Problem für unveränderliche Objekte behandelt? Vielen Dank!

Answer 1

Sie beschreiben memoization.

Dies kann durch creating your own helper/decorator function oder mit functools.lru_cache aus der Standardbibliothek (Python 3.2 +)

Answer 2

etwas wie dies vielleicht getan werden?

import java.util.{Collections, WeakHashMap} 
case class Memoized[T,R](f: T => R) extends Function1[T,R] { 
    val mem = Collections.synchronizedMap(new WeakHashMap[T,R]) 
    def apply(t: T) = Option(mem.get(t)).getOrElse { 
     val r = f(t) 
     mem.put(t, r) 
     r 
    } 
} 

Sie können dann nur tun (unter anderem verwendet) foo(objectsWithDupes, Memoized(f))