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<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).

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