The empty list

Post by lisper » Sat, Dec 17, 2022, 3:58 PM UTC

rosebay wrote: post #8

lisper wrote: post #4

> It is necessary that there be a special empty-list object which is a list but not a cons. That is not true. NIL could be a CONS. In fact, it acts just like a CONS whose CAR and CDR are itself. The only way in which NIL does not behave like a CONS is that it does not answer true to CONSP. But that doesn't matter because it answers true to NULL, so you can build a CL-style CONSP if you want it by checking for (AND (C…

I tend to agree but would be happy to be proven wrong by more knowledgeable folks in these comments. However I assume here we are talking about dotted lists and not ‘proper’ ones?

    (setf NIL (cons 0 0)))
    (setf (car NIL) NIL)
    (setf (cdr NIL) NIL)

    (defun null (thing) (eq thing NIL))

    (defun cl-style-consp (thing)
      (and (consp thing) (not (null thing)))
    (defun cl-style-symbolp (thing)
      (or (symbolp thing) (null thing))
    (defun cl-style-symbol-name (thing)
      (if (null thing) "NIL" (symbol-name thing)))

Post by kmstout » Sat, Dec 17, 2022, 4:00 PM UTC

lisper wrote: post #6

djha-skin wrote: post #3

It's very difficult to deserialize in serialize things like yaml and json in CL because it doesn't have a distinct false object. When you do deserialize `false` it turns into nil. Then when you serialize it back again it turns into `null`. From a practical perspective, this is annoying. I don't hate using it as a language, it's fine, but because it's different enough than other languages it confuses people.

I share your frustration, particularly since one could add a canonical false value to CL in a backwards-compatible way. But it's too late now. But as a practical solution you could de-serialize false into, say, :false, in order to distinguish them from empty lists, and then do a post-processing step to turn those into nils if you wanted to.

Post by lisper » Sat, Dec 17, 2022, 4:06 PM UTC

kmstout wrote: post #13

lisper wrote: post #6

Earlier quoted context omitted.

I share your frustration, particularly since one could add a canonical false value to CL in a backwards-compatible way. But it's too late now. But as a practical solution you could de-serialize false into, say, :false, in order to distinguish them from empty lists, and then do a post-processing step to turn those into nils if you wanted to.

> you could de-serialize false into, say, :false ... That's the approach that st-json [0] builds on: - true and false become :true and :false, respectively - [] becomes nil - {} becomes #s(st-json:jso :alist nil) --- [0] in QuickLisp and at https://github.com/marijnh/ST-JSON

Post by mik1998 » Sat, Dec 17, 2022, 4:25 PM UTC

Post by mtreis86 » Sat, Dec 17, 2022, 4:31 PM UTC

lisper wrote: post #11

rosebay wrote: post #8

Earlier quoted context omitted.

I tend to agree but would be happy to be proven wrong by more knowledgeable folks in these comments. However I assume here we are talking about dotted lists and not ‘proper’ ones?

No. Dotted lists are just a notational convention. All lists can be written in dotted notation. You can define NIL as follows: (setf NIL (cons 0 0))) (setf (car NIL) NIL) (setf (cdr NIL) NIL) Then: (defun null (thing) (eq thing NIL)) You also have to add a bunch of special cases to other functions: (defun cl-style-consp (thing) (and (consp thing) (not (null thing))) (defun cl-style-symbolp (thing) (or (symbolp thing)…

    CL-USER> (equalp '(1 2 3)
                     '(1 . (2 . (3 . nil))))
    => T