cyclone/docs/api/scheme/base.md

Base Library

The (scheme base) library exports many of the procedures and syntax bindings that are traditionally associated with Scheme.

For more information see the R⁷RS Scheme Specification.

• abs
• and
• any
• append
• assoc
• assq
• assv
• begin
• boolean=?
• bytevector-copy
• bytevector-copy!
• call-with-current-continuation
• call-with-port
• call-with-values
• call/cc
• case
• ceiling
• char<=?
• char<?
• char=?
• char>=?
• char>?
• complex?
• cond
• cond-expand
• current-error-port
• current-input-port
• current-output-port
• define-record-type
• denominator
• do
• dynamic-wind
• eof-object
• error
• even?
• every
• exact
• exact-integer?
• exact?
• expt
• features
• floor
• floor-quotient
• floor-remainder
• floor-remainder
• floor/
• flush-output-port
• foldl
• foldr
• for-each
• gcd
• get-output-bytevector
• get-output-string
• guard
• inexact
• inexact?
• input-port-open?
• input-port?
• lcm
• let
• let*
• let*-values
• let-values
• letrec
• letrec*
• list
• list-copy
• list-ref
• list-set!
• list-tail
• list?
• make-constructor
• make-getter
• make-list
• make-parameter
• make-setter
• make-string
• make-type-predicate
• map
• max
• member
• memq
• memv
• min
• modulo
• negative?
• newline
• not
• numerator
• odd?
• open-input-bytevector
• open-input-string
• open-output-bytevector
• open-output-string
• or
• output-port-open?
• output-port?
• parameterize
• positive?
• quasiquote
• quotient
• raise
• raise-continuable
• rational?
• read-line
• read-string
• receive
• record?
• remainder
• reverse
• round
• slot-set!
• square
• string
• string->list
• string->utf8
• string->vector
• string-copy
• string-copy!
• string-fill!
• string-for-each
• string-map
• string<=?
• string<?
• string=?
• string>=?
• string>?
• symbol=?
• syntax-error
• truncate
• truncate-quotient
• truncate-remainder
• truncate/
• type-slot-offset
• unless
• utf8->string
• values
• vector
• vector->list
• vector->string
• vector-append
• vector-copy
• vector-copy!
• vector-fill!
• vector-for-each
• vector-map
• when
• with-exception-handler
• write-char
• write-string
• zero?

abs

(abs num)

and

(and {test1} ...)

any

(any pred lst)

append

(append list ...)

assoc

(assoc obj alist)

(assoc obj alist compare)

assq

(assq obj alist)

assv

(assv obj alist)

begin

(begin {expression or definition} ...)

boolean=?

(boolean=? b1 b2 ...)

bytevector-copy

(bytevector-copy bytevector)

(bytevector-copy bytevector start)

(bytevector-copy bytevector start end)

bytevector-copy!

(bytevector-copy! to at from)

(bytevector-copy! to at from start)

(bytevector-copy! to at from start end)

call-with-current-continuation

(call-with-current-continuation proc)

call-with-port

(call-with-port port proc)

call-with-values

(call-with-values producer consumer)

call/cc

(call/cc proc)

case

(case {key} {clause1} {clause2} ...)

ceiling

(ceiling z)

char<=?

(char<=? c1 c2 c3 ...)

char<?

(char<?  c1 c2 c3 ...)

char=?

(char=?  c1 c2 c3 ...)

char>=?

(char>=? c1 c2 c3 ...)

char>?

(char>?  c1 c2 c3 ...)

complex?

(complex? obj) 

cond

(cond {clause1} {clause2} ...)

cond-expand

(cond-expand {ce-clause2} {ce-clause2} ...)

current-error-port

(current-error-port)

current-input-port

(current-input-port)

current-output-port

(current-output-port)

define-record-type

(define-record-type {name}

  {constructor} {pred} {field} ...)

denominator

(denominator n)

do

(do (({variable1} {init1} {step1})

     ...)

({test} {expression} ...)

{command} ...)

dynamic-wind

(dynamic-wind before thunk after)

eof-object

(eof-object)

error

(error message obj ...)

even?

(even? num)

every

(every pred lst)

exact

(exact? num)

exact-integer?

(exact-integer? num)

exact?

(exact? num)

expt

(expt z1 z2)

features

(features) 

floor

(floor z)

floor-quotient

(floor-quotient n m)

floor-remainder

(floor-remainder n m)

floor/

(floor/ n m)

flush-output-port

(flush-output-port)

(flush-output-port port)

foldl

(foldl func accum lst)

foldr

(foldr func end lst)

for-each

(for-each proc list1 list2 ...)

gcd

(gcd n1 ...)

get-output-bytevector

(get-output-bytevector port)

get-output-string

(get-output-string port)

guard

(guard ({variable}

        {cond clause1} {cond clause2} ...)

  {body})

inexact

(inexact z)

inexact?

(inexact? num)

input-port-open?

(input-port-open? port)

input-port?

(input-port? port)

lcm

(lcm n1 ...)

let

(let {bindings} {body})

let*

(let* {bindings} {body})

let*-values

(let*-values {mv binding spec} {body})

let-values

(let-values {mv binding spec} {body})

letrec

(letrec {bindings} {body})

letrec*

(letrec* {bindings} {body})

list

(list obj ...)

list-copy

(list-copy lst)

list-ref

(list-ref lst k)

list-set!

(list-set! lst k obj)

list-tail

(list-tail lst k) 

list?

(list? o)

make-constructor

(make-constructor make name)

make-getter

(make-getter sym name idx)

make-list

(make-list k )

(make-list k fill)

make-parameter

(make-parameter init)

(make-parameter init converter)

make-setter

(make-setter sym name idx)

make-string

(make-string k)

(make-string k fill)

make-type-predicate

(make-type-predicate pred name)

map

(map proc list1 list2 ...)

max

(max x1 x2 ...)

member

(member obj lst) 

(member obj lst compare) 

memq

(memq obj lst)

memv

(memv obj lst)

min

(min x1 x2 ...)

modulo

(modulo a b)

negative?

(negative? n)

newline

(newline)

(newline port) 

not

(not x)

numerator

(numerator n) n)

odd?

(odd? num)

open-input-bytevector

(open-input-bytevector bv)

open-input-string

(open-input-string string)

open-output-bytevector

(open-output-bytevector open-output-string)

open-output-string

(open-output-string)

or

(or {test1} ...)

output-port-open?

(output-port-open? port)

output-port?

(output-port? obj)

parameterize

(parameterize (({param1} {value1}) ...)

  {body})

positive?

(positive? n)

quasiquote

(quasiquote {qq template})

quotient

(quotient x y)

raise

(raise obj)

raise-continuable

(raise-continuable obj)

rational?

(rational? obj)

read-line

(read-line)

(read-line port)

read-string

(read-string k)

(read-string k port)

receive

(receive {formals} {expression} {body})

record?

(record? obj)

remainder

(remainder num1 num2)

reverse

(reverse lst)

round

(round z)

slot-set!

(slot-set! name obj idx val)

square

(square z)

string

(string char ...)

string->list

(string->list string)

(string->list string start)

(string->list string start end)

string->utf8

(string->utf8 string)

(string->utf8 string start)

(string->utf8 string start end)

string->vector

(string->vector string)

(string->vector string start)

(string->vector string start end)

string-copy

(string-copy string)

(string-copy string start)

(string-copy string end)

string-copy!

(string-copy! to at from)

(string-copy! to at from start)

(string-copy! to at from start end)

string-fill!

(string-fill! str fill)

(string-fill! str fill start)

(string-fill! str fill start end)

string-for-each

(string-for-each proc string1 string2 ...)

string-map

(string-map proc string1 string2 ...)

string<=?

(string<=? str1 str2)

string<?

(string<? str1 str2)

string=?

(string=? str1 str2)

string>=?

(string>=? str1 str2)

string>?

(string>? str1 str2)

symbol=?

(symbol=? symbol1 symbol2 symbol3 ...)

syntax-error

(syntax-error {message} {args} ...)

truncate

(truncate z)

truncate-quotient

(truncate-quotient quotient)

truncate-remainder

(truncate-remainder remainder)

truncate/

(truncate/ n m)

type-slot-offset

(type-slot-offset name sym)

unless

(unless {test} {expression1} {expression2} ...)

utf8->string

(utf8->string bytevector)

(utf8->string bytevector start)

(utf8->string bytevector start end)

values

(values obj ...)

vector

(vector obj ...)

vector->list

(vector->list vector)

(vector->list vector start)

(vector->list vector start end)

vector->string

(vector->string vector)

(vector->string vector start)

(vector->string vector start end)

vector-append

(vector-append vector ...)

vector-copy

(vector-copy vector)

(vector-copy vector start)

(vector-copy vector start end)

vector-copy!

(vector-copy! to at from)

(vector-copy! to at from start)

(vector-copy! to at from start end)

vector-fill!

(vector-fill! vector fill)

(vector-fill! vector fill start)

(vector-fill! vector fill start end)

vector-for-each

(vector-for-each proc vector1 vector2 ...)

vector-map

(vector-map proc vector1 vector2 ...)

when

(when {test} {expression1} {expression2} ...)

with-exception-handler

(with-exception-handler handler thunk)

write-char

(write-char char)

(write-char char port)

write-string

(write-string string)

(write-string string port)

zero?

(zero? n)