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)