if version\0 < 1:

    raise       = PRIMOP{'Fraise'}
    print       = PRIMOP{'Fprint'}
    pprint      = PRIMOP{'Fpprint'}
    pformat     = PRIMOP{'Fformat'}
    quote       = PRIMOP{'Fquote'}
    iter        = PRIMOP{'Fiter'}
    kiter       = PRIMOP{'Fkiter'}
    spawn       = PRIMOP{'Fspawn'}
    import_fast = PRIMOP{'Fimport'}     -- This one doesn't wait for the module to load
    import      = PrimaImport           -- This one does
    ask_root    = PrimaConsoleQuestion
    sleep       = PrimaSleep
    resume      = PrimaResume
    str         = PRIMOP{'Fstr'}
    format_time = PRIMOP{'Fformat_time'}
    append      = PRIMOP{'Fappend'}
    truncate    = PRIMOP{'Ftrunc'}      -- Truncate (or extend) a list in place
    length      = <l: l.__length__>
    span        = <a, b: Range(start=a, stop=b)>
    sjoin       = PRIMOP{'Fsjoin2'}
    slen        = PRIMOP{'Fslen'}       -- Getting crufty here -- we need dispatching...
    sindent     = PRIMOP{'Fsindent'}
    joinlines   = sjoin{sep='\n'}
    reversed    = PRIMOP{'Freversed'}
    read_file   = PRIMOP{'Fread_file'}
    file_lines  = PRIMOP{'Ffile_lines'}
    json        = PRIMOP{'Fjson'}
    oid         = PRIMOP{'Foid'}
    vdb_add     = PRIMOP{'Fvdb_add'}
    vdb_find    = PRIMOP{'Fvdb_find'}

    {|
     | Wait until func() returns a known value.
     |
     | The DSL compiler uses this for "x!"
     |
     | I.e., "foo.x!" desugars to
     |  wait_until_known(<foo.x>)
     |}
    def wait_until_known(func):
        for val in func:
            if val?:
                return val

    {|
     | Return the first len items of list l.
     | Returns l if length(l) <= len
     |}
    def trunc(l, len):
        if length(l) <= len:
            return l
        ll = []
        for i:v in l:
            if i >= len:
                -- break for
                return ll
            append(ll, v)
        return ll

    def list(itr):
        l = []
        for v in itr:
            append(l, v)
        return l

    def set(itr):
        s = {}
        for v in itr:
            append(s, v)
        return s

    def tuple(itr):
        return PRIMOP('Ftuple', list(itr))  -- Very inefficient, but general?

    {|
     | This adds a new property to an existing type.
     |
     | This behaves the same as if the equivalent field
     |  line was added to the original definition of type.
     |
     | Returns the resulting Property Object.
     |
     | (This isn't really needed any more since you can
     |  amend types with a normal type declaration, but
     |  useful I guess for eventual meta programming.)
     |}
    def add_property(type, mode, name, default):                    -- field syntax order
        return PRIMOP('Ftype_field2', type, name, mode, default)    -- internal logic order

    (|
     | This is a wrapper around the primitive back end which makes it possible
     |  to add/query using Objects as keys instead of strings, which we're doing
     |  by just maintaining a bi-directional mapping between those two things.
     |
     | TODO: Need a finalizer to destroy the vdb (named oid(v)) on GC
     |)
    type vdb:               -- oid(vdb) will be its vector database name
        var nextid = 0      -- used to allocate fresh keys
        val items           -- for now must manually init with an empty map ; maps object key to str value.
        val key2ob, ob2key  -- also must init with empty maps

    def new_vdb():
        return vdb(items=[:], key2ob=[:], ob2key=[:])

    def vadd(v, key, val):

        v.items[key] = val  -- v.items is our ground truth

        if not (skey = v.ob2key[key])?:
            skey           = "i{v.nextid}"
            v.nextid       = v.nextid+1
            v.key2ob[skey] = key
            v.ob2key[key]  = skey

        vdb_add(oid(v), skey, val)  -- This can update an existing key which is why it's outside the conditional

    def vfind(v, val, num):
        num = num\10    -- default parameter values not yet fully supported, but this works fine
        return [v.key2ob[skey] for skey in vdb_find(oid(v), val, num)]


    import telegram -- *** This doesn't belong here, but useful for development ***

    version = 1