how to check if a list is empty or nil?

(not (= lst nil))

(/= lst nil)

empty?, list?, nil? does not work either.

do I really have to use (= 0 (length lst))
seems inefficient if the lists can be big.

On Aug 23, 10:59*am, ssecorp <circularf...@gmail.com> wrote:
> (not (= lst nil))
>
> (/= lst nil)
>
> empty?, list?, nil? does not work either.
>
> do I really have to use (= 0 (length lst))
> seems inefficient if the lists can be big.
Use NULL. ENDP also works.

ssecorp wrote:
> (not (= lst nil))
>
> (/= lst nil)
>
> empty?, list?, nil? does not work either.
>
> do I really have to use (= 0 (length lst))
> seems inefficient if the lists can be big.

lst. Or list if you realize you are not doing scheme.

kt

On Aug 23, 6:19*pm, Kenny <kentil...@gmail.com> wrote:
> ssecorp wrote:
> > (not (= lst nil))
>
> > (/= lst nil)
>
> > empty?, list?, nil? does not work either.
>
> > do I really have to use (= 0 (length lst))
> > seems inefficient if the lists can be big.
>
> lst. Or list if you realize you are not doing scheme.
>
> kt

huh?

In article
<8ef28f1e-2d71-482d-9e6c-10c18407a5b8@m73g2000hsh.googlegroups.com>,
ssecorp <circularfunc@gmail.com> wrote:

> (not (= lst nil))
>
> (/= lst nil)

= and /= are for numbers. EQ is the predicate you should use if you
want to compare with NIL.

>
> empty?, list?, nil? does not work either.

Others have mentioned NULL. There's also NOT (although that should
generally only be used when you're treating it as a boolean, rather than
a list) and ENDP (which is generally used when you're iterating, hence
the name).

>
> do I really have to use (= 0 (length lst))
> seems inefficient if the lists can be big.

--
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

On Aug 23, 11:42*am, ssecorp <circularf...@gmail.com> wrote:
> On Aug 23, 6:19*pm, Kenny <kentil...@gmail.com> wrote:
>
> > ssecorp wrote:
> > > (not (= lst nil))
>
> > > (/= lst nil)
>
> > > empty?, list?, nil? does not work either.
>
> > > do I really have to use (= 0 (length lst))
> > > seems inefficient if the lists can be big.
>
> > lst. Or list if you realize you are not doing scheme.
>
> > kt
>
> huh?

I think Kenny's point is that you can use the name "list" rather than
"lst", and this will not conflict with the function (named "list")
because, unlike scheme, CL has a separate namespace for functions.

On 23 Aug, 16:59, ssecorp <circularf...@gmail.com> wrote:
> (not (= lst nil))
>
> (/= lst nil)
>
> empty?, list?, nil? does not work either.
>
> do I really have to use (= 0 (length lst))
> seems inefficient if the lists can be big.

The empty list is false so you can write

(if list
(do stuff);non-empty case
(do other stuff));empty case

Otherwise do what Barry says.

DeverLite <derby.little@gmail.com> writes:

> On Aug 23, 11:42*am, ssecorp <circularf...@gmail.com> wrote:
>> On Aug 23, 6:19*pm, Kenny <kentil...@gmail.com> wrote:
>>
>> > ssecorp wrote:
>> > > (not (= lst nil))
>>
>> > > (/= lst nil)
>>
>> > > empty?, list?, nil? does not work either.
>>
>> > > do I really have to use (= 0 (length lst))
>> > > seems inefficient if the lists can be big.
>>
>> > lst. Or list if you realize you are not doing scheme.
>>
>> > kt
>>
>> huh?
>
> I think Kenny's point is that you can use the name "list" rather than
> "lst", and this will not conflict with the function (named "list")
> because, unlike scheme, CL has a separate namespace for functions.

No. Kenny's point is that to test for a not null list you can just
write list. In the same way that in C, to test for a non zero integer
you can just write integer.


And the OP should try reading some initiation book about Common Lisp,
like:

Common Lisp: A Gentle Introduction to Symbolic Computation
http://www-cgi.cs.cmu.edu/afs/cs.cmu...ook/index.html
http://www.cs.cmu.edu/~dst/LispBook/


--
__Pascal Bourguignon__ http://www.informatimago.com/
Kitty like plastic.
Confuses for litter box.
Don't leave tarp around.

ssecorp wrote:
> On Aug 23, 6:19 pm, Kenny <kentil...@gmail.com> wrote:
>
>>ssecorp wrote:
>>
>>>(not (= lst nil))
>>
>>>(/= lst nil)
>>
>>>empty?, list?, nil? does not work either.
>>
>>>do I really have to use (= 0 (length lst))
>>>seems inefficient if the lists can be big.
>>
>>lst. Or list if you realize you are not doing scheme.
>>
>>kt
>
>
> huh?

1. nil is false
2. there is no need to mangle the name
3. 1 and 2 are false in Scheme

kt