(defintrinsic keyword-symbol (a))

}
function _unkeyword(k) {
    return substr(k, 3)

function _symbol2keyword(n) {
    return _keyword(_SYM_NUMBERS[n])
}

* v0.8: keyword arguments
** Special forms added

keyword-symbol
** Keyword arguments
#+begin_src glotawk
  (defun takes-kwargs (a :kw b c) (list b c))
  (takes-kwargs 42 (:b 5)) ;; => (5 nil)
#+end_src
In the parameter list of a lambda expression, you may write the symbol
~:kw~. If you do, then every symbol after that is to be looked up by
name in the keyword arguments. When the lambda is called, every
two-item list after the positional arguments is swept up into an
alist, and the parameters are assoc'd in it. If there is no keyword
argument corresponding to a keyword parameter, that parameter will be
set to nil.
Naturally, defun follows suit with this syntax.
If you already have an alist, you can use ~apply~ to pass it in as the
keyword arguments.

function _bind(vars, args, env, outer_env, d, hdlrs, st, errp,   arg_value, lexpr_list) {

# ((:kw1 (+ 1 2)) (:kw2 (* 3 5))) -> ((:kw1 3) (:kw2 15))
function _bind_kw_args_alist(args, env, outer_env, d, hdlrs, st, errp, k, v) {
    if(_is_null(args)) {
        return _nil()
    } else if(_atom_awk(args)) {
        return _error(_cons(_string("_bind_kw_args_alist: improper list"),
                            _nil()),
                      env, d, hdlrs, st, errp)
    } else {
        k = _eval3(_caar(args), env, env, d+1, hdlrs, st, errp)
        v = _eval3(_cadar(args), env, env, d+1, hdlrs, st, errp)
        return _cons(_cons(k, _cons(v, _nil())),
                     _bind_kw_args_alist(_cdr(args), env, outer_env, d, hdlrs, st, errp))
    }
}
        
function _bind_kw(vars, args_alist, env, outer_env, d, hdlrs, st, errp,    sym, dflt, v) {
    if(_is_null(vars)) {
        return outer_env
    } else if(_atom_awk(vars)) {
        # keyword LEXPR. bind vars to an alist of all the keyword args
        return _cons(_cons(vars, _cons(args_alist, _nil())),
                     outer_env)
    } else {
        # we aren't going to run out of args, because we're going to
        # default each kw parameter to something, or to nil
        sym = _car(vars)
        if(_atom_awk(sym)) {
            # just a parameter name. _assoc defaults to nil.
            v = _assoc(_symbol2keyword(sym), args_alist)
            # assoc returns the pair; take just the value
            if(!_is_null(v)) v = _cadr(v)
            logg_dbg("_bind_kw", "binding " _repr(sym) " = " _repr(v))
            return _cons(_cons(sym, _cons(v, _nil())),
                         _bind_kw(_cdr(vars), args_alist, env, outer_env, d, hdlrs, st, errp))
        } else {
            return _error(_cons(_string("_bind_kw: keyword parameter " _repr(sym) " is not an atom"), _nil()))
        }
    }
}
            
        
    
function _bind(vars, args, env, outer_env, d, hdlrs, st, errp,  arg_value, lexpr_list, bkwal) {

            logg_err("_bind", "more args than vars")

            return _error(_cons(_string("_bind: more args than vars"),
                                _nil()),
                          env, d, hdlrs, st, errp)

        if(_is_null(args)) {
            logg_err("_bind", "no args for vars " _repr(vars))
        }

        if(_is_null(args))
            return _error(_cons(_string("_bind: no args for vars " _repr(vars)),
                                _nil()),
                          env, d, hdlrs, st, errp)
        else if(_eq_awk(_car(vars), _keyword("kw"))) {
            logg_dbg("_bind", ":kw in vars. args is " _repr(args))
            bkwal = _bind_kw_args_alist(args, env, d, hdlrs, st, errp)
            logg_dbg("_bind", "bkwal is " _repr(bkwal))
            return _bind_kw(_cdr(vars),
                            bkwal,
                            env, outer_env, d, hdlrs, st, errp)
        } else {

        arg_value = _cons(_car(vars),
                          _cons(_eval3(_car(args), env, env, d+1, hdlrs, st, errp),
                                _nil()))

            arg_value = _cons(_car(vars),
                              _cons(_eval3(_car(args), env, env, d+1, hdlrs, st, errp),
                                    _nil()))

        return _cons(arg_value,
                     _bind(_cdr(vars), _cdr(args), env, outer_env, d, hdlrs, st, errp))

            return _cons(arg_value,
                         _bind(_cdr(vars), _cdr(args), env, outer_env, d, hdlrs, st, errp))
        }

    logg_dbg("_expand1", _repr(form), depth)

        return _string(substr(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp), 3))

        return _string(_unkeyword(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp)))
    else if(car == _symbol("keyword-symbol"))
        # this too depends on the keyword's atom being "k somestuff"        
        return _symbol(_unkeyword(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp)))

#    }

    }

    _symbol("keyword-symbol")

lisp_eval_should_be '(defun takes-kw-args (a :kw b c) 42)' '(*lambda (a :kw b c) 42)' 'keyword argument definition syntax'
lisp_eval_should_be '((lambda (a :kw b c) (list a b c)) 3 (:b 5))' '(3 5 ())' 'keyword argument use; nil if missing'
lisp_eval_should_be '((lambda (a :kw b c) (list a b c)) 3 (:c 7) (:b 5))' '(3 5 7)' 'keyword argument use, out of order'
lisp_eval_should_be '(label ((args '\''((:b 5) (:c 7))) (fun (lambda (a :kw b c) (list a b c)))) (apply fun 3 args))' '(3 5 7)' 'keyword args from an existing alist'