(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 <············@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.
On 23 Aug, 16:59, ssecorp <············@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.
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 <·········@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?
On Aug 23, 11:42 am, ssecorp <············@gmail.com> wrote:
> On Aug 23, 6:19 pm, Kenny <·········@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.
DeverLite <············@gmail.com> writes:
> On Aug 23, 11:42�am, ssecorp <············@gmail.com> wrote:
>> On Aug 23, 6:19�pm, Kenny <·········@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.edu/user/dst/www/LispBook/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 <·········@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
In article
<····································@m73g2000hsh.googlegroups.com>,
ssecorp <············@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, ······@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 ***