[vim9class] using a class object or enum value as a dict key

[errael]

Note that both class and enum have the problem.

For enums, eval('Planet.earth') works in some cases to convert a string to an enum value. name was added with an enum instance variable. Then, in conjunction with eval, the idea was to use something like eval('Planet.' .. obj.name) to get the object from a string. There are problems if the enum is defined in another file and/or there are multiple enum of the same name in different files; so this is not a general solution.

Problems

• Convert object/value to unique string index.
• Convert index string back to object/value.
• Would like to have a container, like dict_ok (dict object key).

There are various things that vim can do, such as including builtin capability to assist:

1. convert object to unique string ("<SID>" must be included)
2. convert string to object (but watch out for garbage collection)
3. provide a "dict_ok" with the same interface as a dict
4. extend dict to accept an object as a key (E1324: Using an Object as a String)

In the meantime, the following comments show a way that a developer can create such a dictionary. The trick is to construct a unique ID, in these examples unique_object_id is an instance variable.

A vim provided unique_object_id would get rid of the weird GenerateKey file/code below, #14374 (comment).

In the following vim9script an id looks like

<SNR>31_SomeClassName@17

If this were provided by vim, the 17 would be something the system can use to get at the actual object (assuming such a thing actually exists). For an enum value could have something like

<SNR>47_Planet@earth

Note: earth is extracted by id->matchstr('\(@\)\@<=.*') or id[ id->stridx('@') + 1 : ]; I like id->split('@')[1]. So with a unique id, the name instance variable is not needed. The same variable name could be used with both an enum and class instance.

An alternative to unique_object_id member variable would be a builtin function; this would avoid any backward comaptibility issues but with a performance cost.

A vim builtin could take this unique id and return the object. A null/empty-thing should be returned if the object is not found; garbage collected or non-existent, an exception if malformed.

This is developed from #14330 (comment) and its following comments.

Related: @zzzyxwvut did some work on object serialization. See #14330 (comment) and following comments in that thread.

[errael]

This code is a working solution with vim 9.1.255 and later.

Note that this solution keeps a reference to the object key. This

• Avoids the key from being garbage collected.
• Facilitates conversion of the string key back to the object.

The file in the next comment is imported. If vim provided unique_object_id that wouldn't be needed.

However, notice that with a vim provided unique key, the key type as an object; but there is no way to do that. It's been mentioned that being able to specify a type as object, for example

def Put(key: object, value: X)

would be handy in various situations. This is another case.

vim9script

# Like a "dict_ok<IObjKey, any>" where key:IObjKey, type:any type
# See below to create a dictionary with strict type checking (compile time).

# var dok = DictObjKey.new()

import autoload './obj_key.vim'

export abstract class DictObjKeyBase 

    var _d: dict<list<any>>

    def len(): number
        return this._d->len()
    enddef

    def empty(): bool
        return this._d->len() == 0
    enddef

    def StringKeys(): list<string>
        return this._d->keys()
    enddef
endclass

## For strict type checking, import this file to get "DictObjKeyBase"
## copy the following and change KeyType/ValueType as needed.
##
## Note: "KeyType" must implement "obj_key.IObjKey".

type ValueType = any
type KeyType = obj_key.IObjKey

export class DictObjKey extends DictObjKeyBase

    def Put(key: KeyType, value: ValueType)
        this._d[key.unique_object_id] = [ key, value ]
    enddef

    def Get(key: KeyType): ValueType
        return this._d[key.unique_object_id][1]
    enddef

    def StringKeyToObj(key: string): KeyType
        return this._d[key][0]
    enddef

    def Keys(): list<KeyType>
        # can optimize: for loop, inline StringKeyToObj
        return this._d->keys()->mapnew((i, k) => this.StringKeyToObj(k))
    enddef
endclass

[errael]

This code automatically creates a unique_object_id by examining the stack to determine the unique class name that can be assigned to an object. Lets hope it goes away soon.

Here's an example of a class that can be added to the dictionary defined above.

vim9script

import './obj_key.vim'

export class ExampleClass implements obj_key.IObjKey
    const unique_object_id = obj_key.GenerateKey()
endclass

And here's obj_key.vim

vim9script

# Generated key is of the form "<SNR>45_SomeClass@17".

export interface IObjKey
    var unique_object_id: string
endinterface

# This is a helper sub-class. Or use the interface directly
export abstract class ObjKey implements IObjKey
    const unique_object_id: string
    # Following fails, see
    #   [vim9class] vim9 seems to get confused about what file is executing
    #   https://github.com/vim/vim/issues/14402
    # const unique_object_id = GenerateKey() 
endclass

# Return unique key for calling object. Must be called from class "new*".
export def GenerateKey(): string
    return GenerateKeyFromStack(expand('<stack>'))
enddef

######################################################################

# following requires at least vim 9.1.255

# Parse the argument stack and find the caller,
# which is a constructor,"new*", (if caller is not a new, error)
# and return the caller's unique id.
def ExtractCaller(stack: string): string
    # The caller's frame is the second to the last
    var s1 = stack->split('\.\.')[-2]

    # Extract '<SNR>45_C0.Fun' from 'function <SNR>45_C0.Fun[1]'
    # and split it into "['<SNR>45_C0', 'Fun']".
    var l1 = matchstr(s1, '<[^\[]*')->split('\.')

    if l1->len() != 2
        echoerr printf("'%s' not a class", l1)
    elseif l1[1] !~ 'new.*'
        echoerr printf("'%s' not invoked from new", l1)
    endif

    return l1[0]
enddef

var obj_id_count_script = 1

def GenerateKeyFromStack(stack: string): string
    var the_key = ExtractCaller(stack) .. '@' .. string(obj_id_count_script)
    obj_id_count_script += 1
    return the_key
enddef

[errael]

@zzzyxwvut , @yegappan you might find this interesting

[errael]

For any readers, there's an interesting example at #14330 (comment)

[errael]

This is an example of creating an object dictionary that does strict type checking. If there were generics, this would look like

DictObjKey<KeyType, ValueType>

The example:

vim9script

import './obj_key.vim'
import './dict_ok.vim'

export class ExampleClass implements obj_key.IObjKey
    const unique_object_id = obj_key.GenerateKey()
endclass

# if you don't want a dictionary with strict type checking, use DictObjKey as:
#       export class ExampleClassDict extends dict_ok.DictObjKey
#       endclass
# otherwise do the following for compile type checking and best performance.

## Following copied from dict_ok_template.vim.
## With KeyType/ValueType modified 

type ValueType = string
type KeyType = ExampleClass


export class ExampleClassDict extends dict_ok.DictObjKeyBase

    def Put(key: KeyType, value: ValueType)
        this._d[key.unique_object_id] = [ key, value ]
    enddef

    def Get(key: KeyType): ValueType
        return this._d[key.unique_object_id][1]
    enddef

    def StringKeyToObj(key: string): KeyType
        return this._d[key][0]
    enddef

    def Keys(): list<KeyType>
        # can optimize: for loop, inline StringKeyToObj
        return this._d->keys()->mapnew((i, k) => this.StringKeyToObj(k))
    enddef

endclass

[errael]

@yegappan I've re-written this. I'd appreciate any comments; in particular about vim generated unique_object_id, aka as_key.

[yegappan]

Thanks for working on this. I will review this later this week.

[errael]

There's an obvious way to avoid the risk of a name conflict for a variable that provides a unique object id/key. How could I forget, dunder to the rescue. Something like __key could be used. Then obj.__key.