*Fork
- A global variable holding a (possibly empty)
prg
body, to be
executed after a call to fork
in the
child process.
: (push '*Fork '(off *Tmp)) # Clear '*Tmp' in child process
-> (off *Tmp)
+Fold
- Prefix class for maintaining
fold
ed indexes to +String
relations. Typically used in
combination with the +Ref
or +Idx
prefix classes. See also Database
.
(rel nm (+Fold +Idx +String)) # Item Description
...
(rel tel (+Fold +Ref +String)) # Phone number
(fail) -> lst
- Constructs an empty Pilog query, i.e. a query
that will aways fail. See also
goal
.
(dm clr> () # Clear query chart in search dialogs
(query> This (fail)) )
fail/0
- Pilog predicate that always fails. See also
true/0
.
: (? (fail))
-> NIL
(fetch 'tree 'any) -> any
- Fetches a value for the key
any
from a database tree. See also
tree
and store
.
: (fetch (tree 'nr '+Item) 2)
-> {3-2}
(fifo 'var ['any ..]) -> any
- Implements a first-in-first-out structure using a circular list. When called
with
any
arguments, they will be concatenated to end of the
structure. Otherwise, the first element is removed from the structure and
returned. See also queue
, push
, pop
, rot
and circ
.
: (fifo 'X 1)
-> 1
: (fifo 'X 2 3)
-> 3
: X
-> (3 1 2 .)
: (fifo 'X)
-> 1
: (fifo 'X)
-> 2
: X
-> (3 .)
(file) -> (sym1 sym2 . num) | NIL
- Returns for the current input channel the path name
sym1
, the
file name sym2
, and the current line number num
. If
the current input channel is not a file, NIL
is returned. See also
info
, in
and load
.
: (load (pack (car (file)) "localFile.l")) # Load a file in same directory
(fill 'any ['sym|lst]) -> any
- Fills a pattern
any
, by substituting sym
, or all
symbols in lst
, or - if no second argument is given - each pattern
symbol in any
(see pat?
),
with its current value. @
itself is not considered a pattern symbol
here. In any case, expressions following the symbol ^
should
evaluate to lists which are then (destructively) spliced into the result. See
also match
.
: (setq @X 1234 @Y (1 2 3 4))
-> (1 2 3 4)
: (fill '@X)
-> 1234
: (fill '(a b (c @X) ((@Y . d) e)))
-> (a b (c 1234) (((1 2 3 4) . d) e))
: (let X 2 (fill (1 X 3) 'X))
-> (1 2 3)
: (fill (1 ^ (list 'a 'b 'c) 9))
-> (1 a b c 9)
: (match '(This is @X) '(This is a pen))
-> T
: (fill '(Got ^ @X))
-> (Got a pen)
(filter 'fun 'lst ..) -> lst
- Applies
fun
to each element of lst
. When
additional lst
arguments are given, their elements are also passed
to fun
. Returns a list of all elements of lst
where
fun
returned non-NIL
. See also fish
, find
, pick
and extract
.
: (filter num? (1 A 2 (B) 3 CDE))
-> (1 2 3)
(fin 'any) -> num|sym
- Returns
any
if it is an atom, otherwise the CDR of its last
cell. See also last
and tail
.
: (fin 'a)
-> a
: (fin '(a . b))
-> b
: (fin '(a b . c))
-> c
: (fin '(a b c))
-> NIL
(finally exe . prg) -> any
prg
is executed, then exe
is evaluated, and the
result of prg
is returned. exe
will also be evaluated
if prg
does not terminate normally due to a runtime error or a call
to throw
. See also bye
, catch
, quit
and Error
Handling
.
: (finally (prinl "Done!")
(println 123)
(quit)
(println 456) )
123
Done!
: (catch 'A
(finally (prinl "Done!")
(println 1)
(throw 'A 123)
(println 2) ) )
1
Done!
-> 123
(find 'fun 'lst ..) -> any
- Applies
fun
to successive elements of lst
until
non-NIL
is returned. Returns that element, or NIL
if
fun
did not return non-NIL
for any element of
lst
. When additional lst
arguments are given, their
elements are also passed to fun
. See also seek
, pick
and filter
.
: (find pair (1 A 2 (B) 3 CDE))
-> (B)
: (find '((A B) (> A B)) (1 2 3 4 5 6) (6 5 4 3 2 1))
-> 4
: (find > (1 2 3 4 5 6) (6 5 4 3 2 1)) # shorter
-> 4
(fish 'fun 'any) -> lst
- Applies
fun
to each element - and recursively to all sublists -
of any
. Returns a list of all items where fun
returned
non-NIL
. See also filter
.
: (fish gt0 '(a -2 (1 b (-3 c 2)) 3 d -1))
-> (1 2 3)
: (fish sym? '(a -2 (1 b (-3 c 2)) 3 d -1))
-> (a b c d)
(flg? 'any) -> flg
- Returns
T
when the argument any
is either
NIL
or T
. See also bool
. (flg? X)
is equivalent to
(or (not X) (=T X))
.
: (flg? (= 3 3))
-> T
: (flg? (= 3 4))
-> T
: (flg? (+ 3 4))
-> NIL
(flip 'lst ['cnt]) -> lst
- Returns
lst
(destructively) reversed. Without the optional
cnt
argument, the whole list is flipped, otherwise only the first
cnt
elements. See also reverse
and rot
.
: (flip (1 2 3 4)) # Flip all four elements
-> (4 3 2 1)
: (flip (1 2 3 4 5 6) 3) # Flip only the first three elements
-> (3 2 1 4 5 6)
(flush) -> flg
- Flushes the current output stream by writing all buffered data. A call to
flush
for standard output is done automatically before a call to
key
. Returns T
when
successful. See also rewind
.
: (flush)
-> T
(fmt64 'num) -> sym
(fmt64 'sym) -> num
- Converts a number
num
to a string in base-64 notation, or a
base-64 formatted string to a number. The digits are represented with the
characters 0
- 9
, :
, ;
,
A
- Z
and a
- z
. This format
is used internally for the names of external symbols
in the 32-bit version.
See also hax
, hex
, bin
and oct
.
: (fmt64 9)
-> "9"
: (fmt64 10)
-> ":"
: (fmt64 11)
-> ";"
: (fmt64 12)
-> "A"
: (fmt64 "100")
-> 4096
(fold 'any ['cnt]) -> sym
- Folding to a canonical form: If
any
is not a symbol,
NIL
is returned. Otherwise, a new transient symbol with all digits
and all letters of any
, converted to lower case, is returned. If
the cnt
argument is given, the result is truncated to that length
(or not truncated if cnt
is zero). Otherwise cnt
defaults to 24. See also lowc
.
: (fold " 1A 2-b/3")
-> "1a2b3"
: (fold " 1A 2-B/3" 3)
-> "1a2"
fold/3
- Pilog predicate that succeeds if the first
argument, after
fold
ing it to a
canonical form, is a prefix of the folded string representation of the
result of applying the get
algorithm to
the following arguments. Typically used as filter predicate in select/3
database queries. See also
pre?
, isa/2
, same/3
, bool/3
, range/3
, head/3
, part/3
and tolr/3
.
: (?
@Nr (1 . 5)
@Nm "main"
(select (@Item)
((nr +Item @Nr) (nm +Item @Nm))
(range @Nr @Item nr)
(fold @Nm @Item nm) ) )
@Nr=(1 . 5) @Nm="main" @Item={3-1}
-> NIL
(for sym 'num ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(for sym|(sym2 . sym) 'lst ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(for (sym|(sym2 . sym) 'any1 'any2 [. prg]) ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
- Conditional loop with local variable(s) and multiple conditional exits: In
the first form, the value of
sym
is saved, sym
is
bound to 1
, and the body is executed with increasing values up to
(and including) num
. In the second form, the value of
sym
is saved, sym
is subsequently bound to the
elements of lst
, and the body is executed each time. In the third
form, the value of sym
is saved, and sym
is bound to
any1
. If sym2
is given, it is treated as a counter
variable, first bound to 1 and then incremented for each execution of the body.
While the condition any2
evaluates to non-NIL
, the
body is repeatedly executed and, if prg
is given, sym
is re-bound to the result of its evaluation. If a clause has NIL
or
T
as its CAR, the clause's second element is evaluated as a
condition and - if the result is NIL
or non-NIL
,
respectively - the prg
is executed and the result returned. If the
body is never executed, NIL
is returned. See also do
and loop
.
: (for (N 1 (>= 8 N) (inc N)) (printsp N))
1 2 3 4 5 6 7 8 -> 8
: (for (L (1 2 3 4 5 6 7 8) L) (printsp (pop 'L)))
1 2 3 4 5 6 7 8 -> 8
: (for X (1 a 2 b) (printsp X))
1 a 2 b -> b
: (for ((I . L) '(a b c d e f) L (cddr L)) (println I L))
1 (a b c d e f)
2 (c d e f)
3 (e f)
-> (e f)
: (for (I . X) '(a b c d e f) (println I X))
1 a
2 b
3 c
4 d
5 e
6 f
-> f
for/2
for/3
for/4
- Pilog predicate that generates a sequence of
numbers. See also
for
and range
.
: (? (for @I 3))
@I=1
@I=2
@I=3
-> NIL
: (? (for @I 3 7))
@I=3
@I=4
@I=5
@I=6
@I=7
-> NIL
: (? (for @I 7 3 2))
@I=7
@I=5
@I=3
-> NIL
(fork) -> pid | NIL
- Forks a child process. Returns
NIL
in the child, and the
child's process ID pid
in the parent. In the child, the
VAL
of the global variable *Fork
(should be a prg
) is
executed. See also pipe
and tell
.
: (unless (fork) (do 5 (println 'OK) (wait 1000)) (bye))
-> NIL
OK # Child's output
: OK
OK
OK
OK
(forked)
- Installs maintenance code in
*Fork
to close server sockets and clean up
*Run
code in child processes. Should
only be called immediately after task
.
: (task -60000 60000 (msg 'OK)) # Install timer task
-> (-60000 60000 (msg 'OK))
: (forked) # No timer in child processes
-> (task -60000)
: *Run
-> ((-60000 56432 (msg 'OK)))
: *Fork
-> ((task -60000) (del '(saveHistory) '*Bye))
(format 'num ['cnt ['sym1 ['sym2]]]) -> sym
(format 'sym|lst ['cnt ['sym1 ['sym2]]]) -> num
- Converts a number
num
to a string, or a string
sym|lst
to a number. In both cases, optionally a precision
cnt
, a decimal-separator sym1
and a
thousands-separator sym2
can be supplied. Returns NIL
if the conversion is unsuccessful. See also Numbers and round
.
: (format 123456789) # Integer conversion
-> "123456789"
: (format 123456789 2) # Fixed point
-> "1234567.89"
: (format 123456789 2 ",") # Comma as decimal-separator
-> "1234567,89"
: (format 123456789 2 "," ".") # and period as thousands-separator
-> "1.234.567,89"
: (format "123456789") # String to number
-> 123456789
: (format (1 "23" (4 5 6)))
-> 123456
: (format "1234567.89" 4) # scaled to four digits
-> 12345678900
: (format "1.234.567,89") # separators not recognized
-> NIL
: (format "1234567,89" 4 ",")
-> 12345678900
: (format "1.234.567,89" 4 ",") # thousands-separator not recognized
-> NIL
: (format "1.234.567,89" 4 "," ".")
-> 12345678900
(free 'cnt) -> (sym . lst)
- Returns, for the
cnt
'th database file, the next available
symbol sym
(i.e. the first symbol greater than any symbol in the
database), and the list lst
of free symbols. See also seq
, zap
and dbck
.
: (pool "x") # A new database
-> T
: (new T) # Create a new symbol
-> {2}
: (new T) # Create another symbol
-> {3}
: (commit) # Commit changes
-> T
: (zap '{2}) # Delete the first symbol
-> {2}
: (free 1) # Show free list
-> ({4}) # {3} was the last symbol allocated
: (commit) # Commit the deletion of {2}
-> T
: (free 1) # Now {2} is in the free list
-> ({4} {2})
(from 'any ..) -> sym
- Skips the current input channel until one of the strings
any
is
found, and starts subsequent reading from that point. The found any
argument, or NIL
(if none is found) is returned. See also till
and echo
.
: (and (from "val='") (till "'" T))
test val='abc'
-> "abc"
(full 'any) -> bool
- Returns
NIL
if any
is a non-empty list with at
least one NIL
element, otherwise T
. (full
X)
is equivalent to (not (memq NIL X))
.
: (full (1 2 3))
-> T
: (full (1 NIL 3))
-> NIL
: (full 123)
-> T
(fun? 'any) -> any
- Returns
NIL
when the argument any
is neither a
number suitable for a code-pointer, nor a list suitable for a lambda expression
(function). Otherwise a number is returned for a code-pointer, T
for a function without arguments, and a single formal parameter or a list of
formal parameters for a function. See also getd
.
: (fun? 1000000000) # Might be a code pointer
-> 1000000000
: (fun? 100000000000000) # Too big for a code pointer
-> NIL
: (fun? 1000000001) # Cannot be a code pointer (odd)
-> NIL
: (fun? '((A B) (* A B))) # Lambda expression
-> (A B)
: (fun? '((A B) (* A B) . C)) # Not a lambda expression
-> NIL
: (fun? '(1 2 3 4)) # Not a lambda expression
-> NIL
: (fun? '((A 2 B) (* A B))) # Not a lambda expression
-> NIL