*Class
- A global variable holding the current class. See also
OO Concepts
, class
, extend
, dm
and var
and rel
.
: (class +Test)
-> +Test
: *Class
-> +Test
(caaar 'lst) -> any
- List access shortcut: Equivalent to
(car (car (car 'lst)))
.
: (caaar '(((1 2) 3) 4))
-> 1
(caadr 'lst) -> any
- List access shortcut: Equivalent to
(car (car (cdr 'lst)))
.
: (caadr '(1 (2 3)))
-> 2
(caar 'lst) -> any
- List access shortcut: Equivalent to
(car (car 'lst))
.
: (caar '((1 2) (3 4)))
-> 1
(cache 'var 'sym . prg) -> any
- Speeds up some calculations, by holding previously calculated results in an
idx
tree structure. sym
must be a transient symbol representing a unique key for the argument(s) to the
calculation.
: (de fibonacci (N)
(cache '*Fibonacci (format N)
(if (< N 2)
1
(+
(fibonacci (dec N))
(fibonacci (- N 2)) ) ) ) )
-> fibonacci
: (fibonacci 22)
-> 28657
: (fibonacci 10000)
-> 5443837311356528133873426099375038013538 ... # (2090 digits)
(cadar 'lst) -> any
- List access shortcut: Equivalent to
(car (cdr (car 'lst)))
.
: (cadar '((1 2 3)))
-> 2
(cadddr 'lst) -> any
- List access shortcut: Equivalent to
(car (cdr (cdr (cdr
'lst))))
, or the fourth element of lst
.
: (cadddr (1 2 3 4 5 6))
-> 4
(caddr 'lst) -> any
- List access shortcut: Equivalent to
(car (cdr (cdr 'lst)))
, or
the third element of lst
.
: (caddr (1 2 3 4 5 6))
-> 3
(cadr 'lst) -> any
- List access shortcut: Equivalent to
(car (cdr 'lst))
, or the
second element of lst
.
: (cadr (1 2 3 4 5 6))
-> 2
(call 'any ..) -> flg
- Calls an external system command. The
any
arguments specify the
command and its arguments. Returns T
if the command was executed
successfully.
: (when (call 'test "-r" "file.l") # Test if file exists and is readable
(load "file.l") # Load it
(call 'rm "file.l") ) # Remove it
(car 'lst) -> any
- List access: Returns the first element of
lst
.
: (car (1 2 3 4 5 6))
-> 1
(case 'any (any1 . prg1) (any2 . prg2) ..) -> any
- Multi-way branch:
any
is evaluated and compared to the CAR
elements anyN
of each clause. If one of them is a list,
any
is in turn compared to all elements of that list.
T
is a catch-all for any value. If a comparison succeeds,
prgN
is executed, and the result returned. Otherwise
NIL
is returned.
: (case (char 66) ("A" (+ 1 2 3)) (("B" "C") "Bambi") ("D" (* 1 2 3)))
-> "Bambi"
(catch 'any . prg) -> any
- Sets up the environment for a non-local jump which may be caused by
throw
or by a runtime error. If
any
is an atom, it is used by throw
as a jump label
(with T
being a catch-all for any label), and a throw
called during the execution of prg
will immediately return the
thrown value. Otherwise, any
should be a list of strings, to catch
any error whose message contains one of these strings, and this will immediately
return the matching string. If neither throw
nor an error occurs,
the result of prg
is returned. See also finally
, quit
and
Error Handling
.
: (catch 'Ok (println 1) (throw 'Ok 999) (println 2))
1
-> 999
: (catch '("No such file") (in "doesntExist" (foo)))
-> "No such file"
(cd 'any) -> sym
- Changes the current directory to
any
. The old directory is
returned on success, otherwise NIL
. See also dir
and pwd
.
: (when (cd "lib")
(println (sum lines (dir)))
(cd @) )
10955
(cdaar 'lst) -> any
- List access shortcut: Equivalent to
(cdr (car (car 'lst)))
.
: (cdaar '(((1 2 3))))
-> (2 3)
(cdadr 'lst) -> any
- List access shortcut: Equivalent to
(cdr (car (cdr 'lst)))
.
: (cdadr '((1 2) (3 4)))
-> (4)
(cdar 'lst) -> any
- List access shortcut: Equivalent to
(cdr (car 'lst))
.
: (cdar '((1 2) (3 4)))
-> (2)
(cddar 'lst) -> any
- List access shortcut: Equivalent to
(cdr (cdr (car 'lst)))
.
: (cddar '((1 2 3 4)))
-> (3 4)
(cddddr 'lst) -> any
- List access shortcut: Equivalent to
(cdr (cdr (cdr (cdr
'lst))))
. Returns all but the first four elements of lst
.
: (cddddr (1 2 3 4 5 6))
-> (5 6)
(cdddr 'lst) -> any
- List access shortcut: Equivalent to
(cdr (cdr (cdr 'lst)))
.
Returns all but the first three elements of lst
.
: (cdddr (1 2 3 4 5 6))
-> (4 5 6)
(cddr 'lst) -> any
- List access shortcut: Equivalent to
(cdr (cdr 'lst))
. Returns
all but the first two elements of lst
.
: (cddr (1 2 3 4 5 6))
-> (3 4 5 6)
(cdr 'lst) -> any
- List access: Returns all but the first element of
lst
.
: (cdr (1 2 3 4 5 6))
-> (2 3 4 5 6)
(center 'cnt|lst 'any ..) -> sym
- Returns a transient symbol with all
any
arguments pack
ed in a centered format. Trailing blanks
are omitted. See also align
, tab
and wrap
.
: (center 4 12)
-> " 12"
: (center 4 "a")
-> " a"
: (center 7 "a")
-> " a"
: (center (3 3 3) "a" "b" "c")
-> " a b c"
(chain 'lst ..) -> lst
- Concatenates (destructively) one or several new list elements
lst
to the end of the list in the current make
environment. This operation is efficient
also for long lists, because a pointer to the last element of the list is
maintained. chain
returns the last linked argument. See also
link
, yoke
and made
.
: (make (chain (list 1 2 3) NIL (cons 4)) (chain (list 5 6)))
-> (1 2 3 4 5 6)
(char) -> sym
(char 'cnt) -> sym
(char T) -> sym
(char 'sym) -> cnt
- When called without arguments, the next character from the current input
stream is returned as a single-character transient symbol, or
NIL
upon end of file. When called with a number cnt
, a character with
the corresponding unicode value is returned. As a special case, T
is accepted to produce a byte value greater than any first byte in a UTF-8
character (used as a top value in comparisons). Otherwise, when called with a
symbol sym
, the numeric unicode value of the first character of the
name of that symbol is returned. See also peek
, skip
, key
, line
, till
and eof
.
: (char) # Read character from console
A # (typed 'A' and a space/return)
-> "A"
: (char 100) # Convert unicode to symbol
-> "d"
: (char T) # Special case, catch all
-> # (not printable)
: (char "d") # Convert symbol to unicode
-> 100
(chdir 'any . prg) -> any
- Changes the current directory to
any
with cd
during the execution of prg
. Then
the previous directory will be restored and the result of prg
returned. See also dir
and pwd
.
: (pwd)
-> "/usr/abu/pico"
: (chdir "src" (pwd))
-> "/usr/abu/pico/src"
: (pwd)
-> "/usr/abu/pico"
(chkTree 'sym ['fun]) -> num
- Checks a database tree node (and recursively all sub-nodes) for consistency.
Returns the total number of nodes checked. Optionally,
fun
is
called with the key and value of each node, and should return NIL
for failure. See also tree
and
root
.
: (show *DB '+Item)
{C} NIL
sup (7 . {7-3})
nr (7 . {7-1}) # 7 nodes in the 'nr' tree, base node is {7-1}
pr (7 . {7-4})
nm (77 . {7-6})
-> {C}
: (chkTree '{7-1}) # Check that node
-> 7
(chop 'any) -> lst
- Returns
any
as a list of single-character strings. If
any
is NIL
or a symbol with no name, NIL
is returned. A list argument is returned unchanged.
: (chop 'car)
-> ("c" "a" "r")
: (chop "Hello")
-> ("H" "e" "l" "l" "o")
(circ 'any ..) -> lst
- Produces a circular list of all
any
arguments by cons
ing them to a list and then connecting the
CDR of the last cell to the first cell. See also list
.
: (circ 'a 'b 'c)
-> (a b c .)
(class sym . typ) -> obj
- Defines
sym
as a class with the superclass(es)
typ
. As a side effect, the global variable *Class
is set to obj
. See also
extend
, dm
, var
,
rel
, type
, isa
and object
.
: (class +A +B +C +D)
-> +A
: +A
-> (+B +C +D)
: (dm foo> (X) (bar X))
-> foo>
: +A
-> ((foo> (X) (bar X)) +B +C +D)
(clip 'lst) -> lst
- Returns a copy of
lst
with all white space characters or
NIL
elements removed from both sides. See also trim
.
: (clip '(NIL 1 NIL 2 NIL))
-> (1 NIL 2)
: (clip '(" " a " " b " "))
-> (a " " b)
(close 'cnt) -> cnt | NIL
- Closes a file descriptor
cnt
, and returns it when successful.
Should not be called inside an out
body
for that descriptor. See also open
,
listen
and connect
.
: (close 2) # Close standard error
-> 2
(cmd [any]) -> sym
- When called without an argument, the name of the command that invoked the
picolisp interpreter is returned. Otherwise, the command name is set to
any
. Setting the name may not work on some operating systems. Note
that the new name must not be longer than the original one. See also argv
and Invocation
.
$ ./p dbg.l
: (cmd)
-> "./bin/picolisp"
: (cmd "!/bin/picolust")
-> "!/bin/picolust"
: (cmd)
-> "!/bin/picolust"
(cnt 'fun 'lst ..) -> cnt
- Applies
fun
to each element of lst
. When
additional lst
arguments are given, their elements are also passed
to fun
. Returns the count of non-NIL
values returned
from fun
.
: (cnt cdr '((1 . T) (2) (3 4) (5)))
-> 2
(collect 'var 'cls ['hook] ['any|beg ['end [var ..]]])
- Returns a list of all database objects of class
cls
, where the
values for the var
arguments correspond to the any
arguments, or where the values for the var
arguments are in the
range beg
.. end
. var
, cls
and hook
should specify a tree
for cls
or one of its
superclasses. If additional var
arguments are given, the final
values for the result list are obtained by applying the get
algorithm. See also db
, aux
,
fetch
, init
and step
.
: (collect 'nr '+Item)
-> ({3-1} {3-2} {3-3} {3-4} {3-5} {3-6} {3-8})
: (collect 'nr '+Item 3 6 'nr)
-> (3 4 5 6)
: (collect 'nr '+Item 3 6 'nm)
-> ("Auxiliary Construction" "Enhancement Additive" "Metal Fittings" "Gadget Appliance")
: (collect 'nm '+Item "Main Part")
-> ({3-1})
(commit ['any] [exe1] [exe2]) -> flg
- Closes a transaction, by writing all new or modified external symbols to the
database, and by removing all deleted symbols from the database. For nested
transactions, only the changes since the last call to
begin
are taken into account. A
non-NIL
any
argument forces modifications of the
current transaction level to be written out, even if this is not the top level.
When any
is anything other than T
, it is implicitly
sent (with all modified objects) via the tell
mechanism to all family members. If
exe1
or exe2
are given, they are executed as pre- or
post-expressions while the database is lock
ed and protect
ed. Returns T
when the
topmost transaction is closed. See also rollback
.
: (pool "db")
-> T
: (put '{1} 'str "Hello")
-> "Hello"
: (commit)
-> T
(con 'lst 'any) -> any
- Connects
any
to the first cell of lst
, by
(destructively) storing any
in the CDR of lst
. See
also conc
.
: (setq C (1 . a))
-> (1 . a)
: (con C '(b c d))
-> (b c d)
: C
-> (1 b c d)
(conc 'lst ..) -> lst
- Concatenates all argument lists (destructively). See also
append
and con
.
: (setq A (1 2 3) B '(a b c))
-> (a b c)
: (conc A B) # Concatenate lists in 'A' and 'B'
-> (1 2 3 a b c)
: A
-> (1 2 3 a b c) # Side effect: List in 'A' is modified!
(cond ('any1 . prg1) ('any2 . prg2) ..) -> any
- Multi-way conditional: If any of the
anyN
conditions evaluates
to non-NIL
, prgN
is executed and the result returned.
Otherwise (all conditions evaluate to NIL
), NIL
is
returned. See also nond
, if
, if2
and when
.
: (cond
((= 3 4) (println 1))
((= 3 3) (println 2))
(T (println 3)) )
2
-> 2
(connect 'any 'cnt) -> cnt | NIL
- Tries to establish a TCP/IP connection to a server listening at host
any
, port cnt
. any
may be either a
hostname or a standard internet address in numbers-and-dots notation. Returns a
socket descriptor cnt
, or NIL
if the connection cannot
be established. See also listen
and
nagle
.
: (connect "localhost" 4444)
-> 3
(cons 'any ['any ..]) -> lst
- Constructs a new list cell with the first argument in the CAR and the second
argument in the CDR. If more than two arguments are given, a corresponding chain
of cells is built.
(cons 'a 'b 'c 'd)
is equivalent to (cons
'a (cons 'b (cons 'c 'd)))
. See also list
.
: (cons 1 2)
-> (1 . 2)
: (cons 'a '(b c d))
-> (a b c d)
: (cons '(a b) '(c d))
-> ((a b) c d)
: (cons 'a 'b 'c 'd)
-> (a b c . d)
(copy 'any) -> any
- Copies the argument
any
. For lists, the top level cells are
copied, while atoms are returned unchanged.
: (=T (copy T)) # Atoms are not copied
-> T
: (setq L (1 2 3))
-> (1 2 3)
: (== L L)
-> T
: (== L (copy L)) # The copy is not identical to the original
-> NIL
: (= L (copy L)) # But the copy is equal to the original
-> T
(count 'tree) -> num
- Returns the number of nodes in a database tree. See also
tree
and root
.
: (count (tree 'nr '+Item))
-> 7
(ctl 'sym . prg) -> any
- Waits until a write (exclusive) lock (or a read (shared) lock if the first
character of
sym
is "+
") can be set on the file
sym
, then executes prg
and releases the lock. If the
files does not exist, it will be created. When sym
is
NIL
, a shared lock is tried on the current innermost I/O channel,
and when it is T
, an exclusive lock is tried instead. See also
in
, pipe
and out
. Note: It is not recommended to lock a file
by name and then do I/O on the same file, as this may give unexpected results on
some operating systems.
$ echo 9 >count # Write '9' to file "count"
$ ./p dbg.l
: (ctl ".ctl" # Exclusive control, using ".ctl"
(in "count"
(let Cnt (read) # Read '9'
(out "count"
(println (dec Cnt)) ) ) ) ) # Write '8'
-> 8
:
$ cat count # Check "count"
8
(ctty 'sym|pid) -> flg
- When called with a symbolic argument,
ctty
changes the current
TTY device to sym
. Otherwise, the local console is prepared for
serving the Pico Lisp process with the process ID pid
. See also
raw
.
: (ctty "/dev/tty")
-> T
(curry lst . fun) -> fun
- Builds a new function from the list of symbols
lst
and the
functional expression fun
. Each member in lst
that is
a pat?
symbol is substituted inside
fun
by its value. All other symbols in lst
are
collected into a job
environment.
: (de multiplier (@X)
(curry (@X) (N) (* @X N)) )
-> multiplier
: (multiplier 7)
-> ((N) (* 7 N))
: ((multiplier 7) 3))
-> 21
: (let (N1 0 N2 1)
(def 'fiboCounter
(curry (N1 N2) (Cnt)
(do Cnt
(println
(prog1
(+ N1 N2)
(setq N1 N2 N2 @) ) ) ) ) ) )
-> fiboCounter
: (pp 'fiboCounter)
(de fiboCounter (Cnt)
(job '((N2 . 1) (N1 . 0))
(do Cnt
(println
(prog1 (+ N1 N2) (setq N1 N2 N2 @)) ) ) ) )
-> fiboCounter
: (fiboCounter 5)
1
2
3
5
8
-> 8
: (fiboCounter 5)
13
21
34
55
89
-> 89
(cut 'cnt 'var) -> lst
- Pops the first
cnt
elements (CAR) from the stack in
var
. See also pop
and
del
.
: (setq S '(1 2 3 4 5 6 7 8))
-> (1 2 3 4 5 6 7 8)
: (cut 3 'S)
-> (1 2 3)
: S
-> (4 5 6 7 8)