Topic: Nil

[AWW]

I know that Nil is the return value for an expression that is evaluated as false in the if/or/while functions. But what about coding similar to this:

(Function
      nil

Thanks for any input/clarification.

[Lee Mac]

nil can also be an empty list:

nil == ()

[David Bethel]

Nil always evaluates to an empty list in LISP

(null nil) -> T
(listp nil) -> T
(equal nil '()) ->T

Not like some languages where nil is NOT T

-David

[gile]

More, nil is the only LISP data which is both considered as a list and as an atom:
(listp nil) => T
(atom nil) => T

[David Bethel]

More, nil is the only LISP data which is both considered as a list and as an atom:
(listp nil) => T
(atom nil) => T

Amazing that the help files still do not list this:

atom
Verifies that an item is an atom
(atom item)
Arguments
item
Any AutoLISP element.
Some versions of LISP differ in their interpretation of atom, so be careful when converting from non-AutoLISP code.
Return Values
Nil if item is a list; otherwise T. Anything that is not a list is considered an atom.
Examples
Command: (setq a '(x y z))
(X Y Z)
Command: (setq b 'a)
A
Command: (atom 'a)
T
Command: (atom a)
nil
Command: (atom 'b)
T
Command: (atom b)
T
Command: (atom '(a b c))
nil

-David

[AWW]

So in this case, nil is a list or atom that returns T. Always thought nil was false and T was true.

[gile]

T is true.
nil is both false and an empty list.

But you have to consider that LISP functions using predicates do not required the predicate to retun T (or nil), but a non nil value (or nil).

[Jeff H]

nil
Do you consider nil equivalent to a empty list?
Or does a empty list just point to nothing(How can you have a empty list? By definition can it really be considered a list before items are added to it?)
 
I guess those questions can depend on how you look it.
Kinda like null for some languages.
Look at it is as the bits that represent 0 or
that it points to nothing.
 
 

[gile]

Yes,
nil can be seen as null (nothing) in some languages:  a variable wich hasn't been assigned is nil, set a variable to nil is the same as set a variable to null in some languages.

How can you have a empty list? By definition can it really be considered a list before items are added to it?

Yes,
you have to consider nil as an empty list too :
(cons 1 nil) returns (1)
as [] in F#:
1 :: [] returns [1]

And it is used as false in predicate too.

[Jeff H]

I knew AutoLisp would have to have a representaion for for a empty list and was asking more in a abstract sense,
but isn't Lisp just a bunch of linked list and nil represents the tail?

[gile]

but isn't Lisp just a bunch of linked list and nil represents the tail?

Yes, nil represents the tail of the last cons cell in a linked list.

(cons 1 (cons 2 (cons 3 (cons 4 nil)))) returns (1 2 3 4)


'(1 2 3 4) is a shortcut for: '(1 . (2 . (3 . (4 . nil))))

A French thread about cons cells and linked lists

[Jeff H]

I guess someone deleted a post but had this quoted

An AutoLISP variable that has not been assigned a value is said to be nil. This is different from blank, which is considered a character string, and different from 0, which is a number. So, in addition to checking a variable for its current value, you can test to determine if the variable has been assigned a value.   
     
Each variable consumes a small amount of memory, so it is good programming practice to reuse variable names or set  variables to nil when their values are no longer needed. Setting a variable to nil releases the memory used to store that variable's value. If you no longer need the val variable, you can release its value from memory with the following expression
_$ (setq val nil)

       

I guess the difference is or I does setting a variable to a empty list  also release the value?

[hermanm]

T is true.

unless some bozo does this:

Code: [Select]

Command: (setq T nil)
nil

but:

Code: [Select]

Command: (eval t)
nil
Command: (atom t)
T

so,

Code: [Select]

Command: (setq t (atom t))
T

restores T to T

but if:

Code: [Select]

Command: (listp T)
T

we know that:

Code: [Select]

Command: (eval T)
nil

because nil is (as Gile pointed out) the only symbol which is both an atom & a list.

I know Gile knows all this - more for OP & other novices.

[Ketxu]

And Nil smaller all number ^^:

Command: (< nil -10000000)
T

Command: (< nil -10000000000000000000000000000)
T

[gile]

I guess someone deleted a post but had this quoted

An AutoLISP variable that has not been assigned a value is said to be nil. This is different from blank, which is considered a character string, and different from 0, which is a number. So, in addition to checking a variable for its current value, you can test to determine if the variable has been assigned a value.   
     
Each variable consumes a small amount of memory, so it is good programming practice to reuse variable names or set  variables to nil when their values are no longer needed. Setting a variable to nil releases the memory used to store that variable's value. If you no longer need the val variable, you can release its value from memory with the following expression
_$ (setq val nil)

       

I guess the difference is or I does setting a variable to a empty list  also release the value?

OK, I think I understand what you mean, and that makes sense.

Mainly, nil is nothing (null) because it's used to release memory, and it serves as well for some types explicitly defined in more strongly typed language (i.e. F#):
- the boolean false value
- an empty list (as [] in F#)
- the absence of a specific value as argument or function return (as () the F# unit type)

Here're some examples comparinf AutoLISP and F# (which is the strongly typed language closest to lISP I know).

nil as null (null isn't often used with F# which avoid the use mutable variables as it's more an imperative behavior)

Code: [Select]

_$ (setq s "foo")
"foo"
_$ (setq s nil)
nil

Code: [Select]

> let mutable s = "foo" ;;
val mutable s : string = "foo"

> s <- null ;;
val it : unit = ()

nil as false

Code: [Select]

_$ (= 0 1)
nil

Code: [Select]

> 0 = 1 ;;
val it : bool = false

nil as empty list

Code: [Select]

_$ (setq l nil)
nil
_$ (cons 1 l)
(1)

Code: [Select]

> let l = [] ;;

val l : 'a list

> 1 :: l ;;
val it : int list = [1]

nil as absence of a specific value

Code: [Select]

_$ (defun foo nil (alert "Hello"))
FOO
_$ (foo)
nil

Code: [Select]

> let foo () = printfn "Hello" ;;
val foo : unit -> unit

> foo () ;;
Hello
val it : unit = ()