Generic types with metatable and cache implementation

Help and Feedback Scripting Support
#1

Hello all. Trying to implement a LRU cache with Luau typing in a ModuleScript, and here’s what I’ve got so far:

--!strict

local LRUCache: LRUCacheImpl = {} :: LRUCacheImpl
LRUCache.__index = LRUCache

type map<K, V> = {[K]: V}

type LRUCacheImpl = {
	__index: LRUCacheImpl,
	new: (max_size: number) -> LRUCache -- Recursive type being used with different parameters
}

export type LRUCache<K, V> = typeof(setmetatable({} :: { max_size: number, map: map<K, V> }, {} :: LRUCacheImpl))

function LRUCache.new<K, V>(max_size: number)
	local __LRUCache = setmetatable({}, LRUCache)
	__LRUCache.max_size = max_size
	local __map: map<K, V> = {}
	__LRUCache.map = __map
	return __LRUCache
end

return LRUCache

I’m trying to create a cache that will cache values in the form of {[K]: V} as denoted by the map type I’ve defined; however, this throws an error when I try something like this:

LRUCache = require(..LRUCache)
LRUStringCache = LRUCache.new<string, boolean>(2048)

From my understanding, all should be well here; what is the issue? It seems like there is something I’m not understanding properly, and the official Luau documentation w.r.t metatables is… rough, to say it kindly :slight_smile:

"Recursive type being used with different parameters" disappears whenever I delete the generic typings. Is this currently supported in Luau to begin with? The beta solver gives me a whole host of separate issues so if that’s the solution I’ll just deal with a typeless LRU cache.

EDIT: From what I’ve gleamed in RFCs and whatnot it seems like this is not currently supported under concerns of exponential explosion when dealing with potential recursive generic types, at least to my knowledge. Ah well! If anyone has any solutions or ideas please feel free to respond.

2 Likes
#2 
new: (max_size: number) -> LRUCache

I might be missing something but LRUCache isn’t a type, right? What is being returned should be a type and not a reference to a table. At the very least, you can do something like this

new: (max_size: number) -> typeof(LRUCache)
#3

It’s defined here:

2 Likes
#4

I intended LRUCache to be a type defined with two generics that would be the key-value pair in whatever internal storage mechanism I decide to run with. My issue is that it won’t let me define LRUCache<K, V> due to recursion issues. Without the generic types, it is recognized as its own type just fine

P.S. I’m following the official Luau typing guide for OOP/meta-tables, so everything type-related to a metatable is pulled from here

#5

Whoops, I am very blind lol. Based on the error, my guess is that it’s complaining that LRUCache has generic types but you don’t specify those types in LRUCacheImpl. I’m not sure if this is the “correct” way of doing things but you can fix it by turning LRUCacheImpl into a generic type as well.

type LRUCacheImpl<K, V> = {
	__index: LRUCacheImpl<K, V>,
	new: (max_size: number) -> LRUCache<K, V>
}

export type LRUCache<K, V> = typeof(setmetatable({} :: { max_size: number, map: map<K, V> }, {} :: LRUCacheImpl<K, V>))

Then for the actual implementation, you just give it two any types

local LRUCache: LRUCacheImpl<any, any> = {} :: LRUCacheImpl<any, any>

Then you can call the function like this

local LRUStringCache: LRUCache<string, boolean> = LRUCache.new(2048)
2 Likes
#6

Yup, that’s it! I see where the <any, any> declaration makes sense. It recognizes the two types perfectly and complains when their types are wrong :slight_smile:

2 Likes
#7

This topic was automatically closed 14 days after the last reply. New replies are no longer allowed.