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. See also box, object, class, type, isa, send and dbase.


: (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
(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