✎

Owl Builtin Libraries

Owl experimental library reference generator output. #public

(owl alpha)

(alpha-convert exp env)

(owl args)

(process-arguments args rules error-msg cont)
print-rules
(cl-rules lst)
(format-rules rules)

(owl assemble)

(assemble-code obj tail)
(inst->op name)
(bytes->bytecode bytes)

(owl ast)

(call? thing)
(var? thing)
(value-of node)
(sexp->ast exp env)
(mkcall rator rands)
(mklambda formals body)
(mkvar sym)
(mkval val)
(mkvarlambda formals body)

(owl base)

call/cc
wait
lets/cc
(exports (owl list))
(exports (owl rlist))
(exports (owl list-extra))
(exports (owl ff))
(exports (owl io))
(exports (owl lazy))
(exports (owl string))
(exports (scheme base))
(exports (owl symbol))
(exports (owl sort))
(exports (owl vector))
(exports (owl equal))
(exports (owl random))
(exports (owl defmac))
(exports (owl render))
(exports (owl syscall))
(exports (owl bisect))
(exports (owl function))
(exports (owl fasl))
(exports (owl port))
(exports (owl time))
(exports (owl suffix))
(exports (owl regex))
(exports (owl math-extra))
(exports (owl math))
(exports (owl tuple))
(exports (owl digest))
(exports (scheme cxr))
(exports (scheme time))

(owl bisect)

(bisect op lo hi)
(bisect-unsorted op lo hi)
(bisect-range get val lo hi)
(bisect-range-unsorted get val lo hi)

(owl boolean)

(boolean? ?) -> bool, foo bar kuvaus

(owl cgen)

(compile-to-c code extras)
(code->bytes code extras)

(owl char)

char?
char->integer
integer->char

(owl checksum)

(checksum x)
(adler-32 ll)
(fletcher-64 ll)
(make-checksummer n)

(owl closure)

(build-closures exp env)
(uncompiled-closure? thing)

(owl codec)

(hex-encode str)
(hex-decode str)

(owl compile)

primops
prim-opcodes
(compile exp env)

(owl cps)

(cps exp env)

(owl date)

date
(leap-year? n)
(valid-date? d m y)
(next-date day month year)
(week-info d m y)
day-names-fi
day-names-en
(date-str s)
minute
hour
day
week
year
leap-year

(owl defmac)

eof?
o
(not x)
begin
quasiquote
define
letrec
let
if
and
cond
case
let*
or
list
ilist
tuple
tuple-case
->
syntax-error
lets
define*
λ
(immediate? obj)
allocated?
raw?
call-with-values
do
define-library
(i x)
self
letrec*
let*-values
define-values
case-lambda
type-bytecode
type-proc
type-clos
type-fix+
type-fix-
type-pair
type-vector-dispatch
type-vector-leaf
type-vector-raw
type-ff-black-leaf
type-eof
type-tuple
type-symbol
type-const
type-rlist-spine
type-rlist-node
type-port
type-socket
type-tcp-client
type-ff
type-ff-r
type-ff-red
type-ff-red-r
type-string
type-complex
type-rational
type-int+
type-int-
type-string-wide
type-string-dispatch
type-thread-state
define-record-type
_record-values
type-record
(record? x)
->>
if-lets

(owl digest)

sha1
(sha1-raw thing)
sha1-bytes
(hmac-sha1 k m)
hmac-sha1-bytes
sha256
(sha256-raw thing)
sha256-bytes
(hmac-sha256 k m)
hmac-sha256-bytes

(owl dump)

(dump-fasl obj path)
(load-fasl path fval)
(make-compiler extras)

(owl env)

poll-tag
buffer-tag
link-tag
lookup
env-bind
(apply-env exp env)
env-fold
(verbose-vm-error env opcode a b)
prim-opcodes
opcode->wrapper
(primop-of val)
primitive?
thread-quantum
(env-set-macro env key transformer)
(env-set env key val)
*tabula-rasa*
env-del
signal-tag
(signal-halt threads state controller)
(env-get env key def)
(env-keep env namer)
empty-env
env-get-raw
env-put-raw
(env-keys env)
meta-tag
name-tag
current-library-key

(owl equal)

(equal? a b)
eqv?

(owl eval)

(repl env in)
(evaluate exp env)
(repl-file env path)
(repl-port env fd)
(repl-string env str)
(repl-trampoline repl env)
(exported-eval exp env)
(print-repl-error lst)
(bind-toplevel env)
(library-import env exps fail repl)
*owl-core*

(owl fasl)

(encode obj cook)
(tuple->list tuple)
(fasl-encode obj)
fasl-decode
(fasl-encode-cooked obj cook)
(objects-below obj)
(decode-or ll err)
(decode-stream ll err)
(fasl-encode-stream obj cook)
(sub-objects root pred)

(owl ff)

(get ff key def)
(put ff key val)
(ff-fold op state tree)
(ff-foldr op state tree)
(ff-update ff key val) -> ff', *key must be in ff*
(ff-map ff op)
(list->ff lst)
(ff->list ff)
(del ff key)
(ff-union a b collide)
(ff? obj)
(ff-diff a b)
fupd
(ff-iter tree)
(ff-singleton? ff)
getf
(keys ff)
(ff->sexp ff)
(ff-ok? ff)
empty
(empty? x)
(ff-max node def)
(ff-min node def)

(owl fixedpoint)

(fix-points exp env) -> #(ok exp' env)

(owl function)

(function? x)
(bytecode? x)
(procedure? obj)

(owl gensym)

(fresh free)
(gensym exp)

(owl html)

(html exp)
(carry-session sexp var val)

(owl http)

(fail env code reason)
(server server-id handler port)
query-case
(add-response-header env key value)

(owl iff)

(iget ff num def)
(iput ff num val)
(ifold op st ff)
(iff->list iff)

(owl intern)

(string->symbol str)
(symbol->string ob)
(bytes->symbol bytes)
(initialize-interner symbol-list codes)
(string->uninterned-symbol str)
(intern-symbols sexp)
(start-dummy-interner ())
(put-symbol node sym)
(string->interned-symbol root str)
empty-symbol-tree
(start-symbol-interner initial-symbols)

(owl io)

(display x)
print
(fclose fd)
(open-output-file path)
(open-input-file path)
(sleep ms)
(print-to to . stuff)
(close-port fd)
(flush-port fd)
(system-println str)
(print* lst)
(port->byte-stream fd)
(file->vector path)
(write-vector write each leaf chunk separately (note)
(write obj)
stdout
stderr
stdin
(open-socket port)
(open-connection ip port)
(start-base-threads ())
(vector->file vec path)
(wait-write fd)
(tcp-clients port)
(tcp-send ip port ll)
(display-to to obj)
(print*-to to lst)
(system-print str)
(system-stderr str)
write-to
(write-bytes port byte-list)
(write-byte-vector port bvec)
port->fd
port?
fd->port
(blocks->port ll fd)
(closing-blocks->port ll fd)
(tcp-socket port)
(tcp-client sock)
(get-block fd block-size)
(try-get-block fd block-size block?)
(lines fd)
(fasl-save obj path)
(fasl-load path fail-val)
(writer-to names)
(write-really bvec fd)
(file->list path)
(start-muxer . id)
(open-append-file path)
(file-size path)
(byte-stream->port bs fd)
(port->block-stream fd)
(block-stream->port bs fd)
(port->meta-byte-stream fd)

(owl lazy)

pair
subsets
permutations
(tail l)
(lfold op state lst)
(lfoldr op state lst)
(lmap fn l)
(lappend a b)
(lfor state lst op)
(liota pos step end)
(liter op st)
(lnums n)
(lzip op a b)
(uncons l d)
(ltake l n)
(llast l)
(llen lst)
(force thunk)
(lunfold op st end?)
delay
(avg ll)
(force-ll it)
(ldrop l n)
(llref ll p)
(lkeep p l)
(lremove p l)
(lcar ll)
(lcdr ll)
(ledit op l)

(owl list-extra)

(iota from step to)
(take l n)
(lref lst pos)
(lset lst pos val)
(length lst)
(drop l n)
(ldel lst pos)
(led lst pos op)
(ledn lst pos op)
(lins lst pos val)
list-ref
(list-tail lst n)
(repeat thing n)
(split l n)

(owl list)

(getq lst k) -> #false | value, get a value from an association list
(has? lst key) -> bool
(foldr op st lst) -> st', compute a value from the right
- (foldr - 0 '(1 2 3)) = 2
- (foldr cons null '(a b c)) = '(a b c)
(remove pred lst)
(null? any) -> bool
null
(append append list ...) -> list', join lists
- (append '(1) '() '(2 3)) = '(1 2 3)
(caar '((a . b) . c)) -> a
(cadr '(a . (b . c))) -> b
(cdar '((a . b) . c)) -> b
(cddr '(a . (b . c))) -> c
(reverse lst) -> lst', reverse a list
(for-each fn lst) -> , run a function to all elements of a list for side effects_
(map fn lst) -> lst', run a function to all elements of a list
- (map even? '(1 2 3)) = '(#false #true #false)
(fold op state lst) -> state', walk over a list from left and compute a value
- (fold - 0 '(1 2 3)) = -6
- (fold (lambda (a b) (cons b a)) null '(a b c)) = '(c b a)
(keep pred lst)
(zip fn as bs) -> ((fn a b) ...), zip values of lists together with a function
- (zip cons '(1 2 3) '(a b c d)) = '((1 . a) (2 . b) (3 . c))
(pair? any) -> bool
(first pred l def)
(mem mem compare lst elem) -> bool, check if lst contains elem comparing with compare
(for st l op)
(all pred lst)
(some pred lst)
(last last list default) -> last-elem | default, get the last value of a list
(drop-while pred lst)
(list? any) -> bool, O(n)
(smap op st lst)
(unfold op st end?)
(take-while pred lst)
(fold2 op s1 s2 lst) -> s1' s2', fold with 2 states
(diff a b)
(union a b)
(intersect a b)
(fold-map o s l)
(foldr-map o s l)
(halve lst)
╯°□°╯
(interleave mid lst)
(edit op l)

(owl macro)

(match pattern exp)
(macro-expand exp env)
(make-transformer literals rules)

(owl math-extra)

(expt a b)
(isqrt n)
(sqrt n)
(expt-mod a b m)
(ncr n m)
(npr n m)
(! n)
(factor n)
(prime? n)
primes-between
(totient n)
(divisor-sum num)
(divisor-count n)
dlog
(fib n)
dlog-simple
(exact-integer-sqrt n)
phi
(histogram (num ...) [n-bins]) -> ((n-in-bin . bin-limit) ...)

(owl math)

(fixnum? x)
+
-
*
(/ a b)
(= a b)
(< a b)
(> a b)
(>> a b)
(<< a b)
(add rational case: a/b + c)
(<= a b)
(>= a b)
(number? a)
(band a b)
(bor a b)
(bxor a b)
fx%
(negate num)
divmod
(gcd a b)
(mod a b)
(rem a b)
(quotrem a b)
(div a b)
(min a b)
(max a b)
ediv
(floor n)
(even? n)
(odd? n)
(abs n)
(sub a b)
(mul a b)
(big-bad-args op a b)
(ceiling n)
quotient
quot
ceil
(minl as)
(maxl as)
(gcdl ls)
(sum l)
(product l)
(negative? a)
(numerator n)
(denumerator n)
(log n a)
(log2 n)
(render-number num tl base)
(zero? x)
(exact? n)
(inexact? n)
real?
complex?
rational?
(exact->inexact n)
(inexact->exact n)
positive?
(denominator n)
(integer? a)
remainder
(lcm a b)
modulo
(truncate n)
(round n)
rational
complex
*max-fixnum*
*fixnum-bits*
(nat-succ n)

(owl parse)

(assert pred val)
let-parses
(get-byte ll ok fail pos)
(get-imm n)
(get-epsilon val)
(get-byte-if pred)
(get-one-of bytes)
(get-word str val)
(get-either a b)
(get-kleene* par)
(get-kleene+ what)
(fd->exp-stream fd prompt parse fail re-entry?)
get-rune
(get-rune-if pred)
get-any-of
(peek parser)
(get-greedy* parser)
(get-greedy+ parser)
(null-stream? ll)
(try-parse parser data maybe-path maybe-error-msg fail-val)
(file->exp-stream path prompt parse fail)
(get-word-ci str val)
(get-greedy-repeat n parser)

(owl port)

(socket? x)
(port->fd port)
(tcp? x)
(port? x)
(fd->port fd)
(fd->socket fd)
(fd->tcp fd)

(owl primop)

mkt
bind
eq?
run
ff-bind
apply
call/cc
(set-memory-limit n)
(get-word-size ())
(get-memory-limit ())
clock
set-ticker
(wait n)
sys-prim
(halt n)
primops
multiple-return-variable-primops
(variable-input-arity? op)
(special-bind-primop? op)
(start-seccomp ())
call-with-current-continuation
lets/cc
(bytes->bytecode bytes)
apply-cont
(primop-name pop)
(vm . bytes)
(bytecode-function fixed? arity bytes)
_poll2

(owl queue)

qnull
(qlen cl)
(qcons a cl)
(qsnoc a cl)
(quncons cl d)
(qunsnoc cl d)
(list->queue lst)
(queue->list cl)
(qnull? cl)
(qcar cl)
(qrac cl)

(owl random)

(rand rs max)
(random-numbers rs bound count)
(rand-nbit rs n)
(rand-log rs n)
(rand-range rs lo hi)
(shuffle rs lst)
random-permutation
(random-subset rs l)
(rand-elem rs obj)
(reservoir-sample rs ll n)
seed->rands
(rands->bits rs)
seed->bits
(rands->bytes rs)
seed->bytes
(lcg-rands seed)
(rand-subset rs l)
(rand-occurs? rs prob)

(owl regex)

get-sexp-regex
string->regex
(string->replace-regex str)
(string->complete-match-regex str) -> rex|#false, for conversion of strings to complete matchers
(rex-matches rex thing)

(owl register)

(allocate-registers rtl)
n-registers

(owl render)

(render obj tl)
(make-serializer names)
(str . args)

(owl rlist)

rnull?
(rlist? l)
(rcons a r)
(rcar r)
(rcdr rl)
(rget r p d)
(rset rl pos val)
(rfold op st rl)
(rfoldr op st rl)
(rmap op rl)
(list->rlist lst)
(rlist->list rl)
(riter rl)
(riterr rl)
(rlen r)
requal?
rlist
(rrev rl)

(owl sexp)

(string->sexp str fail)
sexp-parser
(read-exps-from data done fail)
(list->number lst base)
get-sexps
(vector->sexps vec fail errmsg)
(list->sexps lst fail errmsg)
(read thing . rest)
read-ll

(owl sort)

(sort op lst)
(quicksort op lst)
(mergesort op l)
(isort op lst)

(owl string)

(string? x)
(string-eq? a b)
(string-length str)
(string->bytes str)
string-append
(runes->string lst)
bytes->string
null-terminate
(render-string str tl)
(finish-string chunks)
(str-fold op st str)
(str-foldr op st str)
(str-iter str)
(str-iterr str)
(str-app a b)
(string->runes str)
list->string
string->list
(str-replace str pat val)
(c-string str)
(str-map op str)
(str-rev str)
string
string-copy
(substring str start end)
(string-ref str p)
(string<? a b)
(string>? a b)
(string<=? a b)
(string>=? a b)
(unicode-fold-char codepoint tail)
(string-ci<? a b)
(string-ci>? a b)
(string-ci<=? a b)
(string-ci>=? a b)
(make-string n char)
string=?
(string-ci=? a b)
(render-quoted-string str tl)
char=?
(char-ci=? a b)
(str-iter-bytes str)

(owl suffix)

suffix-list
(suffix-array thing)

(owl symbol)

(symbol? x)
(symbol->string x)

(owl syscall)

(fork thunk)
(syscall op a b)
(error reason info)
(fork-named name thunk)
(fork-server name handler)
(mail id msg)
(wait-mail ())
(accept-mail pred)
(interact whom message)
(fork-linked name thunk)
(check-mail ())
(set-signal-action choice)
(kill id)
(catch-thread id)
(release-thread thread)
(fork-linked-server name handler)
(return-mails rmails)
(exit-thread value)
(single-thread? ())
(exit-owl value)
(poll-mail-from id rounds default)
(start-profiling ())
(stop-profiling ())
(running-threads ())
(par* ts)
par
(por* ts)
por

(owl sys)

(fork ())
(kill pid signal)
(wait pid)
(dir-fold op st path)
(dir->list path)
(getenv str)
(exec path args)
(chdir path)
sighup
signint
sigquit
sigill
sigabrt
sigfpe
sigkill
sigsegv
sigpipe
sigalrm
sigterm
(seek-end fd)
(unlink path)
(rmdir path)
(mkdir path mode)
(lseek fd pos whence)
(seek-pos fd pos)

(owl terminal)

(output lst val)
(port->readline-sexp-stream port prompt)
(set-terminal-rawness rawp)
(font-normal lst)
(font-bold lst)
(clear-screen lst)
(clear-screen-top lst)
(clear-screen-bottom lst)
(clear-line lst)
(clear-line-left lst)
(clear-line-right lst)
(set-cursor lst x y)
(cursor-hide lst)
(cursor-show lst)
(cursor-save lst)
(cursor-restore lst)
(cursor-up lst n)
(cursor-down lst n)
(cursor-left lst n)
(cursor-right lst n)
tio
(terminal-server fd receiver)
(get-terminal-size ll)
(port->readline-line-stream port prompt)
(terminal-input . opt)
(readline ll history x y w)
(draw-box tl xo yo w h)
tio*

(owl thread)

(thread-controller self todo done state)
(repl-signal-handler threads state controller)
(start-thread-controller threads state-alist)
(try thunk fail-val)

(owl time)

(time ())
(time-ms ())
(elapsed-real-time thunk)
timed

(owl tuple)

(tuple? x)
(list->tuple lst)
(tuple->list tuple)
(read-tuple tuple pos lst)

(owl unicode)

(utf8-encode thing)
(utf8-decode lst)
(encode-point point tl)
(two-byte-point a b)
(three-byte-point a b c)
(four-byte-point a b c d)
(utf8-sloppy-decode lst)
last-code-point
(valid-code-point? val)
(utf8-decoder ll fail)

(owl vector)

(byte-vector? x)
(vector? x)
(vec-len vec)
(vec-ref v n)
(vec->list vec)
(vec-iterr v)
(vec-foldr op st vec)
(list->vector l)
vector->list
(vec-iter v)
(vec-fold op st vec)
vec-range
(vec-iter-range v p e)
vector
(merge-chunks ll len)
(leaf-data leaf)
(vec-leaf-of v n)
(vec-leaves vec)
(vec-map fn vec)
(vec-cat a b)
(vec-rev a)
(list->byte-vector bs)
vector-ref
vector-length
make-vector
*vec-leaf-size*

(scheme base)

boolean?
syntax-rules
define-syntax
not
eq?
+
-
*
/
=
<
>
null?
append
caar
cadr
cdar
cddr
reverse
for-each
map
equal?
pair?
string?
symbol?
char?
cons
car
cdr
lambda
begin
...
unquote
quasiquote
quote
values
error
define
<=
>=
string-length
number?
letrec
let
if
and
else
cond
=>
apply
case
let*
or
list
close-port
gcd
call/cc
string-append
expt
min
max
syntax-error
floor
even?
odd?
abs
length
list?
vector?
string->symbol
ceiling
list->vector
vector->list
quotient
(string->integer str)
negative?
list->string
string->list
vector
numerator
unquote-splicing
zero?
string->number
eqv?
exact?
inexact?
real?
complex?
rational?
symbol->string
set!
vector-set!
positive?
denominator
number->string
char->integer
integer->char
call-with-current-continuation
list-ref
list-tail
string
vector-ref
vector-length
procedure?
(member x lst)
(memq x lst)
memv
call-with-values
string-copy
do
assoc
(assv k l)
(assq k l)
integer?
remainder
substring
string-ref
string<?
string>?
string<=?
string>=?
lcm
(rationalize n max-delta)
exact-integer-sqrt
modulo
truncate
round
make-string
string=?
make-vector
set-car!
set-cdr!
string-set!
cond-expand
include
letrec*
let*-values
define-values
port?
char=?
define-record-type
binary-port?
boolean=?
bytevector
bytevector-append
bytevector-copy
bytevector-copy!
bytevector-length
bytevector-u8-ref
bytevector-u8-set!
bytevector?
call-with-port
char-ready?
char<=?
char<?
char>=?
char>?
close-input-port
close-output-port
current-error-port
current-input-port
current-output-port
dynamic-wind
eof-object
eof-object?
error-object-irritants
error-object-message
error-object?
exact
exact-integer?
features
file-error?
floor-quotient
floor-remainder
floor/
flush-output-port
get-output-bytevector
get-output-string
guard
include-ci
inexact
input-port-open?
input-port?
let-syntax
let-values
letrec-syntax
list-copy
list-set!
make-bytevector
make-list
make-parameter
newline
open-input-bytevector
open-input-string
open-output-bytevector
open-output-string
output-port-open?
output-port?
parameterize
peek-char
peek-u8
raise
raise-continuable
read-bytevector
read-bytevector!
read-char
read-error?
read-line
read-string
read-u8
(square x)
string->utf8
string->vector
string-copy!
string-fill!
string-for-each
string-map
symbol=?
textual-port?
truncate-quotient
truncate-remainder
truncate/
u8-ready?
unless
utf8->string
vector->string
vector-append
vector-copy
vector-copy!
vector-fill!
vector-for-each
vector-map
when
with-exception-handler
write-bytevector
write-char
write-string
write-u8

(scheme case-lambda)

case-lambda

(scheme complex)

(angle z)
(imag-part z)
(magnitude z)
(make-polar mag ang)
(make-rectangular rl im)
(real-part z)

(scheme cxr)

(caaar x)
(caadr x)
(cadar x)
(caddr x)
(cdaar x)
(cdadr x)
(cddar x)
(cdddr x)
(caaaar x)
(caaadr x)
(caadar x)
(caaddr x)
(cadaar x)
(cadadr x)
(caddar x)
(cadddr x)
(cdaaar x)
(cdaadr x)
(cdadar x)
(cdaddr x)
(cddaar x)
(cddadr x)
(cdddar x)
(cddddr x)

(scheme time)

current-jiffy
current-second
jiffies-per-second

(scheme write)

display
write
write-shared
(write-simple . x)