Other

(! . exe) -> any
Low level breakpoint function: The current execution environment is saved and the I/O channels are redirected to the console. Then exe is displayed, and a read-eval-print-loop is entered (with ! as its prompt character), to evaluate expressions and examine the current program environment. An empty input line terminates the read-eval-print-loop, the environment and I/O channels are restored, and the result of exe is returned. ! is normally inserted into existing programs with the debug function. See also e, ^ and *Dbg.

: (de foo (N) (and (println 1) (! println N) (println 2)))
-> foo
: (foo 7)
1                 # Executed '(println 1)'
(println N)       # Entered breakpoint
! N               # Examine the value of 'N'
-> 7
! (e)             # Evaluate '^', i.e. (println N)
7
-> 7
! (e @)           # Evaluate '@' -> the result of '(println 1)'
-> 1
!                 # Empty line: continue
7                 # Executed '(println N)'
2                 # Executed '(println 2)'
-> 2
($ sym|lst lst . prg) -> any
Low level trace function: The first argument sym|lst is printed to the console with a proper indentation, followed by a colon :. If a function is traced, the first argument is the function symbol, else if a method is traced, it is a cons pair of message and class. The second argument lst should be a list of symbols, identical to the function's argument list. The current values of these symbols are printed, followed by a newline. Then prg is executed, and its return value printed in a similar way (this time with an equals sign = instead of a colon) and returned. $ is normally inserted into existing programs with the trace function.

: (de foo (A B) ($ foo (A B) (* A B)))
-> foo
: (foo 3 4)
 foo : 3 4        # Function entry, arguments 3 and 4
 foo = 12         # Function exit, return value 12
-> 12
($dat 'sym1 ['sym2]) -> dat
Converts a string sym1 in ISO format to a date, optionally using a delimiter character sym2. See also dat$, $tim, strDat and expDat.

: ($dat "20070601")
-> 733134
: ($dat "2007-06-01" "-")
-> 733134
($tim 'sym) -> tim
Converts a string to a time. The minutes and seconds are optional and default to zero. See also tim$ and $dat.

: (time ($tim "10:57:56"))
-> (10 57 56)
: (time ($tim "10:57"))
-> (10 57 0)
: (time ($tim "10"))
-> (10 0 0)
(% 'num ..) -> num
Returns the remainder from the divisions of successive num arguments. The sign of the result is that of the first argument. When one of the arguments evaluates to NIL, it is returned immediately. See also / and */ .

: (% 17 5)
-> 2
: (% -17 5)  # Sign is that of the first argument
-> -2
: (% 5 2)
-> 1
: (% 15 10)
-> 5
: (% 15 10 2)  # (% 15 10) -> 5, then (% 5 2) -> 1
-> 1
(& 'num ..) -> num
Returns the bitwise AND of all num arguments. When one of the arguments evaluates to NIL, it is returned immediately. See also |, x| and bit?.

: (& 6 3)
-> 2
: (& 7 3 1)
-> 1
(* 'num ..) -> num
Returns the product of all num arguments. When one of the arguments evaluates to NIL, it is returned immediately. See also /, */, + and -.

: (* 1 2 3)
-> 6
: (* 5 3 2 2)
-> 60
(** 'num1 'num2) -> num
Integer exponentiation: Returns num1 to the power of num2.

: (** 2 3)
-> 8
: (** 100 100)
-> 10000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
(*/ 'num1 ['num2 ..] 'num3) -> num
Returns the product of num1 and all following num2 arguments, divided by the num3 argument. The result is rounded to the nearest integer value. When one of the arguments evaluates to NIL, it is returned immediately. Note that */ is especially useful for fixed point arithmetic, by multiplying with (or dividing by) the scale factor. See also *, /, +, - and sqrt.

: (*/ 3 4 2)
-> 6
: (*/ 1234 2 10)
-> 247
: (*/ 100 6)
-> 17

: (scl 2)
-> 2
: (format (*/ 3.0 1.5 1.0) *Scl)
-> "4.50"

: (scl 20)
-> 20
: (format (*/ 9.9 9.789 9.56789 `(* 1.0 1.0)) *Scl)
-> "927.23474457900000000000"

(+ 'num ..) -> num
Returns the sum of all num arguments. When one of the arguments evaluates to NIL, it is returned immediately. See also inc, -, *, / and */.

: (+ 1 2 3)
-> 6
(++ var) -> any
Pops the first element (CAR) from the stack in var. (++ Lst) is equivalent to (pop 'Lst). See also pop.

(- 'num ..) -> num
Returns the difference of the first num argument and all following arguments. If only a single argument is given, it is negated. When one of the arguments evaluates to NIL, it is returned immediately. See also dec, +, *, / and */.

: (- 7)
-> -7
: (- 7 2 1)
-> 4
(-> any [cnt]) -> any
Searches for the value of any (typically a Pilog variable, or an expression of variables) at top level (or level cnt) in the current environment. See also prove and unify.

: (? (append (1 2 3) (4 5 6) @X) (^ @ (println 'X '= (-> @X))))
X = (1 2 3 4 5 6)
 @X=(1 2 3 4 5 6)
-> NIL
(/ 'num ..) -> num
Returns the first num argument successively divided by all following arguments. When one of the arguments evaluates to NIL, it is returned immediately. See also *, */, %, + and -.

: (/ 12 3)
-> 4
: (/ 60 -3 2 2)
-> -5
(: sym|0 [sym1|cnt ..]) -> any
Fetches a value any from the properties of a symbol, or from a list, by applying the get algorithm to This and the following arguments. Used typically in methods or with bodies. (: ..) is equivalent to (; This ..). See also ;, =: and ::.

: (put 'X 'a 1)
-> 1
: (with 'X (: a))
-> 1
(:: sym [sym1|cnt .. sym2]) -> var
Fetches a property for a property key sym or sym2 from a symbol. That symbol is This (if no other arguments are given), or a symbol found by applying the get algorithm to This and the following arguments. The property (the cons pair, not just its value) is returned, suitable for direct (destructive) manipulations with functions expecting a var argument. Used typically in methods or with bodies. See also =:, prop and :.

: (with 'X (=: cnt 0) (inc (:: cnt)) (: cnt))
-> 1
(; 'sym1|lst [sym2|cnt ..]) -> any
Fetches a value any from the properties of a symbol, or from a list, by applying the get algorithm to sym1|lst and the following arguments. See also :, =: and ::.

: (put 'A 'a 1)
-> 1
: (put 'A 'b 'B)
-> B
: (put 'B 'c 7)
-> 7
: (; 'A a)
-> 1
: (; 'A b c)
-> 7
(< 'any ..) -> flg
Returns T when all arguments any are in strictly increasing order. See also Comparing.

: (< 3 4)
-> T
: (< 'a 'b 'c)
-> T
: (< 999 'a)
-> T
(<= 'any ..) -> flg
Returns T when all arguments any are in strictly non-decreasing order. See also Comparing.

: (<= 3 3)
-> T
: (<= 1 2 3)
-> T
: (<= "abc" "abc" "def")
-> T
(<> 'any ..) -> flg
Returns T when not all any arguments are equal (structure equality). (<> 'any ..) is equivalent to (not (= 'any ..)). See also Comparing.

: (<> 'a 'b)
-> T
: (<> 'a 'b 'b)
-> T
: (<> 'a 'a 'a)
-> NIL
(= 'any ..) -> flg
Returns T when all any arguments are equal (structure equality). See also Comparing.

: (= 6 (* 1 2 3))
-> T
: (= "a" "a")
-> T
: (== "a" "a")
-> T
: (= (1 (2) 3) (1 (2) 3))
-> T
(=0 'any) -> 0 | NIL
Returns 0 when any is a number with value zero. See also n0, lt0, le0, ge0, gt0 and =1.

: (=0 (- 6 3 2 1))
-> 0
: (=0 'a)
-> NIL
(=1 'any) -> 1 | NIL
Returns 1 when any is a number with value one. See also =0.

: (=1 (- 6 3 2))
-> 1
: (=1 'a)
-> NIL
(=: sym|0 [sym1|cnt .. sym2|0] 'any)
Stores a new value any for a property key sym or sym2 (or in the symbol value for zero) in a symbol. That symbol is This (if no other arguments are given), or a symbol found by applying the get algorithm to This and the following arguments. Used typically in methods or with bodies. See also put, : and ::.

: (with 'X (=: a 1) (=: b 2))
-> 2
: (get 'X 'a)
-> 1
: (get 'X 'b)
-> 2
(== 'any ..) -> flg
Returns T when all any arguments are the same (pointer equality). See also n== and Comparing.

: (== 'a 'a)
-> T
: (== 'NIL NIL (val NIL) (car NIL) (cdr NIL))
-> T
: (== (1 2 3) (1 2 3))
-> NIL
(==== ['sym ..]) -> NIL
Close the current transient scope by clearing the transient index. All transient symbols become hidden and inaccessible by the reader. Then any optional sym arguments are (re-)inserted into the transient index. See also extern and intern.

: (setq S "abc")           # Read "abc"
-> "abc"
: (== S "abc")             # Read again, get the same symbol
-> T
: (====)                   # Close scope
-> NIL
: (== S "abc")             # Read again, get another symbol
-> NIL
(=T 'any) -> flg
Returns T when any is the symbol T. (=T X) is equivalent to (== T X). See also nT.

: (=T 0)
-> NIL
: (=T "T")
-> NIL
: (=T T)
-> T
(> 'any ..) -> flg
Returns T when all arguments any are in strictly decreasing order. See also Comparing.

: (> 4 3)
-> T
: (> 'A 999)
-> T
(>= 'any ..) -> flg
Returns T when all arguments any are in strictly non-increasing order. See also Comparing.

: (>= 'A 999)
-> T
: (>= 3 2 2 1)
-> T
(>> 'cnt 'num) -> num
Shifts right the num argument by cnt bit-positions. If cnt is negative, a corresponding left shift is performed.

: (>> 1 8)
-> 4
: (>> 3 16)
-> 2
: (>> -3 16)
-> 128
: (>> -1 -16)
-> -32
(? [sym ..] [pat 'any ..] . lst) -> flg
Top-level function for interactive Pilog queries. ? is a non-evaluating front-end to the query function. It displays each result, waits for console input, and terminates when a non-empty line is entered. If a preceding list of (non-pattern-) symbols is given, they will be taken as rules to be traced by prove. The list of variable/value pairs is passed to goal for an initial Pilog environment. See also pilog and solve.

: (? (append (a b c) (d e f) @X))
 @X=(a b c d e f)
-> NIL

: (? (append @X @Y (a b c)))
 @X=NIL @Y=(a b c)
 @X=(a) @Y=(b c)
 @X=(a b) @Y=(c)
 @X=(a b c) @Y=NIL
-> NIL

: (? (append @X @Y (a b c)))
 @X=NIL @Y=(a b c).                    # Stopped
-> NIL

: (? append (append @X @Y (a b c)))    # Trace 'append'
1 (append NIL (a b c) (a b c))
 @X=NIL @Y=(a b c)
2 (append (a . @X) @Y (a b c))
1 (append NIL (b c) (b c))
 @X=(a) @Y=(b c).                      # Stopped
-> NIL
@
Holds the result of the last top level expression in the current read-eval-print loop, or the result of the conditional expression during the evaluation of flow functions (see @ Result). When @ is used as a formal parameter in lambda expressions, it denotes a variable number of evaluated arguments.
@@
Holds the result of the second last top level expression in the current read-eval-print loop (see @ Result). Some functions store a secondary return value in @@.
@@@
Holds the result of the third last top level expression in the current read-eval-print loop (see @ Result).
^
Holds the currently executed expression during a breakpoint or an error. See also debug, !, e and *Dbg.

: (* (+ 3 4) (/ 7 0))
!? (/ 7 0)
Div/0
? ^
-> (/ 7 0)
(| 'num ..) -> num
Returns the bitwise OR of all num arguments. When one of the arguments evaluates to NIL, it is returned immediately. See also x|, & and bit?.

: (| 1 2)
-> 3
: (| 1 2 4 8)
-> 15