N

(n== 'any ..) -> flg

Returns T when not all any arguments are the same (pointer equality). (n== 'any ..) is equivalent to (not (== 'any ..)). See also ==.

: (n== 'a 'a)
-> NIL
: (n== (1) (1))
-> T

(n0 'any) -> flg

Returns T when any is not a number with value zero. See also =0, lt0, ge0 and gt0.

: (n0 (- 6 3 2 1))
-> NIL
: (n0 'a)
-> T

(nT 'any) -> flg

Returns T when any is not the symbol T. See also =T.

: (nT 0)
-> T
: (nT "T")
-> T
: (nT T)
-> NIL

(nagle 'cnt 'flg) -> cnt

Disables the "nagle" algorithm for the socket descriptor cnt if flg is NIL, or enables it if flg is non-NIL. Returns the socket descriptor. See also listen and connect.

: (nagle (connect "localhost" 8080) NIL)  # Disable the nagle algorithm
-> 3

(name 'sym ['sym2]) -> sym

Returns, if sym2 is not given, a new transient symbol with the name of sym. Otherwise sym must be a transient symbol, and its name is changed to that of sym2. See also str, sym, zap and intern.

: (name 'abc)
-> "abc"
: (name "abc")
-> "abc"
: (name '{abc})
-> "abc"
: (name (new))
-> NIL
: (de foo (Lst) (car Lst))          # 'foo' calls 'car'
-> foo
: (intern (name (zap 'car) "xxx"))  # Globally change the name of 'car'
-> xxx
: (xxx (1 2 3))
-> 1
: (pp 'foo)
(de foo (Lst)
   (xxx Lst) )                      # Name changed
-> foo
: (foo (1 2 3))                     # 'foo' still works
-> 1
: (car (1 2 3))                     # Reader returns a new 'car' symbol
!? (car (1 2 3))
car -- Undefined
?

(nand 'any ..) -> flg

Logical NAND. The expressions any are evaluated from left to right. If NIL is encountered, T is returned immediately. Else NIL is returned. (nand ..) is equivalent to (not (and ..)).

: (nand (lt0 7) (read))
-> T
: (nand (lt0 -7) (read))
abc
-> NIL
: (nand (lt0 -7) (read))
NIL
-> T

(need 'cnt ['lst ['any]]) -> lst

Produces a list of at least cnt elements. When called without optional arguments, a list of cnt NIL's is returned. When lst is given, it is extended to the left (if cnt is positive) or (destructively) to the right (if cnt is negative) with any elements.

: (need 5)
-> (NIL NIL NIL NIL NIL)            # Allocate 5 cells
: (need 5 '(a b c))
-> (NIL NIL a b c)
: (need -5 '(a b c))
-> (a b c NIL NIL)
: (need 5 '(a b c) " ")             # String alignment
-> (" " " " a b c)

(new ['flg|num] ['typ ['any ..]]) -> obj

Creates and returns a new object. If flg is given and non-NIL, the new object will be an external symbol (created in database file 1 if T, or in the corresponding database file if num is given). typ (typically a list of classes) is assigned to the VAL, and the initial T message is sent with the arguments any to the new object. If no T message is defined for the classes in typ or their superclasses, the any arguments should evaluate to alternating keys and values for the initialization of the new object. See also box, object, class, type, isa, send and Database.

: (new)
-> $134426427
: (new T '(+Address))
-> {1A;3}

(next) -> any

Can only be used inside functions with a variable number of arguments (with @). Returns the next argument from the internal list. See also args, arg, rest, and pass.

: (de foo @ (println (next)))          # Print next argument
-> foo
: (foo)
NIL
-> NIL
: (foo 123)
123
-> 123

(nil . prg) -> NIL

Executes prg, and returns NIL. See also t, prog, prog1 and prog2.

: (nil (println 'Ok))
Ok
-> NIL

(noLint 'sym)
(noLint 'sym|(sym . cls) 'sym2)

Excludes the check for a function definition of sym (in the first form), or for variable binding and usage of sym2 in the function definition, file contents or method body of sym (second form), during calls to lint. See also lintAll.

: (de foo ()
   (bar FreeVariable) )
-> foo
: (lint 'foo)
-> ((def bar) (bnd FreeVariable))
: (noLint 'bar)
-> bar
: (noLint 'foo 'FreeVariable)
-> (foo . FreeVariable)
: (lint 'foo)
-> NIL

(nond ('any1 . prg1) ('any2 . prg2) ..) -> any

Negated ("non-cond") multi-way conditional: If any of the anyN conditions evaluates to NIL, prgN is executed and the result returned. Otherwise (all conditions evaluate to non-NIL), NIL is returned. See also cond, ifn and unless.

: (nond
   ((= 3 3) (println 1))
   ((= 3 4) (println 2))
   (NIL (println 3)) )
2
-> 2

(nor 'any ..) -> flg

Logical NOR. The expressions any are evaluated from left to right. If a non-NIL value is encountered, NIL is returned immediately. Else T is returned. (nor ..) is equivalent to (not (or ..)).

: (nor (lt0 7) (= 3 4))
-> T

(not 'any) -> flg

Logical negation. Returns T if any evaluates to NIL.

: (not (== 'a 'a))
-> NIL
: (not (get 'a 'a))
-> T

(nth 'lst 'cnt ..) -> lst

Returns the tail of lst starting from the cnt'th element of lst. Successive cnt arguments operate on the results in the same way. (nth 'lst 2) is equivalent to (cdr 'lst).

: (nth '(a b c d) 2)
-> (b c d)
: (nth '(a (b c) d) 2 2)
-> (c)
: (cdadr '(a (b c) d))
-> (c)

(num? 'any) -> num | NIL

Returns any when the argument any is a number, otherwise NIL.

: (num? 123)
-> 123
: (num? (1 2 3))
-> NIL