Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-05-19 21:59:16 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
cyclone/docs/api/scheme/base.md
Justin Ethier f0fb0ab198 Added macros
2016-09-30 00:14:22 -04:00

505 lines
12 KiB
Markdown
Raw Blame History

# 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)
Reference in a new issue View git blame Copy permalink