access key and function name collision

[Junker]

In some situations, when an access key has the same name as a function, unexpected behaviour occurs.

Example.

CL-USER> (DEFVAR V1 '(:A 1 :B 2 :SORT "desc"))
V1
CL-USER> (ACCESS:WITH-DOT () 'V1.A)
(ACCESS:ACCESSES V1 'A)
CL-USER> (ACCESS:ACCESSES V1 'A)
1
CL-USER> (ACCESS:ACCESSES V1 'SORT)

invalid number of arguments: 1
   [Condition of type SB-INT:SIMPLE-PROGRAM-ERROR]

Restarts:
 0: [REPLACE-FUNCTION] Call a different function with the same arguments
 1: [CALL-FORM] Call a different form
 2: [RETRY] Retry SLIME REPL evaluation request.
 3: [*ABORT] Return to SLIME's top level.
 4: [ABORT] abort thread (#<THREAD tid=1620761 "repl-thread" RUNNING {1002000003}>)

Backtrace:
  0: (SORT (:A 1 :B 2 :SORT "desc")) [external]
  1: (ACCESS:CALL-IF-APPLICABLE (:A 1 :B 2 :SORT "desc") #<FUNCTION SORT> :WARN-IF-NOT-A-FN? NIL)
  2: (ACCESS:ACCESS (:A 1 :B 2 :SORT "desc") SORT :TYPE NIL :TEST NIL :KEY NIL :SKIP-CALL? NIL)
  3: (ACCESS:ACCESSES #<unavailable argument> SORT)
  4: (SB-INT:SIMPLE-EVAL-IN-LEXENV (ACCESS:ACCESSES V1 (QUOTE SORT)) #<NULL-LEXENV>)
  5: (EVAL (ACCESS:ACCESSES V1 (QUOTE SORT)))
 --more--

This happens because the SORT function exists and is being called.
I noticed that the ACCESS function has a SKIP-CALL? key, but it is not accessible from the ACCESSES function or with dot-syntax.
Maybe should add SKIP-CALL? key in the ACCESSES and WITH-DOT functions etc.

[vindarel]

Hi, it works if you use a :keyword and not a 'symbol to access the key:

(ACCESS:ACCESSES V1 :SORT)
;; => "desc"

best,

[Junker]

thanks for the solution for ACCESSES, but it doesn't solve problem with dot-syntax.

[vindarel]

could you explain or showcase what's the problem with the dot syntax?

[vindarel]

(now I get it)

I don't have a fix yet but another function that binds :skip-call?:

(defun accesses* (o &rest keys)
  "keep accessing keys on resulting objects
  but call access with :skip-call? to T,
  so this still accesses the object when keys are symbols which are bound
  to a function in the current package.

   eg: (accesses o 'a 'b) => (access (access o 'a :skip-call? t) 'b :skip-call? t)"
  (iter (for k in keys)
    (destructuring-bind (k &key type test key)
        (ensure-list k)
      (setf o (access o k :test test :type type :key key :skip-call? t))))
  o)

[bobbysmith007]

I have not used any lisp in quite a while. Access is nice for solving the nested-different-types-of-dictionaries but I did not use dot syntax very often, and cannot comment on the right way to fix it at this point as it was quite a lot of lines of code ago. It calls functions because classes (which are another type of data-bag) have accessor function. Sort being caught is more-or-less an accident of trying to conflate all types of dictionary into one.

[bobbysmith007]

Copied for posterity from #24

The original goal was to be able to switch between alists, plists, hashtables, and objects with a single access call, since CLOS objects use accessor function, accessing them requires searching for functions and using them to access the object.

Packages should already allow you to avoid accessing the wrong symbol. It seems like you are using the cl package or you are running this in the CL package, neither of which make much sense (to me). Your keys should be in their own package already and you should be able to look them up inside that package regardless of whats happening the in the CL package.

You already have two things listed under the cl:sort symbol the default function and your key in this dictionary. If you were to change that plist into an object, you would have to rename that symbol (or not use the cl:package) to get the correct resolution. To me it would make more sense for your keys to be in your own package, or as a keyword, or not be named the same as an already reserved CL key.

Feel free to fork this and do whatever you want, but to me, half the point of this package would be missing by removing function calls by default