memoization

I have 2 expensive Generic methods: public T DoStuff<T>() { //return depends on T. } public T DoStuffBasedOnString<T>(string input) { //return depends on T. } Their return values can never vary for a given Type and string. Is it possible to memoize these functions? My starting point is a memoize function taken from here: https://www.aleksandar.io/post/memoization/ public static Func<T, TResult> Memoize<T, TResult>(this Func<T, TResult> f) { var cache = new ConcurrentDictionary<T, TResult>(); return a => cache.GetOrAdd(a, f); } 来源： https://stackoverflow.com/questions/56269443/can-i-memoize-a

I'm developing my own functional-programming library, and now referring the underscore . memoize _.memoize(function, [hashFunction]) Memoizes a given function by caching the computed result. Useful for speeding up slow-running computations. If passed an optional hashFunction, it will be used to compute the hash key for storing the result, based on the arguments to the original function. The default hashFunction just uses the first argument to the memoized function as the key. var fibonacci = _.memoize(function(n) { return n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2); }); The above code that

I'm trying to make a memoize decorator that works with multiple threads. I understood that I need to use the cache as a shared object between the threads, and acquire/lock the shared object. I'm of course launching the threads: for i in range(5): thread = threading.Thread(target=self.worker, args=(self.call_queue,)) thread.daemon = True thread.start() where worker is: def worker(self, call): func, args, kwargs = call.get() self.returns.put(func(*args, **kwargs)) call.task_done() The problem starts, of course, when I'm sending a function decorated with a memo function (like this ) to many

Issue: To avoid creating multiple objects or multiple queries when possible. I am using Presenters with rails as a Best Practice. I am following advice that says that it would be good to use "extend ActiveSupport.Memoizable" (and then memoize :method(s) to use them) over setting up items with @the_record = record ||= @record style because of a couple of issues - false or nil not getting stored so the query gets called again and also that memoizable uses the cache better (i.e. uses it!). However I see that memoizable is getting deprecated in rails 3.1 Notes i github under carrierwave and with

I've and Zope utility with a method that perform network processes. As the result of the is valid for a while, I'm using plone.memoize.ram to cache the result. MyClass(object): @cache(cache_key) def do_auth(self, adapter, data): # performing expensive network process here ...and the cache function: def cache_key(method, utility, data): return time() // 60 * 60)) But I want to prevent the memoization to take place when the do_auth call returns empty results (or raise network errors). Looking at the plone.memoize code it seems I need to raise ram.DontCache() exception, but before doing this I

Say I have a function that runs a SQL query and returns a dataframe: import pandas.io.sql as psql import sqlalchemy query_string = "select a from table;" def run_my_query(my_query): # username, host, port and database are hard-coded here engine = sqlalchemy.create_engine('postgresql://{username}@{host}:{port}/{database}'.format(username=username, host=host, port=port, database=database)) df = psql.read_sql(my_query, engine) return df # Run the query (this is what I want to memoize) df = run_my_query(my_query) I would like to: Be able to memoize my query above with one cache entry per value of

Polymorphic "constants", like 5 :: Num a => a , aren't really constants but functions of a dictionary argument. Hence, if you define primes :: Num n => [n] primes = ... Bad example of course, there's no good reason here to have it polymorphic... what I'm really interested is if you try to globally memoise a nontrivial polymorphic function, with e.g. memo-trie s. then this sequence won't be shared between calls from different sites, which isn't nice in terms of performance. (Isn't this the main reason the Haskell standard blessed us with the Dreaded Monomorphism Restriction?) The only way I can