Memoize last value

[cstjean]

One of my favorite light-weight memoization strategy is to just remember the result of the last call. Basically

function foo(a,b,c)
    if (a,b,c) === foo_last_args
        return foo_last_return_value
    else
        ... compute and store
    end
end

It solves the problem of the ever-growing dictionary, since only one value is stored. Are you interested in an implementation for this package?

[ExpandingMan]

I'm a little confused, wouldn't it normally wind up just looking up (a,b,c) in the dict?

I guess maybe you're suggesting that it's a common enough use case that it's worth doing just because of the clock cycles you save not looking up in the dict?

I feel like I'm missing something.

[cstjean]

Well, yes, you're saving the dict look-up, but the main win is that your memo's memory usage is constant, whereas with a dict, it grows with each cache miss. For instance, if I have f(df::DataFrame), where df is a huge table loaded from disk, I might make 50 identical calls to f with the same dataframe, then load another one, 50 calls on the new one... I don't want the memo to prevent N big dataframes from getting GC'ed. Does that make sense?

I believe it could be implemented by creating a OneKeyMap <: AbstractDict, which drops older keys, and using that in the scribe instead of Dict/IdDict.

[ExpandingMan]

My intention was that this sort of functionality would indeed be supported by other AbstractDict types.

I think I get what you're saying, but it seems to me that the solution would be deleting dict entries, that would seem much more general than what you're suggesting. There's certainly no easy way of doing that in this package at present, it might be nice to have.

Would that also accommodate your use case?

[cstjean]

Sure, if there was a convenient way of using a custom AbstractDict with @anamnesis, that'd be good enough for me. In Memoize, the syntax is @memoize Dict{Int, Int} foo(x) = x. Unfortunately, the implementation is broken.

[cstjean]

Another use case: using a vector-based associative to minimize the look-up cost.