Atoms and Definitions of JOY

February, 10th 2002

Abstract

This document is containing a brief description
of all Atoms, defined by the JOY-System and
of all visible definitions, defined by the basic Joy Libraries.
The basic Libraries are
inilib, agglib, seqlib and numlib.

This document is up to date with Joy as it could be downloaded from
the Joy Home Page at February, 10th 2002.


Contents:
Abbreviations
A Aggregate: Set, String or List
B Boolean: true or false
C Character
F Float
I Integer
L List
N Number
P Program
Seq Sequence: String or List
Set Set
Str String
T Tree
U User defined symbol
X Y Z Anything
-> Type specifier
=> Evaluates to
... Resulting type depends on parameter stack.

Note: The following descriptions do include a type specification, the definition and/or a describing text and sometimes examples. A type specification like 'I1 I2 -> I3' does not mean there are three different types of integer. The incoming and outgoing values are just enumerated in order to make them addressable by the following text.

[Joy Home Page]

For questions and discussion about JOY please contact the JOY mailing list at concatenative@yahoogroups.com .
Generated at Monday 11-FEB-02 21:52:12 by Rabbit .





[Contents] [Next]

Joy Types / Aggregates

list type
-> L
interp.c
The type of lists of values of any type (including lists) or the type of quoted programs which may contain operators or combinators. Literals of this type are written inside square brackets.
  • [] => []
  • [ 3 512 -7] => [ 3 512 -7]
  • [ john mary] => [ john mary]
  • [ 'A 'C[ 'B]] => [ 'A 'C[ 'B]]
  • [ dup *] => [ dup *]

set type
-> Set
interp.c
The type of sets of small non-negative integers. The maximum is platform dependent, typically the range is 0..31. Literals are written inside curly braces.
  • {} => {}
  • { 0} => { 0}
  • { 1 3 5} => { 1 3 5}
  • { 17 18 19} => { 17 18 19}

string type
-> Str
interp.c
The type of strings of characters. Literals are written inside double quotes.
Unix style escapes are accepted: \n - newline, \t - tabulator and so on.
  • "" => ""
  • "A" => "A"
  • "hello world" => "hello world"
  • "123" => "123"

[Contents] [Next] [Previous]

Joy Types / Char, Truth, File

character type
-> C
interp.c
The type of characters. Literals are written with a single quote. Examples: 'A '7 '; and so on. Unix style escapes are allowed.
  • 'a => 'a
  • '0 => '0
  • '# => '#

file type
-> STREAM
interp.c
The type of references to open I/O streams, typically but not necessarily files. The only literals of this type are stdin stdout and stderr.
  • stdin => file type

truth value type
-> B
interp.c
The logical type or the type of truth values. It has just two literals: true and false.
  • true => true
  • false => false

[Contents] [Next] [Previous]

Joy Types / Numerics

float type
-> F
interp.c
The type of floating-point numbers. Literals of this type are written with embedded decimal points (like 1.2) and optional exponent specifiers (like 1.5E2).
  • 1.20 => 1.20

integer type
-> I
interp.c
The type of negative zero or positive integers. Literals are written in decimal notation.
  • -123 => -123
  • 0 => 0
  • 42 => 42

[Contents] [Next] [Previous]

Stack Manipulation

dup
X -> X X
interp.c
Pushes an extra copy of X onto stack.
  • 42 dup => 42 42

dup2
X Y -> X Y X Y
inilib
== dupd dup swapd;

dupd
Y Z -> Y Y Z
interp.c
As if defined by: dupd == [dup] dip;
id
->
interp.c
Identity function, does nothing. Any program of the form P id Q is equivalent to just P Q.
newstack
... ->
inilib
== [] unstack;
Remove the stack and continue with the empty stack.
pop
X ->
interp.c
Removes X from top of the stack.
  • 1 2 pop => 1

pop2
Y Z ->
inilib
== pop pop;

popd
Y Z -> Z
interp.c
As if defined by: popd == [pop] dip;
rolldown
X Y Z -> Y Z X
interp.c
Moves Y and Z down and moves X up.
rolldownd
X Y Z W -> Y Z X W
interp.c
As if defined by: rolldownd == [rolldown] dip;
rollup
X Y Z -> Z X Y
interp.c
Moves X and Y up and moves Z down.
rollupd
X Y Z W -> Z X Y W
interp.c
As if defined by: rollupd == [rollup] dip;
rotate
X Y Z -> Z Y X
interp.c
Interchanges X and Z.
rotated
X Y Z W -> Z Y X W
interp.c
As if defined by: rotated == [rotate] dip;
stack
.. X Y Z -> .. X Y Z [Z Y X ..]
interp.c
Pushes the stack as a list.
  • 1 2 3 stack => 1 2 3[ 3 2 1]

swap
X Y -> Y X
interp.c
Interchanges X and Y.
  • 1 2 swap => 2 1

swapd
X Y Z -> Y X Z
interp.c
As if defined by: swapd == [swap] dip;
unstack
[X Y ..] -> ..Y X
interp.c
The list [X Y ..] becomes the new stack.
  • 1 2 3[ 'a 'b] unstack => 'b 'a

[Contents] [Next] [Previous]

Aggregates / at, of, drop, pair, rest, size, take, unpair, ....

at
A I -> X
interp.c
X is the member of A at position I. The first item is at position 0.
  • [ 1 2 3] 1 at => 2
  • 1[ 1 2 3] of => 2

drop
A N -> A
interp.c
Result is A with its first N elements deleted.
  • [ 1 2 3] 2 drop => [ 3]
  • { 1 2 3} 2 drop => { 3}
  • "abc" 2 drop => "c"

elements
L -> Set
agglib
== {}swap [swons]step;
Returns all members of L, doubles removed. The elements of L must fit the sets range.
  • [ 1 2 3 1 2 3] elements => { 1 2 3}

of
I A -> X
interp.c
X is the member of A at position I. The first item is at position 0.
  • [ 1 2 3] 1 at => 2
  • 1[ 1 2 3] of => 2

pair
X Y -> L
was: stdlib
== [] cons cons;
  • "Frank" 17 pair => ["Frank" 17]

pairlist
X X -> L
agglib
== [] cons cons;

pairset
I I -> Set
agglib
== {} cons cons;

pairstring
C C -> Str
agglib
== "" cons cons;

rest
A -> A
interp.c
Result is the non-empty aggregate A with its first member removed.
restd

agglib
== [rest] dip;

set2string

agglib
== ""[[ chr] dip cons] foldr;

setsize
-> setsize
interp.c
Pushes the maximum number of elements in a set (platform dependent). Typically it is 32 and set members are in the range 0..31.
  • setsize => 32

shunt
A A -> A
agglib
== [swons] step;
  • [][ 1 2 3] shunt => [ 3 2 1]

size
A -> I
interp.c
Integer I is the size of aggregate A.
string2set

agglib
== {} swap shunt;

take
A I -> A
interp.c
Retain just the first I elements of A.
  • [ 1 2 3] 2 take => [ 1 2]
  • { 1 2 3} 2 take => { 1 2}

unitlist
X -> L
agglib
== [] cons;
  • 1 unitlist => [ 1]

unitset
I -> Set
agglib
== {} cons;

unitstring
C -> Str
agglib
== "" const] dip;;

unpair
A -> X Y
agglib
== uncons uncons pop;
  • [ 1 2 3 4] unpair => 1 2

[Contents] [Next] [Previous]

Aggregates / Tests

all
A [P:test] -> X
interp.c
Applies test P to members of aggregate A, returns true if all pass.
  • [ 1 2 3 4][ 5 >] all => false
  • [ 1 2 3 4][ 5 <] all => true

compare
A A -> I
interp.c
I (=-1 0 +1) is the comparison of aggregates A1 and A2. The values correspond to the predicates <= = >=.
  • { 1 2 3}{ 1 2 3} compare => 0
  • { 1 2 3}{ 1 2 4} compare => 4
  • { 1 2 3}{ 1 31} compare => -3
  • "1 2 3"" 1 2 3" compare => 17
  • 1 1 compare => 0
  • 1 10 compare => -9
  • true false compare => 1
  • false true compare => -1

equal
T T -> B
interp.c
(Recursively) tests whether two trees are identical.
  • [ 1[ 'a[ 5] 2]][ 1[ 'a[ 5] 2]] equal => true
  • [ 1[ 'a[ 5] 2]][ 1[ 'a[ 6] 2]] equal => false

has
A X -> B
interp.c
Tests whether aggregate A has X as a member.
  • [ 1 2 3] 3 has => true
  • 3[ 1 2 3] in => true

in
X A -> B
interp.c
Tests whether X is a member of aggregate A.
  • [ 1 2 3] 3 has => true
  • 3[ 1 2 3] in => true

leaf
X -> B
interp.c
Tests whether X is not a list.
list
X -> B
interp.c
Tests whether X is a list.
null
X -> B
interp.c
Tests for empty aggregate X or zero numeric.
  • 0 null => true
  • [] null => true
  • {} null => true
  • "" null => true

null2
X Y -> B
agglib
== nulld null or;
Tests whether X or Y is null.
nulld
X Y -> B Y
agglib
== [null] dip;

set
X -> B
interp.c
Tests whether X is a set.
small
X -> B
interp.c
X has to be an aggregate or an integer.
Tests whether aggregate X has 0 or 1 members or integer X is 0 or 1.
  • -1 small => true
  • 0 small => true
  • 1 small => true
  • 2 small => false
  • [] small => true
  • [ 1] small => true
  • [ 1 2] small => false

some
A [P:test] -> B
interp.c
Applies test to members of aggregate A and returns true if some ( that is one or more ) pass, false if not.
  • [ 1 2 3][ odd] some => true
  • [ 2 4 6][ odd] some => false

string
X -> B
interp.c
Tests whether X is a string.
[Contents] [Next] [Previous]

Aggregates / average, flatten, frontlist, insert, delete, variance, ....

average
L -> N
Set -> I
agglib
== [sum] [size] cleave /;

cartproduct
L L -> L
seqlib
  • [ 1 2][ 'a 'b] cartproduct => [[ 2 'b][ 2 'a][ 1 'b][ 1 'a]]

delete
A X -> A
seqlib
Delete first occurance of X out of A.
  • "delete" 'e delete => "dlete"

flatten
L -> L
seqlib
== [ null] [] [ uncons] [ concat] linrec;
  • [[ 1 2 3][ 4 5 6][ 7[ 'a 'b] 9]] flatten => [ 1 2 3 4 5 6 7[ 'a 'b] 9]

from-to
I I A -> A
C C A -> A
agglib
Create an aggregate containing values from I1 to I2 for sets and lists, from C1 to C2 for strings.
from-to-list
I I -> L
agglib
== [] from-to;
  • 5 10 from-to-list => [ 5 6 7 8 9 10]

from-to-set
I I -> Set
agglib
== {} from-to;
  • 5 10 from-to-set => { 5 6 7 8 9 10}

from-to-string
C C -> Str
agglib
== "" from-to";
  • 'a 'f from-to-string => "abcdef"

frontlist
A -> A
seqlib
  • [ 1 2 3] frontlist => [[][ 1][ 1 2][ 1 2 3]]

frontlist1
A -> A
seqlib
== [ null] [[] cons] [ uncons] [[ cons] map popd[] swons] linrec;
Thompson p 247
  • [ 1 2 3] frontlist1 => [[][ 1][ 1 2][ 1 2 3]]

insert
A X -> A
seqlib
Insert X in A at sorted position.
  • [ 1 2 3 4 1] 3.50 insert => [ 1 2 3 3.50 4 1]

insert-old

seqlib
Alternative implementation of insert.
insertlist
L X -> L
seqlib
  • [ 1 2 3]"X" insertlist => [["X" 1 2 3][ 1"X" 2 3][ 1 2"X" 3][ 1 2 3"X"]]

orlist
[P] -> [P]
seqlib
== [list] swap disjoin;
Creates a quoted program that evaluates to true, if [P] returns true or X is a list.
  • [ set] orlist => [[ list][ true][ set] ifte]
  • { 1 2 3}[ set] orlist[ sum][] ifte => 6

orlistfilter
[P] -> [P]
seqlib
== orlist[filter]cons;
  • [ set] orlistfilter => [[[ list][ true][ set] ifte] filter]
  • [ 1{ 1 2}[ 99 88]"string"][ set] orlistfilter i => [{ 1 2}[ 99 88]]

permlist
L -> L
seqlib
Create a list of all permutations of L.
  • [ 1 2 3] permlist => [[ 1 2 3][ 2 1 3][ 2 3 1][ 1 3 2][ 3 1 2][ 3 2 1]]

powerlist1
L ->L
seqlib
  • [ 1 2 3] powerlist1 => [[][ 3][ 2][ 2 3][ 1][ 1 3][ 1 2][ 1 2 3]]

powerlist2

seqlib
  • [ 1 2 3] powerlist2 => [[ 1 2 3][ 1 2][ 1 3][ 1][ 2 3][ 2][ 3][]]

product
L|Set -> N
seqlib
== 1[ *] fold;
Calculate the product of all list or set items.
  • [ 1 2 3 4 5] product => 120

restlist
L -> L
seqlib
== [ null] [[] cons] [ dup rest] [ cons] linrec;
  • [ 1 2 3 4] restlist => [[ 1 2 3 4][ 2 3 4][ 3 4][ 4][]]

scalarproduct
L L -> N
seqlib
== [ 0] dip2[ null2] [ pop2] [ uncons2[ * +] dip2] tailrec;
Scalarproduct.
  • [ 2 3 1][ 6 4 12] scalarproduct => 36

subseqlist
L -> L
seqlib
  • [ 1 2 3] subseqlist => [[ 1][ 1 2][ 1 2 3][ 2][ 2 3][ 3][]]

sum
L|Seq -> N
agglib
== 0[+]fold;
Calculate the sum of all list or set items.
  • [ 1 2 3 4 5] sum => 15

variance
L -> N
agglib
Calculate variance of lists items.
[Contents] [Next] [Previous]

Aggregates / cons and concat

concat
A A -> A
interp.c
Evaluates to the concatenation of two aggregates.
  • [ 1 2 3 4][ 3 4 5 6] concat => [ 1 2 3 4 3 4 5 6]
  • "abcd""efgh" concat => "abcdefgh"
  • { 1 2 3 4}{ 3 4 5 6} concat => { 1 2 3 4 5 6}

cons
X A -> A
interp.c
Result is A with a new member X (first member for sequences).
  • 9[ 1 2 3] cons => [ 9 1 2 3]
  • 'z"abc" cons => "zabc"
  • 9{ 1 2 3} cons => { 1 2 3 9}

cons2
X Y A A -> A A
agglib
== swapd cons consd;
Cons 2 values to 2 aggregates.
  • 1 2[][] cons2 => [ 1][ 2]

consd

agglib
== [cons] dip;

enconcat
X A1 A2 -> A
interp.c
The concatenation of two aggregates A1 and A2 with X inserted between them.
As if defined by enconcat == swapd cons concat;
  • 0[ 1 2 3 4][ 3 4 5 6] enconcat => [ 1 2 3 4 0 3 4 5 6]
  • '0"abcd""efgh" enconcat => "abcd0efgh"
  • 0{ 1 2 3 4}{ 3 4 5 6} enconcat => { 0 1 2 3 4 5 6}

swoncat
A A -> A
inilib
== swap concat;
  • [ 1 2 3 4][ 3 4 5 6] swoncat => [ 3 4 5 6 1 2 3 4]
  • "abcd""efgh" swoncat => "efghabcd"
  • { 1 2 3 4}{ 3 4 5 6} swoncat => { 1 2 3 4 5 6}

swons
A X -> A
interp.c
Result is A with a new member X (first member for sequences).
  • [ 1 2 3] 9 swons => [ 9 1 2 3]
  • "abc" 'z swons => "zabc"
  • { 1 2 3} 9 swons => { 1 2 3 9}

swons2
A A X Y -> A A
agglib
== swapd swons swonsd;
Swons 2 items to 2 aggregates.
  • "ext"[ 1 2 3] 't 999 swons2 => "text"[ 999 1 2 3]

swonsd

agglib
== [swons] dip;

uncons
A -> X A
interp.c
Returns the first and the rest of non-empty aggregate A.
  • [ 1 2 3] uncons => 1[ 2 3]

uncons2
A A -> X Y A A
agglib
== unconsd uncons swapd;
Uncons 2 values from 2 aggregates.
  • [ 999 1 2 3]"text" uncons2 => 999 't[ 1 2 3]"ext"

unconsd

agglib
== [uncons] dip;

unswons
A -> A X
interp.c
Returns the rest and the first of non-empty aggregate A.
  • [ 1 2 3] unswons => [ 2 3] 1

unswons2
A A -> A A X Y
agglib
== [ unswons] dip unswons swapd;
Unswons 2 items from 2 aggregates.
  • [ 1 2 3]"text" unswons2 => [ 2 3]"ext" 1 't

unswonsd

agglib
== [unswons] dip;

[Contents] [Next] [Previous]

Aggregates / first, second,...

fifth
A -> A
agglib
== 4 drop first;

first
A -> X
interp.c
X is the first member of the non-empty aggregate A.
firstd

agglib
== [first] dip;

fourth
L -> L
agglib
== 3 drop first;

second

agglib
== rest first;

secondd

agglib
== [ secondd] dip;

third

agglib
== rest rest first;

thirdd

agglib
== [third] dip;

[Contents] [Next] [Previous]

Aggregates / merge, qsort, reverse, transpose, zip

merge
Seq Seq -> Seq
seqlib
Concat 2 sorted sequences with sorted result.
  • [ 1 2 3 4][ 2 3 4 5] merge => [ 1 2 2 3 3 4 4 5]
  • "aabc""abde" merge => "aaabbcde"

merge1
Seq Seq -> Seq
seqlib
Concat 2 sorted sequences of sequences with sorted result.
mk_qsort
L [P] -> L
seqlib
Sort a sequence. The new order is obtained after applying P on every list item.
  • [[ 1 2 3][ 5][ 700 -699]][ sum] mk_qsort => [[ 700 -699][ 5][ 1 2 3]]

qsort
A -> A
seqlib
== [small] [] [uncons [>] split] [swapd cons concat] binrec;
Sort a sequence.
  • "string." qsort => ".ginrst"
  • [ 1 3 2] qsort => [ 1 2 3]

qsort1
L -> L
seqlib
== [small] [] [uncons [[first] unary2 >] split] [swapd cons concat] binrec;
Sort a sequence of sequences.
qsort1-1
L -> L
seqlib
Sort a sequence of sequences. Like qsort1, but different implementation.
reverse
S -> S
seqlib
== [[]] [""] iflist swap shunts;
Reverse a list or string.
  • [ 1 2 3] reverse => [ 3 2 1]

reverselist
L -> L
seqlib
== [] swap shunt ;
Reverse a list.
reversestring
Str -> Str
seqlib
== "" swap shunt ;
Reverse a string.
transpose
L -> L
seqlib
Transpose a list of lists.
  • [[ 1 2 3 4][ 'a 'b 'c]] transpose => [[ 1 'a][ 2 'b][ 3 'c]]

zip
A A -> A
agglib
== [null2] [pop2 []] [uncons2] [[pairlist] dip cons] linrec;
Zip 2 aggregates into a list of pairs.
  • [ 1 2 3][ 10 20 30] zip => [[ 1 10][ 2 20][ 3 30]]

zipwith
A A [P] -> A
was: stdlib
== [[null2] [pop2 []] [uncons2]]dip [dip cons]cons linrec;
Zip 2 aggregates, combining by P.
  • [ 1 2 3][ 10 20 30][ +] zipwith => [ 11 22 33]

[Contents] [Next] [Previous]

Aggregates / trees

treeflatten

seqlib

treereverse

seqlib

treesample

seqlib
== [[ 1 2[ 3 4] 5[[[ 6] ] ] 7] 8] ;

treeshunt

seqlib

treestrip

seqlib

[Contents] [Next] [Previous]

Characters

char
X -> B
interp.c
Tests whether X is a character.
chr
I -> C
interp.c
C is the character whose Ascii value is integer I (or logical or character).
ord
C -> I
interp.c
Integer I is the Ascii value of character C (or logical or integer).
to-lower
C -> C
inilib
== ['a ] [32 +] [] ifte;

to-upper
C -> C
inilib
== ['a >=] [32 -] [] ifte;

[Contents] [Next] [Previous]

Logic

!=
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X not equal to Y. Also supports float.
>
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X greater than Y. Also supports float.
Qsort is using > in order to obtain the arrangement.
  • ["dup""dup2""dup3" dup dup2"1""Xx"] qsort => ["1""Xx""dup" dup"dup2" dup2"dup3"]

>=
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X greater than or equal to Y. Also supports float.
<
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X less than Y. Also supports float.
<=
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X less than or equal to Y. Also supports float.
=
X Y -> B
interp.c
Either both X and Y are numeric or both are strings or symbols. Tests whether X equal to Y. Also supports float.
and
X Y -> Z
interp.c
Result is the intersection of two sets or the logical conjunction of two truth values.
  • { 1 2 3}{ 2 3 4} and => { 2 3}
  • true false and => false

boolean
X -> B
inilib
True if X is a logical or a set.
choice
B X Y -> Z
interp.c
Result is X if B is true and Y if B is false.
conjoin
[P][P] -> [P]
inilib
== [[false] ifte] cons cons;
  • [ P1][ P2] conjoin => [[ P1][ P2][ false] ifte]

disjoin
[P][P] -> [P]
inilib
== [ifte] cons [true] swons cons;
  • [ P1][ P2] disjoin => [[ P1][ true][ P2] ifte]

false
-> B
interp.c
Pushes the value false.
  • false => false

falsity
-> B
inilib
== false;

logical
X -> B
interp.c
Tests whether X is a logical.
negate
X -> [P]
inilib
== [[false] [true] ifte] cons;
  • [ small] negate => [[ small][ false][ true] ifte]

not
X -> Y
interp.c
Y is the complement of a set, the logical negation of a truth value.
  • { 1 2 3} not => { 0 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31}
  • true not => false

or
X Y -> Z
interp.c
Z is the union of two sets, the logical disjunction of two truth values.
  • { 1 2 3}{ 2 3 4} or => { 1 2 3 4}
  • true false or => true

sequand
X [P:condition][P:if-true] -> ...
inilib
== [pop false] ifte;

sequor
X [P:condition][P:if-false] -> ...
inilib
== [pop true] swap ifte;

true
-> B
interp.c
Pushes the value true.
  • true => true

truth
-> B
inilib
== true;

xor
X Y -> Z
interp.c
Z is the symmetric difference of two sets, the logical exclusive disjunction of two truth values.
  • { 1 2 3}{ 2 3 4} xor => { 1 4}
  • true false xor => true

[Contents] [Next] [Previous]

Numerics / Binary

*
N N -> N
interp.c
Result is the product of two numbers. Also supports float.
+
N N -> N
interp.c
Result is the adding of two numbers. Also supports float.
-
N N -> N
interp.c
Numeric N is the result of subtracting two numbers. Also supports float.
/
N N -> N
interp.c
Result is the (rounded) ratio of two integers or the quotient of two numbers. Also supports float.
  • 10 3 / => 3
  • 10.00 3 / => 3.33
  • 10 3.00 / => 3.33

abs
N -> N
interp.c
Result is the absolute value (0 1 2..) of number N. Also supports float.
div
I I -> I I
interp.c
Result are the quotient and remainder of dividing two integers.
  • 7 3 div => 2 1

ipow
N I -> N
was: stdlib
== 1 rotate [*] cons times;
I times N * N, that is N raised to I-th power.
  • 2 3 ipow => 8

max
N N -> N
interp.c
Result is the maximum of two numbers. Also supports float.
min
N N -> N
interp.c
Result is the minimum of two numbers. Also supports float.
null2
X Y -> B
agglib
== nulld null or;
Tests whether X or Y is null.
rem
I I -> I
interp.c
Result is the remainder of dividing two integers. Also supports float.
  • 7 3 rem => 1

[Contents] [Next] [Previous]

Numerics / Unary

even
N -> B
numlib
== 2 rem null;
Tests whether number N is even.
  • 2 even => true
  • 3 even => false

integer
X -> B
interp.c
Tests whether X is an integer.
neg
N -> N
interp.c
Result is the negative of a number. Also supports float.
negative
N -> B
numlib
== 0 <;

null
X -> B
interp.c
Tests for empty aggregate X or zero numeric.
nulld

agglib
== [null] dip;

numerical
X -> B
inilib
True if X is an integer or a float.
odd
N -> B
numlib
== even not;
Tests whether a number is not even.
  • 2 odd => false
  • 3 odd => true

positive
N -> B
numlib
== 0 >;

pred
N -> N
interp.c
Result is the predecessor of numeric N.
  • 2 pred => 1

sign
I -> I
interp.c
Result is the sign (-1 or 0 or +1) of a number. Also supports float.
  • -7 sign => -1
  • 0 sign => 0
  • 7.20 sign => 1.00

small
X -> B
interp.c
X has to be an aggregate or an integer.
Tests whether aggregate X has 0 or 1 members or numeric 0 or 1.
  • -1 small => true
  • 0 small => true
  • 1 small => true
  • 2 small => false
  • [] small => true
  • [ 1] small => true
  • [ 1 2] small => false

succ
M -> N
interp.c
Numeric N is the successor of numeric M.
[Contents] [Next] [Previous]

Numerics / algorithm: fact, fib, ...

cube-root

numlib

deriv

numlib

fact

numlib

fib

numlib

gcd

numlib

newton

numlib

prime

numlib

qroots
F:a F:b F:c ->
numlib
find roots of the quadratic equation with coefficients a b c :
a * X^2 + b * X + c = 0
use-newton

numlib

[Contents] [Next] [Previous]

Numerics / float

acos
F -> F
interp.c
Result is the arc cosine of F.
asin
F -> F
interp.c
Result is the arc sine of F.
atan
F -> F
interp.c
Result is the arc tangent of F.
atan2
F F -> F
interp.c
Result is the arc tangent of the quotient of two floats.
ceil
F -> F
interp.c
Result is the float ceiling of F.
  • 1.25 ceil => 2.00
  • 1.52 ceil => 2.00

celsius
F -> F
numlib
== 32 - 5 * 9 /;
Convert Fahrenheit to Celsius.
cos
F -> F
interp.c
Result is the cosine of F.
cosdeg
F -> F
numlib
== radians cos;
Cosine calculated from degree-value.
cosh
F -> F
interp.c
Result is the hyperbolic cosine of F.
e
-> F
numlib
== 1.0 exp;

exp
F -> F
interp.c
Result is e (2.718281828...) raised to the Fth power.
fahrenheit
F -> F
numlib
== 9 * 5 / 32 +;
Convert Celsius to Fahrenheit.
float
X -> B
interp.c
Tests whether X is a float.
floor
F -> F
interp.c
Result is the floor of F.
  • 1.25 floor => 1.00
  • 1.52 floor => 1.00

frexp
F -> F I
interp.c
Result is the mantissa and the exponent of F. Unless F = 0 0.5 <= abs(F2) < 1.0.
ldexp
F I -> F
interp.c
Result is F times 2 to the Ith power.
log
F -> F
interp.c
Result is the natural logarithm of F.
log10
F -> F
interp.c
F is the common logarithm of F.
modf
F -> F F
interp.c
Results are the fractional part and the integer part (but expressed as a float) of F.
  • 12.25 modf => 0.25 12.00

pi
-> F
numlib
== 3.14159265;

pow
F1 F2 -> F
interp.c
Result is F1 raised to the F2th power.
radians
N -> F
numlib
== pi * 180 /;
Convert degree to radians.
sin
F -> F
interp.c
Result is the sine of F.
sindeg
F -> F
numlib
== radians sin;
Sine calculated from degree-value.
sinh
F -> F
interp.c
Result is the hyperbolic sine of F.
sqrt
F -> F
interp.c
Result is the square root of F.
tan
F -> F
interp.c
Result is the tangent of F.
tandeg
F -> F
numlib
== radians tan;
Tangent calculated from degree-value.
tanh
F -> F
interp.c
Result is the hyperbolic tangent of F.
trunc
F -> I
interp.c
Result is an integer equal to the float F truncated toward zero.
  • 1.25 trunc => 1
  • 1.52 trunc => 1

[Contents] [Next] [Previous]

Numerics / random, Maxint

maxint
-> maxint
interp.c
Pushes largest integer (platform dependent). Typically it is 32 bits.
  • 2147483647 => 2147483647

rand
-> I
interp.c
I is a random integer.
srand
I ->
interp.c
Sets the random integer seed to integer I.
[Contents] [Next] [Previous]

combinators / Recursive

binrec
[P:condition] [P:if-true] [P:R1] [P:R2] -> ...
interp.c
Executes P:condition. If that yields true executes P:if-true.
Else uses P:R1 to produce two intermediates, recurses on both and then executes P:R2 to combines their results.
  • [ 1 3 5 2 4][ small][][ uncons[ >] split][ enconcat] binrec => [ 1 2 3 4 5]

condlinrec
[ [C1] [C2] .. [P:default] ] -> ...
interp.c
Each [Ci] is of the forms [[P:condition] [P:if-true]] or [[P:condition] [P:R1] [P:R2]] .
Tries each P:condition. If that yields true and there is just a P:if-true executes that and exits.
If there are P:R1 and P:R2 executes P:R1, recurses and executes P:R2.
Subsequent case are ignored.
If no P:condition yields true then [P:default] is used. It is of the forms [[T]] or [[R1] [R2]].
For the former executes T.
For the latter executes R1, recurses and executes R2.
genrec
[P:condition] [P:if-true] [P:R1] [P:R2] -> ...
interp.c
Executes P:condition. If that yields true executes P:if-true.
Else executes P:R1 and then
[[P:condition] [P:if-true] [P:R1] [P:R2] genrec] P:R2 .
linrec
[P:condition] [P:if-true] [P:R1] [P:R2] -> ...
interp.c
Executes P:condition. If that yields true executes P:if-true. Else executes P:R1, recurses and executes P:R2.
  • 1[ 1 2 3 4 5][ null][ pop][ uncons][ *] linrec => 120

primrec
X [P:initial] [P:combine] -> X
interp.c
Executes P:initial to obtain an initial value.
If X is an integer uses increasing positive integers from 1 up to X and combines by P:combine for new X.
For aggregate X uses successive members and combines by P:combine for new X.
  • 5[ 1][ *] primrec => 120
  • [ 1 2 3 4 5][ 1][ *] primrec => 120

tailrec
[P:condition] [P:if-true] [P:R1] -> ...
interp.c
Executes P:condition. If that yields true executes P:if-true.
Else executes P:R1 and recurses.
  • 1[ 1 2 3 4 5][ null][ pop][ uncons[ *] dip] tailrec => 120

treegenrec
T [P:O1] [P:O2] [P:C] -> ...
interp.c
T is a tree. If T is a leaf executes P:O1.
Else executes P:O2 and then
[[P:O1] [P:O2] [P:C] treegenrec] P:C .
treerec
T [P:O] [P:C] -> ...
interp.c
T is a tree. If T is a leaf executes P:O.
Else executes [[O] [C] treerec] C .
[Contents] [Next] [Previous]

combinators / dips

dip
X [P] -> ... X
interp.c
Saves X, executes P and pushes X back.
  • 1 2 3["diver"] dip => 1 2"diver" 3

dip2
X Y [P] -> ... X Y
inilib
== [dip] cons dip;
Saves X and Y, executes P and restores X and Y.
Equivalent to dipd.
  • 1 2 3["diver"] dip2 => 1"diver" 2 3

dip3
X Y Z [P] -> ... X Y Z
inilib
== [dip2]cons dip;
Saves X Y Z, executes P and restores X Y Z.
  • 1 2 3["diver"] dip3 => "diver" 1 2 3

dipd
X Y [P] -> ... X Y
inilib
== [dip] cons dip;
Saves X and Y, executes P and restores X and Y.
Equivalent to dip2.
  • 1 2 3["diver"] dipd => 1"diver" 2 3

[Contents] [Next] [Previous]

combinators / apply: i, i2, b, x, infra, cleave,...

all
A [P:test] -> X
interp.c
Applies test P to members of aggregate A, returns true if all pass.
  • [ 1 2 3 4][ 5 >] all => false
  • [ 1 2 3 4][ 5 <] all => true

b
[P] [P] -> ...
was: stdlib
== [i]dip i;
Executes both quoted programs.
  • 16 2 4[ *][ /] b => 2

call
Symbol -> ...
inilib
== [] cons i;
Execute the symbol.
  • 1 2"+" intern call => 3

cleave
X [P] [P] -> Y Z
interp.c
Executes both quotations, each with X on top of the stack and each producing one result.
  • 3[ 2 *][ 3 *] cleave => 6 9

construct
[P:init] [[P1] [P2] ..] -> X1 X2 ..
interp.c
Saves state of stack and then executes [P:init]. Then executes each [Pi] to give Xi pushed onto saved stack.
  • 4 5[ pop][[ 10 +][ 20 +][ 30]] construct => 4 5 14 24 30

i
[P] -> ...
interp.c
Executes P. So [P] i == P.
  • [ 1 2 3 *] i => 1 6

i2
... X [P1][P2] -> ...
inilib
== [dip]dip i;
  • 4 5 6[ *][ +] i2 => 26

infra
L [P] -> L
interp.c
Using list L as stack, executes P and returns a new list. The first element of L is used as the top of stack, and after execution of P the top of stack becomes the first element of new L.
  • [ 2 3 4 5][ *] infra => [ 6 4 5]

some
A [P:test] -> B
interp.c
Applies test to members of aggregate A and returns true if some ( that is one or more ) pass, false if not.
  • [ 1 2 3][ odd] some => true
  • [ 2 4 6][ odd] some => false

x
[P] -> ...
interp.c
Executes P without popping [P]. So [P] x == [P] P.
  • 1 2[ cons] x => 1[ 2 cons]

[Contents] [Next] [Previous]

combinators / apply: app, nullary, unary, binary,...

app1
X [P] -> X
interp.c
Executes P, pushes result new X on stack without old X.
app11
X X [P] -> X
interp.c
Executes P pushes result on stack.
app12
X Y Z [P] -> X X
interp.c
Executes P twice with Y and Z returns 2 values.
app2
X X [P] -> X X
interp.c
== unary2;
Obsolescent.
app3
X X X [P] -> X X X
interp.c
== unary3;
Obsolescent.
app4
X X X X [P] -> X X X X
interp.c
== unary4;
Obsolescent.
binary
X Y [P] -> Z
interp.c
Executes P which leaves Z on top of the stack. No matter how many parameters this consumes, exactly two are removed from the stack.
  • 1 2 3[ 9] binary => 1 9
  • 1 2 3[ + +] binary => 1 6
  • 1 2 3[] binary => 1 3
  • 1 2 3[ 99 999] binary => 1 999

nullary
[P] -> X
interp.c
Executes P which leaves X on top of the stack. No matter how many parameters this consumes none are removed from the stack.
  • 1 2 3[ +] nullary => 1 2 3 5
  • 1 2 3[] nullary => 1 2 3 3
  • 1 2 3[ 7 8 9] nullary => 1 2 3 9

nullary2
X1 X2 [P] -> X1 X2 X:P(rest-of-stack..X1) X:P(rest-of-stack..X2)
inilib
== [nullary]cons dup i2 swapd;
  • 2 3[ 10 +] nullary2 => 2 3 12 13

ternary
X Y Z [P] -> X
interp.c
Executes P which leaves new X on top of the stack. No matter how many parameters this consumes, exactly three are removed from the stack.
  • 1 2 3[ 9] ternary => 9
  • 1 2 3[ + +] ternary => 6
  • 1 2 3[] ternary => 3
  • 1 2 3[ 99 999] ternary => 999

unary
X [P] -> Y
interp.c
Executes P which leaves Y on top of the stack. No matter how many parameters this consumes exactly one is removed from the stack.
  • 100 5 1[ * +] unary => 100 5 105
  • 1 2 3[] unary => 1 2 3
  • 1 2 3[ 7 8 9] unary => 1 2 9

unary2
X Y [P] -> X Y
interp.c
Executes P twice, with X and Y on top of the stack returning new X and new Y.
No matter how many parameters both executions consume, exactly two are removed from the stack.
  • 100 5 1 2[ * +] unary2 => 100 5 105 110

unary3
X Y Z [P] -> X Y Z
interp.c
Executes P three times, with X Y and Z on top of the stack returning new X, new Y and new Z.
No matter how many parameters the executions consume, exactly tree are removed from the stack.
  • 100 5 1 2 3[ * +] unary3 => 100 5 105 110 115

unary4
X X X X [P] -> X X X X
interp.c
Executes P four times, with X:1-4 on top of the stack returning four new X.
No matter how many parameters the executions consume, exactly four are removed from the stack.
  • 100 5 1 2 3 4[ * +] unary4 => 100 5 105 110 115 120

[Contents] [Next] [Previous]

combinators / branches and loops

branch
B [P1] [P2] -> ...
interp.c
If B is true then executes P1 else executes P2.
  • true["true"]["false"] branch => "true"

case
X [..[Xi Pi].. [P:default]] -> ...
interp.c
Indexing on the value of X, execute the matching Pi or P:default.
  • 1[[ 1"one"][ 2"two"]["default"]] case => "one"
  • 2[[ 1"one"][ 2"two"]["default"]] case => "two"
  • 'D[[ 1"one"][ 2"two"]["default"]] case => 'D"default"
  • 9[[ 1["one"]][ 2"two"][ 9"default"]] case => 9 9"default"
  • 1[[ 1 4 5 *][ 2"two"]["default"]] case => 20
  • 1[[ 1["one"]][ 2"two"]["default"]] case => ["one"]

cond
[ ...[[Pi:condition] Pi:if-true]... [P:Default]] -> ...
interp.c
Tries each condition. If a condition yields true executes the corresponding if-true and exits.
If no condition yields true executes default.
  • 1[[[ 1 =] pop"One"][[ 2 =] pop"Two"][ pop"Default"]] cond => "One"
  • 2[[[ 1 =] pop"One"][[ 2 =] pop"Two"][ pop"Default"]] cond => "Two"
  • 'D[[[ 1 =] pop"One"][[ 2 =] pop"Two"][ pop"Default"]] cond => "Default"
  • 1[[[ 1 =] pop 4 5 *][[ 2 =] pop"Two"][ pop"Default"]] cond => 20
  • 1[[[ 1 =] pop["One"]][[ 2 =] pop"Two"][ pop"Default"]] cond => ["One"]

conts
-> [[P] [Q] ..]
interp.c
Pushes current continuations. Buggy, do not use.
forever
[P] -> ...
inilib
== 2147483647 swap times;

ifchar
X [P1] [P2] -> ...
interp.c
If X is a character executes P1 else executes P2.
iffile
X [P1] [P2] -> ...
interp.c
If X is a file executes P1 else executes P2.
iffloat
X [P1] [P2] -> ...
interp.c
If X is a float executes P1 else executes P2.
ifinteger
X [P1] [P2] -> ...
interp.c
If X is an integer executes P1 else executes P2.
iflist
X [P1] [P2] -> ...
interp.c
If X is a list executes P1 else executes P2.
iflogical
X [P1] [P2] -> ...
interp.c
If X is a logical or truth value executes P1 else executes P2.
ifset
X [P1] [P2] -> ...
interp.c
If X is a set executes P1 else executes P2.
ifstring
X [P:if-true] [P:if-false] -> ...
interp.c
If X is a string executes P:if-true else executes P:if-false.
  • "text"["true"]["false"] ifstring => "text""true"

ifte
[P:condition] [P:if-true] [P:if-false] -> ...
interp.c
Executes P:condition. If that yields true then executes P:if-true else executes P:if-false.
  • 1234[ 1234 =]["true"]["false"] ifte => 1234"true"
  • 1234[ 1234 =][ pop"true"][ pop"false"] ifte => "true"
  • 1234[ odd][][ 1 +] ifte => 1235

opcase
X [..[X Xs]..] -> [Xs]
interp.c
Indexing on type of X returns the list [Xs].
  • 1[[ 1"integer"][ 'c"char"][[]"list"]["default"]] opcase => 1["integer"]
  • 2[[ 1"integer"][ 'c"char"][[]"list"]["default"]] opcase => 2["integer"]
  • 'a[[ 1"integer"][ 'c"char"][[]"list"]["default"]] opcase => 'a["char"]
  • [ 1][[ 1"integer"][ 'c"char"][[]"list"]["default"]] opcase => [ 1]["list"]
  • {}[[ 1"integer"][ 'c"char"][[]"list"]["default"]] opcase => {}["default"]

repeat
[P:body][P:condition] -> ...
inilib
== dupd swap[ i] dip2 while;
  • 1[ 1 +][ 10 =] repeat => 2

times
N [P] -> ...
interp.c
Executes N times P.
while
[P1] [P2] -> ...
interp.c
While executing P1 yields true executes P2.
  • 1[ 10 =][ 1 +] while => 1

[Contents] [Next] [Previous]

combinators / functionals on aggregates

filter
A [P] -> A
interp.c
Uses test P to filter an aggregate and produces a sametype aggregate.
  • [ 1 2 3 4][ odd] filter => [ 1 3]

fold
A X [P] -> X
interp.c
Starting with X sequentially pushes members of aggregate A and combines with binary operator P to produce new X.
  • [ 1 2 3 4] 0[ +] fold => 10

fold2
A A X [P] -> A
agglib
== rollupd stepr2;
Starting with X sequentially pushes members of both aggregates and combines with ternary operator P to produce new X.
  • [ 1 2 3][ 6 7 8][][ pair swons] fold2 => [[ 3 8][ 2 7][ 1 6]]

foldr
A X [P] -> X
agglib
== [ [[null]]dip (*P1*) []cons [pop]swoncat (*P2*) [uncons] ]dip (*P3*) linrec;
  • ["some ""strings ""to ""concat "]""[ concat] foldr => "some strings to concat "
  • ["some ""strings ""to ""concat "]""[ concat] fold => "some strings to concat "

foldr2

agglib
== [ [[null2]]dip(* P1 ) []cons[pop2]swoncat(* P2 *) [uncons2](* P3 *) ]dip linrec;

interleave2

agglib
== [cons cons] foldr2;

interleave2list

agglib
== [] interleave2;

map
A [P] -> A
interp.c
Executes P on each member of aggregate A and collects results in a sametype aggregate.
  • [ 1 2 3 4][ odd] map => [ true false true false]

mapr
A [P] -> A
agglib
  • [ 1 2 3 4][ odd] mapr => [ true false true false]

mapr2

agglib
== [ [null2] [pop2[]] [uncons2] ]dip(* P1 P2 P3 *) [dip cons]cons(* P4 *) linrec;


pairstep

agglib
== [dupd] swoncat [step pop] cons cons step;

split
A [P] -> A A
interp.c
Uses test P to split aggregate A into two aggregates of the same type.
  • [ 1 2 3 4][ odd] split => [ 1 3][ 2 4]

step
A [P] -> ...
interp.c
Sequentially putting members of aggregate A onto stack, executes P for each member of A.
  • [ 1 2 3 4][ odd] step => true false true false

step2
A A [P] -> ...
was: stdlib
== [[dup] dip] swoncat [step pop] cons cons step;
  • [][ 1 2 3][ 4 5 6 0][ pair swap[ swons] dip] step2 => [[ 3 0][ 3 6][ 3 5][ 3 4][ 2 0][ 2 6][ 2 5][ 2 4][ 1 0][ 1 6][ 1 5][ 1 4]]

stepr2
A A [P] -> ...
agglib
== [ [null2] [pop pop] ]dip(* P1 P2 *) [dip]cons [dip]cons [uncons2]swoncat(* P3 *) tailrec;
  • [ 1 2 3][ 4 5 6 0][ pair] stepr2 => [ 1 4][ 2 5][ 3 6]

treefilter

seqlib

treemap

seqlib

treestep
T [P] -> ...
interp.c
Recursively traverses leaves of tree T executes P for each leaf.
[Contents] [Next] [Previous]

files and Streams

fclose
STREAM ->
interp.c
The stream is closed and removed from the stack.
feof
STREAM -> STREAM B
interp.c
B is the end-of-file status of stream.
ferror
STREAM -> STREAM B
interp.c
B is the error status of stream.
fflush
STREAM -> STREAM
interp.c
Flush stream forcing all buffered output to be written.
fgetch
STREAM -> STREAM C
interp.c
C is the next available character from stream.
fgets
STREAM -> STREAM Str
interp.c
Str is the next available line from stream.
file
Str -> B
interp.c
Tests whether string Str is a file.
fopen
Str C -> STREAM
interp.c
The file system object with pathname Str is opened with mode C (r w a etc.) and stream object STREAM is pushed.
If the open fails file:NULL is pushed.
fput
STREAM X -> STREAM
interp.c
Writes X to stream.
fputch
STREAM C -> STREAM
interp.c
The character C is written to the current position of stream.
fputchars
STREAM Str -> STREAM
interp.c
The string Str is written without quotes to the current position of stream.
fputstring
STREAM Str -> STREAM
interp.c
== fputchars;
Temporary alternative to fputchars.
fread
STREAM I -> STREAM L
interp.c
I bytes are read from the current position of stream and returned as a list of integers.
fremove
Str -> B
interp.c
The file system object with pathname Str is removed from the file system. B is a boolean indicating success or failure.
frename
Str1 Str2 -> B
interp.c
The file system object with pathname Str1 is renamed to Str2. B is a boolean indicating success or failure.
fseek
STREAM I1 I2 -> STREAM
interp.c
Stream is repositioned to position I1 relative to whence-point I2 where I2 = 0 1 2 for beginning current position end respectively?
ftell
STREAM -> STREAM I
interp.c
I is the current position of stream.
fwrite
STREAM L -> STREAM
interp.c
A list of integers is written as bytes to the current position of stream.
[Contents] [Next] [Previous]

format

format
I C I1 I2 -> Str
interp.c
Result is the formatted version of integer I in mode C with maximum width I1 and minimum width I2.
Possible modes of C:
'd or 'i: decimal
'o: octal
'x or X: hex
  • 12 'd 1 1 format => "12"
  • 12 'd 8 2 format => " 12"
  • 12 'd 8 3 format => " 012"

formatf
F C I1 I2 -> Str
interp.c
Result is the formatted version of Float F in mode C with maximum width I1 and precision I2.
Possible modes of C:
'e or E: exponential
'f: fractional
'g or G: general
  • 12.89 'e 10 4 formatf => "1.2890e+01"
  • 12.89 'f 10 4 formatf => " 12.8900"
  • 12.89 'g 10 4 formatf => " 12.89"

strtod
Str -> F
interp.c
String Str is converted to float F.
strtol
Str I -> I
interp.c
String Str is converted to an integer using base I. If I = 0 assumes base 10 but leading "0" means base 8 and leading "0x" means base 16.
  • "12" 3 strtol => 5

[Contents] [Next] [Previous]

joy / Help and Debug

__dump
->
interp.c
debugging only: pushes the dump as a list.
__latex_manual
->
interp.c
Writes manual of all Joy primitives in Latex to output file.
__memoryindex
->
interp.c
Pushes current value of memory.
__memorymax
->
interp.c
Pushes value of total size of memory.
__settracegc
I ->
interp.c
Sets value of flag for tracing garbage collection to I (= 0..5).
__symtabindex
->
interp.c
Pushes current size of the symbol table.
__symtabmax
->
interp.c
Pushes value of maximum size of the symbol table.
_help
->
interp.c
Lists all hidden symbols in library and then all hidden inbuilt symbols.
autoput
-> I
interp.c
Pushes current value of flag for automatic output.
echo
-> I
interp.c
Pushes value of echo flag.
help
->
interp.c
Lists all defined symbols including those from library files. Then lists all primitives of raw Joy.
helpdetail
L ->
interp.c
Gives brief help on each item of L.
manual
->
interp.c
Writes manual of all Joy primitives to output file.
setautoput
I ->
interp.c
Sets value of flag for automatic put to I. The automatic output is executed as soon as Joy is returning to its main execution loop.
0: none
1: execute one put
2: print the stack
setecho
I ->
interp.c
Sets the value of echo flag for listing of source code lines at stdout while including new files. This results in a mix of code lines with the results these lines produce.
0: no echo
1: echo
2: echo with tab
3: echo with tab and linenumber.
setundeferror
I ->
interp.c
Sets flag that controls behavior of undefined functions.
0: no error
1: error
undeferror
-> I
interp.c
Pushes current value of undefined-is-error flag.
[Contents] [Next] [Previous]

joy / Library Loading

AGGLIB
-> Str
agglib
== "agglib.joy - aggregate library ";

INILIB
-> Str
inilib
== "inilib.joy - the initial library, assumed everywhere ";

NUMLIB
-> Str
numlib
== "numlib.joy - numerical library ";

SEQLIB
-> Str
seqlib
== "seqlib.joy - sequence library, assumes agglib.joy ";

_agglib
-> B
agglib
== true;

_inilib
-> B
inilib

_numlib
-> B
numlib
== true;

_seqlib
-> B
seqlib

all-libload
->
inilib
== basic-libload special-libload;

basic-libload
->
inilib
== "agglib" libload "seqlib" libload "numlib" libload;

include
Str ->
interp.c
Transfers input to file whose name is specified by Str. On end-of-file returns to previous input file.The specified filename has to provide a filename extension.
libload
Str ->
inilib
Str specifies a filename without filename extension. If there is no symbol '_filename' defined, the specified file is included.
special-libload
->
inilib
== "mtrlib" libload "tutlib" libload "lazlib" libload;

verbose
-> B
inilib
== false;
If verbose is defined as false, there comes no notice if a library has already been loaded.
[Contents] [Next] [Previous]

joy / Program: quit, abort, name, body, ...

abort
->
interp.c
Aborts the execution of current Joy program and returns to Joy main cycle.
body
U -> [P]
interp.c
Quotation [P] is the body of user-defined symbol U.
  • [ qsort] first body => [[ small][][ uncons[ >] split][ swapd cons concat] binrec]

gc
->
interp.c
Initiates garbage collection.
intern
Str -> U
interp.c
Pushes the item whose name is string Str.
  • "qsort" intern => qsort
  • "+" intern => +
  • 1 2"+" intern[] cons i => 3

name
U -> Str
interp.c
Result is the type of U for literals, the name of U for atoms and definitions.
  • [ qsort] first name => "qsort"
  • [ +] first name => "+"
  • 17 name => " integer type"

quit
->
interp.c
Exit from Joy.
user
X -> B
interp.c
Tests whether X is a user-defined symbol.
[Contents] [Next] [Previous]

std-input and -output

ask
Str -> X
inilib
== "Please " putchars putchars newline getbr /> ;

bell
->
inilib
== '\007 putch;

get
-> X
interp.c
Reads a factor from input and pushes it onto stack.
Note: While including files ("filename.joy" include ) the input into the Joy system is turned to the specified file. In that case get takes its input from the same file.
newline
->
inilib
== '\n putch;

put
X ->
interp.c
Writes X to output, pops X off stack.
putch
C|I ->
interp.c
Writes character C or whose ASCII is I to stdout.
putchars
Str ->
interp.c
Write Str without quotes to stdout.
putlist
L ->
seqlib
Print a list user-readable to stdout.
[ [1 2 3] [4 5 6] [7 8 [1 2 3] 9] ] putlist is printed as 
[ [1 2 3]
  [4 5 6]
  [7 8 [1 2 3] 9] ]

putln
X ->
inilib
== put newline;

putstrings
L ->
inilib
== [putchars] step;

space
->
inilib
== '\032 putch;

stderr
-> STREAM
interp.c
Pushes the standard error stream.
stdin
-> STREAM
interp.c
Pushes the standard input stream.
stdout
-> STREAM
interp.c
Pushes the standard output stream.
[Contents] [Next] [Previous]

system

getenv
Str -> Str
interp.c
Retrieves the value of the environment variable specified by Str.
system
Str ->
interp.c
Escapes to shell and executes Str. The string may cause execution of another program. When that has finished the process returns to Joy.
[Contents] [Previous]

time and date

clock
-> I
interp.c
Pushes the integer value of current CPU usage in hundreds of a second.
gmtime
I -> L
interp.c
Converts a time I into a list L representing universal time:

[year month day hour minute second isdst yearday weekday].

Month is 1 = January ... 12 = December.
isdst is true or false: (daylight savings/summer time).
weekday is 0 = Monday ... 7 = Sunday.
localtime
I -> L
interp.c
Converts a time I into a list L representing local time:

[year month day hour minute second isdst yearday weekday].

Month is 1 = January ... 12 = December.
isdst is true or false (daylight savings/summer time).
weekday is 0 = Monday ... 7 = Sunday.
localtime-strings
-> L
inilib
Push a list with current time as follows:
[year month day hour minute second isdst yearday weekday].
  • localtime-strings => ["2002""FEB""11""21""52""12""false""00041""Monday"]

mktime
L -> I
interp.c
Converts a list L representing local time into a time I. L has to be in the format generated by localtime.
months
-> L
inilib
== [ "JAN" "FEB" "MAR" "APR" "MAY" "JUN" "JUL" "AUG" "SEP" "OCT" "NOV" "DEC"] ;
x
now
-> S
inilib
Push a string containing current time.
  • now => "21:52:12"

show-todaynow
->
inilib
== today putchars space now putchars newline;
Print current time and date to std-output.
strftime
L Str -> Str
interp.c
Formats a list L in the format of localtime or gmtime using a string and pushes the result as string.
time
-> I
interp.c
Pushes the current time (in seconds since the Epoch).
  • time => 1013460732

today
-> Str
inilib
Push a string containing todays date.
  • today => "Monday 11-FEB-02"

weekdays
-> L
inilib
== [ "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"]li> ;