Functions

Here is the list of functions available in lispe:

@ : get value from a container at positions k1..kn

@@: (@@ e i1 (i2)), i2 is optional

@@@: (@@@ list shape k1...kn)

and: (and cond1 cond2 cond3)

andvalue: (andvalue cond1 cond2 value)

apply: (apply fonc a1 a2...)

at: (see @)

atshape: (extracts values in a flat list according to a shape)

atomp: (atomp e)

atoms: (atoms)

bodies: (bodies name)

block

bappend: (bappend pathname list_of_shorts)

bread: (bread pathname)

bwrite: (bwrite pathname list_of_shorts)

bytes: (bytes string)

car, cdr, cadr...

catch

check : (check CONDITION I1..In)

clone: clone structure

complex: complex numbers

cond: (cond (cond1 instructions)...)

cons: (cons e l)

consb: (consb l e)

consp: (consp e)

containerkeys : (containerkeys dict)

containervalues : (containervalues dict)

count object sub pos

cutlist list size

cyclicp: (cyclicp e)

data: (data D1 D2 ..)

defmacro

deflib: Internal use of the interpreter

defun: Function definition

dethread: Launching a thread

defpat: pattern function definition

defspace: defines a space

dictionary: creates a dictionary indexes on strings

dictionaryi: creates a dictionary indexes on integers

dictionaryn: creates a dictionary indexes on numbers

dictionarytree: creates a dictionary ordered on strings

dictionarytreei: creates a dictionary ordered on integers

dictionarytreen: creates a dictionary ordered on numbers

droplist: (droplist condition list)

emptyp

endwith: (endwith str fnd)

enum: (loop c (enum l) ...)

eq/neq: (eq e1 e2)

eval

explode: (explode string)

extract: (extract e i1 (i2)), i2 is optional

fappend: (append pathname data)

fopen: (fopen pathname op)

filterlist: (filterlist condition list)

find : (find e o pos)

findall : (findall chaine chaine pos)

flatten: (flatten l)

flip: (flip (f x y))

float: (float e)

floats: (floats e)

fclose: (fclose fe)

fgetchars: (fgetchars fe nb)

fputchars: (fputchars fe str)

fseek: (fseek fe pos)

fsize: (fsize fe)

ftell: (ftell fe)

fread: (fread pathname)

fwrite: (fwrite pathname data)

heap: (heap comparison v1 v2...)

if : (if (predicate) THEN ELSE)

imaginary: imaginary part of a complex number

in : (in e o pos)

input

integer : (integer e)

integers : (integers e)

insert : (insert l e idx)

join: (join l sep)

keys@: (keys@ dictionary)

label : (label lab exp)

lambda : lambda function definition

last : (last e)

let : (let ((v1 val1)..(vn valn)) i1..in)

link: (link str atom)

list : (list e1 e2 ..)

llist : (llist e1 e2 ..)

load : (load filename (namespace))

loadcode : (loadcode string (namespace))

lock : mutex

loop : (loop var liste instruction1 instruction2...)

loopcount: (loopcount nb instructions)

lloop (x1 x2 x3...) l1 l2 l3... instructions)

mapcar : (mapcar function list)

mask : (mask Bools LTRUE LFALSE)

mloop : (mloop (x1 x2 x3...) c1 c2 c3... instructions)

maplist : (maplist function list)

mark: (mark l B) marks lists for controlling infinite loops

maybe: (maybe c)

max : (max a1 a2 a3) / (max '(e1 e2 e3))

min : (min a1 a2 a3) / (min '(e1 e2 e3))

minmax : (minmax a1 a2 a3) / (minmax '(e1 e2 e3))

ncheck: (ncheck CONDITION ELSE I1 I2..)

nconc: (nconc l1 l2...)

nconcn: (nconcn l1 l2...)

not : (not e)

nth : (nth l i)

nullp : check if the argument is nil

number : (number e)

numberp : check if the argument is a number

numbers : (numbers e)

or : or Boolean

over: (over 'function lst)

pipe : (pipe)

pop : (pop e cle)

popfirst : (popfirst e)

poplast : (poplast e)

prettify : (prettify l)

print : (print e1 e2 .. en)

println : (println e1 e2 .. en)

printerr : (printerr e1 e2 .. en)

printerrln : (printerrln e1 e2 .. en)

push : (push l a)

pushfirst : (pushfirst l a)

pushlast : (pushlast l a)

pushtrue : (pushtrue l a)

quote : (quote arg)

range : (range initial limit step)

rangein : (rangein initial limit step)

real: real part of a complex number

replaceall : (replaceall object search replace)

resetmark: resets marks for controlling infinite loops

return : (return a)

reverse : (reverse l local)

rfind : (find chaine subch)

rotate : (rotate x nb)

scanlist : (scanlist action let)

self : (self e1 e2..)

select: (select c1 c2 c3)

set: set, sets, seti, setn

setrange : modify container between position b e

set@ : modify container at positions k1...kn

set@@ : same as setrange

set@@@ : same as setshape

setshape : (setshape container shape k1...kn value)

setg : (setg label valeur)

setq : (setq label value)

seth : (seth label value)

short: (short e)

shorts: (shorts e)

sign : (sign e)

signp : (signp e)

size : (size e)

sleep: (sleep tm)

slice list size

sort : (sort a list)

space : (call functions defined in a space)

startwith: (startwith str fnd)

string : (string e)

stringp : (stringp e)

strings : (strings e)

switch

takelist: (takelist condition list)

takenb: (takenb nb lst)

tally: (tally m)

threadclear : clear protected list for threads

threadretrieve : protected list for threads

threadstore : (threadstore namespace e)

threadspace : (threadspace...)

to_list: (to_list object)

to_llist: (to_llist object)

to_tensor: (to_tensor object)

trace : (trace bool)

tree: (tree k v k v kv)

treei: (treei k v k v kv)

treen: (treen k v k v kv)

trigger: (trigger key)

type : (type e)

unique: (unique lst)

use : (use bib)

uuid : Universally Unique Identifier

values@: (values@ dictionary)

wait : wait for threads to end

waiton: (waiton key)

while : (while (condition) instruction1 instruction2 ...)

whilein : (whilein var lst condition instruction1 instruction2 ...)

xor : Exclusive Boolean or

zerop : returns true if value is zero

Haskell Functions

Composition

map : (map op list)

filter : (filter condition list)

drop : (drop nb list)

dropwhile : (dropwhile condition list)

take : (take nb list)

replicate : (replicate nb value)

repeat : (repeat nb)

cycle : (cycle list)

takewhile : (takewhile condition liste)

irange: (irange initial increment)

foldl : (foldl op list initial)

foldl1 : (foldl1 op list)

foldr : (foldr op list initial)

foldr1 : (foldr1 op list)

scanl : (scanl op liste initial)

scanl1 : (scanl1 op list)

scanr : (scanr op list initial)

scanr1 : (scanr1 op list)

zip : (zip l1 l2 l3...)

zipwith : (zipwith op l1 l2 l3...)

APL Functions

backreduce

backscan

concatenate

determinant of a matrix

inner product

invert/solve

iota

irank: (irank m D1 D2...)

ludcmp

lubksb

member

outer product

rank: (rank m D1 D2...)

reduce: (reduce op lst)

rho

scan: (scan op lst)

transpose: (transpose m)

Description of these operators in APL