mirror of
https://github.com/justinethier/cyclone.git
synced 2025-07-15 16:57:35 +02:00
Initial file
This commit is contained in:
Justin Ethier
parent
c2c2a8eabf
commit
f2e545bfa9
38 changed files with 3861 additions and 11 deletions
967
docs/API.md
967
docs/API.md
|
|
@ -3,12 +3,24 @@ layout: main
|
|||
title: API
|
||||
---
|
||||
|
||||
[<img src="images/cyclone-logo-04-header.png" alt="cyclone-scheme">](http://github.com/justinethier/cyclone)
|
||||
|
||||
# API Documentation
|
||||
|
||||
- [R<sup>7</sup>RS Libraries](#r7rs-libraries)
|
||||
- [SRFI Libraries](#srfi-library-support)
|
||||
- [Cyclone Compiler API](#cyclone-compiler-api)
|
||||
- [Index](#index)
|
||||
|
||||
# R<sup>7</sup>RS Libraries
|
||||
|
||||
- Cyclone runtime
|
||||
This section of the Cyclone API is based on the [R<sup>7</sup>RS Scheme Specification](r7rs.pdf):
|
||||
|
||||
- [Primitives](api/primitives.md)
|
||||
- [`scheme base`](api/scheme/base.md)
|
||||
- [`scheme case-lambda`](api/scheme/case-lambda.md)
|
||||
- [`scheme char`](api/scheme/char.md)
|
||||
- [`scheme complex`](api/scheme/complex.md)
|
||||
- [`scheme cxr`](api/scheme/cxr.md)
|
||||
- [`scheme eval`](api/scheme/eval.md)
|
||||
- [`scheme file`](api/scheme/file.md)
|
||||
|
|
@ -20,9 +32,9 @@ title: API
|
|||
- [`scheme time`](api/scheme/time.md)
|
||||
- [`scheme write`](api/scheme/write.md)
|
||||
|
||||
# SRFI Library Support
|
||||
# SRFI Libraries
|
||||
|
||||
Cyclone supports the following [Scheme Requests for Implementation (SRFI)](http://srfi.schemers.org/) libraries:
|
||||
Cyclone supports the following [Scheme Requests for Implementation (SRFI)](http://srfi.schemers.org/) libraries. Detailed information is available in the linked SRFI page as well as the provided Cyclone API:
|
||||
|
||||
- [`srfi 1`](api/srfi/1.md) - [List Library](http://srfi.schemers.org/srfi-1/srfi-1.html)
|
||||
- [`srfi 2`](api/srfi/2.md) - [`and-let*`](http://srfi.schemers.org/srfi-2/srfi-2.html)
|
||||
|
|
@ -30,17 +42,950 @@ Cyclone supports the following [Scheme Requests for Implementation (SRFI)](http:
|
|||
- [`srfi 18`](api/srfi/18.md) - [Multithreading support](http://srfi.schemers.org/srfi-18/srfi-18.html)
|
||||
- [`srfi 27`](api/srfi/27.md) - [Sources of random bits](http://srfi.schemers.org/srfi-27/srfi-27.html)
|
||||
- [`srfi 69`](api/srfi/69.md) - [Basic hash tables](http://srfi.schemers.org/srfi-69/srfi-69.html)
|
||||
- [`srfi 106`](api/srfi/106.md) - [Basic socket interface](http://srfi.schemers.org/srfi-106/srfi-106.html)
|
||||
- [`srfi 111`](api/srfi/111.md) - [Boxes](http://srfi.schemers.org/srfi-111/srfi-111.html)
|
||||
- [`srfi 117`](api/srfi/117.md) - [Mutable queues](http://srfi.schemers.org/srfi-117/srfi-117.html)
|
||||
- [`srfi 132`](api/srfi/132.md) - [Sort Libraries](http://srfi.schemers.org/srfi-132/srfi-132.html)
|
||||
- [`srfi 133`](api/srfi/133.md) - [Vector Library (R7RS-compatible)](http://srfi.schemers.org/srfi-133/srfi-133.html)
|
||||
|
||||
# Cyclone-specific
|
||||
# Cyclone Compiler API
|
||||
|
||||
These libraries are used by the Cyclone compiler itself, and are subject to change:
|
||||
These libraries are used by the Cyclone compiler. Some of these, such as `pretty-print` are stable and unlikely to change, whereas others could change as the compiler evolves.
|
||||
|
||||
- `scheme cyclone cgen`
|
||||
- `scheme cyclone common`
|
||||
- `scheme cyclone libraries`
|
||||
- `scheme cyclone macros`
|
||||
- `scheme cyclone transforms`
|
||||
- `scheme cyclone util`
|
||||
- [`scheme cyclone ast`](api/scheme/cyclone/ast.md)
|
||||
- [`scheme cyclone cgen`](api/scheme/cyclone/cgen.md)
|
||||
- [`scheme cyclone common`](api/scheme/cyclone/common.md)
|
||||
- [`scheme cyclone cps-optimizations`](api/scheme/cyclone/cps-optimizations.md)
|
||||
- [`scheme cyclone libraries`](api/scheme/cyclone/libraries.md)
|
||||
- [`scheme cyclone macros`](api/scheme/cyclone/macros.md)
|
||||
- [`scheme cyclone pretty-print`](api/scheme/cyclone/pretty-print.md)
|
||||
- [`scheme cyclone primitives`](api/scheme/cyclone/primitives.md)
|
||||
- [`scheme cyclone test`](api/scheme/cyclone/test.md)
|
||||
- [`scheme cyclone transforms`](api/scheme/cyclone/transforms.md)
|
||||
- [`scheme cyclone util`](api/scheme/cyclone/util.md)
|
||||
|
||||
# Index
|
||||
|
||||
This section is an alphabetic listing of all the functions, objects, and macros provided by the previous libraries.
|
||||
|
||||
- - -
|
||||
[`*Cyc-version-banner*`](api/scheme/cyclone/common.md#Cyc-version-banner)
|
||||
[`*`](api/primitives.md#)
|
||||
[`*af-inet*`](api/srfi/106.md#af-inet)
|
||||
[`*af-inet6*`](api/srfi/106.md#af-inet6)
|
||||
[`*af-unspec*`](api/srfi/106.md#af-unspec)
|
||||
[`*ai-addrconfig*`](api/srfi/106.md#ai-addrconfig)
|
||||
[`*ai-all*`](api/srfi/106.md#ai-all)
|
||||
[`*ai-canonname*`](api/srfi/106.md#ai-canonname)
|
||||
[`*ai-numerichost*`](api/srfi/106.md#ai-numerichost)
|
||||
[`*ai-v4mapped*`](api/srfi/106.md#ai-v4mapped)
|
||||
[`*c-file-header-comment*`](api/scheme/cyclone/common.md#c-file-header-comment)
|
||||
[`*defined-macros* `](api/scheme/cyclone/transforms.md#*defined-macros)
|
||||
[`*do-code-gen* `](api/scheme/cyclone/transforms.md#*do-code-gen)
|
||||
[`*ipproto-ip*`](api/srfi/106.md#ipproto-ip)
|
||||
[`*ipproto-tcp*`](api/srfi/106.md#ipproto-tcp)
|
||||
[`*ipproto-udp*`](api/srfi/106.md#ipproto-udp)
|
||||
[`*msg-oob*`](api/srfi/106.md#msg-oob)
|
||||
[`*msg-peek*`](api/srfi/106.md#msg-peek)
|
||||
[`*msg-waitall*`](api/srfi/106.md#msg-waitall)
|
||||
[`*primitives* `](api/scheme/cyclone/transforms.md#*primitives)
|
||||
[`*primitives*`](api/scheme/cyclone/primitives.md#primitives)
|
||||
[`*primitives-num-args*`](api/scheme/cyclone/primitives.md#primitives-num-args)
|
||||
[`*shut-rd*`](api/srfi/106.md#shut-rd)
|
||||
[`*shut-rdwr*`](api/srfi/106.md#shut-rdwr)
|
||||
[`*shut-wr*`](api/srfi/106.md#shut-wr)
|
||||
[`*sock-dgram*`](api/srfi/106.md#sock-dgram)
|
||||
[`*sock-stream*`](api/srfi/106.md#sock-stream)
|
||||
[`*trace-level* `](api/scheme/cyclone/transforms.md#*trace-level)
|
||||
[`*version*`](api/scheme/cyclone/common.md#version)
|
||||
[`*version-banner*`](api/scheme/cyclone/common.md#version-banner)
|
||||
[`*version-name*`](api/scheme/cyclone/common.md#version-name)
|
||||
[`*version-number*`](api/scheme/cyclone/common.md#version-number)
|
||||
|
||||
- - -
|
||||
[`+`](api/primitives.md#-1)
|
||||
|
||||
- - -
|
||||
[`->heap`](api/srfi/18.md#-heap)
|
||||
[`-`](api/primitives.md#-)
|
||||
|
||||
- - -
|
||||
[`/`](api/primitives.md#-2)
|
||||
|
||||
- - -
|
||||
[`<=`](api/primitives.md#-4)
|
||||
[`<`](api/primitives.md#-3)
|
||||
|
||||
- - -
|
||||
[`=`](api/primitives.md#-5)
|
||||
|
||||
- - -
|
||||
[`>=`](api/primitives.md#-7)
|
||||
[`>`](api/primitives.md#-6)
|
||||
|
||||
- - -
|
||||
[`Cyc-er-compare? `](api/scheme/cyclone/util.md#Cyc-er-compare)
|
||||
[`Cyc-er-rename `](api/scheme/cyclone/util.md#Cyc-er-rename)
|
||||
[`Cyc-minor-gc`](api/srfi/18.md#Cyc-minor-gc)
|
||||
|
||||
- - -
|
||||
[`abs`](api/scheme/base.md#abs)
|
||||
[`acos`](api/scheme/inexact.md#acos)
|
||||
[`adb:clear!`](api/scheme/cyclone/cps-optimizations.md#adbclear)
|
||||
[`adb:function?`](api/scheme/cyclone/cps-optimizations.md#adbfunction)
|
||||
[`adb:get-db`](api/scheme/cyclone/cps-optimizations.md#adbget-db)
|
||||
[`adb:get/default`](api/scheme/cyclone/cps-optimizations.md#adbgetdefault)
|
||||
[`adb:get`](api/scheme/cyclone/cps-optimizations.md#adbget)
|
||||
[`adb:make-fnc`](api/scheme/cyclone/cps-optimizations.md#adbmake-fnc)
|
||||
[`adb:make-var`](api/scheme/cyclone/cps-optimizations.md#adbmake-var)
|
||||
[`adb:set!`](api/scheme/cyclone/cps-optimizations.md#adbset)
|
||||
[`adb:variable?`](api/scheme/cyclone/cps-optimizations.md#adbvariable)
|
||||
[`adbf:set-simple!`](api/scheme/cyclone/cps-optimizations.md#adbfset-simple)
|
||||
[`adbf:set-unused-params!`](api/scheme/cyclone/cps-optimizations.md#adbfset-unused-params)
|
||||
[`adbf:simple`](api/scheme/cyclone/cps-optimizations.md#adbfsimple)
|
||||
[`adbf:unused-params`](api/scheme/cyclone/cps-optimizations.md#adbfunused-params)
|
||||
[`adbv:assigned-value`](api/scheme/cyclone/cps-optimizations.md#adbvassigned-value)
|
||||
[`adbv:const-value`](api/scheme/cyclone/cps-optimizations.md#adbvconst-value)
|
||||
[`adbv:const?`](api/scheme/cyclone/cps-optimizations.md#adbvconst)
|
||||
[`adbv:defined-by`](api/scheme/cyclone/cps-optimizations.md#adbvdefined-by)
|
||||
[`adbv:global?`](api/scheme/cyclone/cps-optimizations.md#adbvglobal)
|
||||
[`adbv:reassigned?`](api/scheme/cyclone/cps-optimizations.md#adbvreassigned)
|
||||
[`adbv:ref-by`](api/scheme/cyclone/cps-optimizations.md#adbvref-by)
|
||||
[`adbv:set-assigned-value!`](api/scheme/cyclone/cps-optimizations.md#adbvset-assigned-value)
|
||||
[`adbv:set-const!`](api/scheme/cyclone/cps-optimizations.md#adbvset-const)
|
||||
[`adbv:set-const-value!`](api/scheme/cyclone/cps-optimizations.md#adbvset-const-value)
|
||||
[`adbv:set-defined-by!`](api/scheme/cyclone/cps-optimizations.md#adbvset-defined-by)
|
||||
[`adbv:set-global!`](api/scheme/cyclone/cps-optimizations.md#adbvset-global)
|
||||
[`adbv:set-reassigned!`](api/scheme/cyclone/cps-optimizations.md#adbvset-reassigned)
|
||||
[`adbv:set-ref-by!`](api/scheme/cyclone/cps-optimizations.md#adbvset-ref-by)
|
||||
[`address-family`](api/srfi/106.md#address-family)
|
||||
[`address-info`](api/srfi/106.md#address-info)
|
||||
[`alist->hash-table`](api/srfi/69.md#alist-hash-table)
|
||||
[`alist-cons`](api/srfi/1.md#alist-cons)
|
||||
[`alist-copy`](api/srfi/1.md#alist-copy)
|
||||
[`alist-delete!`](api/srfi/1.md#alist-delete-1)
|
||||
[`alist-delete`](api/srfi/1.md#alist-delete)
|
||||
[`alpha-convert `](api/scheme/cyclone/transforms.md#alpha-convert)
|
||||
[`analyze-cps`](api/scheme/cyclone/cps-optimizations.md#analyze-cps)
|
||||
[`analyze-mutable-variables `](api/scheme/cyclone/transforms.md#analyze-mutable-variables)
|
||||
[`and-let*`](api/srfi/2.md#and-let)
|
||||
[`and`](api/scheme/base.md#and)
|
||||
[`angle`](api/scheme/complex.md#angle)
|
||||
[`any`](api/scheme/base.md#any)
|
||||
[`any`](api/srfi/1.md#any)
|
||||
[`app->args `](api/scheme/cyclone/transforms.md#app-args)
|
||||
[`app->fun `](api/scheme/cyclone/transforms.md#app-fun)
|
||||
[`app? `](api/scheme/cyclone/util.md#app)
|
||||
[`append!`](api/srfi/1.md#append)
|
||||
[`append-map!`](api/srfi/1.md#append-map-1)
|
||||
[`append-map`](api/srfi/1.md#append-map)
|
||||
[`append-reverse!`](api/srfi/1.md#append-reverse-1)
|
||||
[`append-reverse`](api/srfi/1.md#append-reverse)
|
||||
[`append`](api/scheme/base.md#append)
|
||||
[`apply `](api/primitives.md#apply)
|
||||
[`asin`](api/scheme/inexact.md#asin)
|
||||
[`assoc`](api/scheme/base.md#assoc)
|
||||
[`assq-remove-key `](api/scheme/cyclone/transforms.md#assq-remove-key)
|
||||
[`assq-remove-keys `](api/scheme/cyclone/transforms.md#assq-remove-keys)
|
||||
[`assq`](api/scheme/base.md#assq)
|
||||
[`assv`](api/scheme/base.md#assv)
|
||||
[`ast:%make-lambda`](api/scheme/cyclone/ast.md#astmake-lambda-1)
|
||||
[`ast:lambda-args`](api/scheme/cyclone/ast.md#astlambda-args)
|
||||
[`ast:lambda-body`](api/scheme/cyclone/ast.md#astlambda-body)
|
||||
[`ast:lambda-formals->list `](api/scheme/cyclone/transforms.md#astlambda-formals-list)
|
||||
[`ast:lambda-formals-type `](api/scheme/cyclone/transforms.md#astlambda-formals-type)
|
||||
[`ast:lambda-id`](api/scheme/cyclone/ast.md#astlambda-id)
|
||||
[`ast:lambda?`](api/scheme/cyclone/ast.md#astlambda)
|
||||
[`ast:make-lambda`](api/scheme/cyclone/ast.md#astmake-lambda)
|
||||
[`ast:set-lambda-args!`](api/scheme/cyclone/ast.md#astset-lambda-args)
|
||||
[`ast:set-lambda-body!`](api/scheme/cyclone/ast.md#astset-lambda-body)
|
||||
[`atan`](api/scheme/inexact.md#atan)
|
||||
[`azip `](api/scheme/cyclone/transforms.md#azip)
|
||||
|
||||
- - -
|
||||
[`basename `](api/scheme/cyclone/transforms.md#basename)
|
||||
[`begin->exps `](api/scheme/cyclone/transforms.md#begin-exps)
|
||||
[`begin? `](api/scheme/cyclone/util.md#begin)
|
||||
[`begin`](api/scheme/base.md#begin)
|
||||
[`boolean=?`](api/scheme/base.md#boolean)
|
||||
[`boolean? `](api/primitives.md#boolean)
|
||||
[`box?`](api/srfi/111.md#box-1)
|
||||
[`box`](api/srfi/111.md#box)
|
||||
[`break!`](api/srfi/1.md#break-1)
|
||||
[`break`](api/srfi/1.md#break)
|
||||
[`built-in-syms `](api/scheme/cyclone/transforms.md#built-in-syms)
|
||||
[`bytevector `](api/primitives.md#bytevector)
|
||||
[`bytevector-append `](api/primitives.md#bytevector-append)
|
||||
[`bytevector-copy!`](api/scheme/base.md#bytevector-copy-1)
|
||||
[`bytevector-copy`](api/scheme/base.md#bytevector-copy)
|
||||
[`bytevector-length `](api/primitives.md#bytevector-length)
|
||||
[`bytevector-u8-ref `](api/primitives.md#bytevector-u8-ref)
|
||||
[`bytevector-u8-set! `](api/primitives.md#bytevector-u8-set)
|
||||
[`bytevector? `](api/primitives.md#bytevector)
|
||||
|
||||
- - -
|
||||
[`caaaar`](api/scheme/cxr.md#caaaar)
|
||||
[`caaadr`](api/scheme/cxr.md#caaadr)
|
||||
[`caaar`](api/scheme/cxr.md#caaar)
|
||||
[`caadar`](api/scheme/cxr.md#caadar)
|
||||
[`caaddr`](api/scheme/cxr.md#caaddr)
|
||||
[`caadr`](api/scheme/cxr.md#caadr)
|
||||
[`caar `](api/primitives.md#caar)
|
||||
[`cadaar`](api/scheme/cxr.md#cadaar)
|
||||
[`cadadr`](api/scheme/cxr.md#cadadr)
|
||||
[`cadar`](api/scheme/cxr.md#cadar)
|
||||
[`caddar`](api/scheme/cxr.md#caddar)
|
||||
[`cadddr`](api/scheme/cxr.md#cadddr)
|
||||
[`caddr`](api/scheme/cxr.md#caddr)
|
||||
[`cadr `](api/primitives.md#cadr)
|
||||
[`call-with-current-continuation`](api/scheme/base.md#call-with-current-continuation)
|
||||
[`call-with-input-file`](api/scheme/file.md#call-with-input-file)
|
||||
[`call-with-output-file`](api/scheme/file.md#call-with-output-file)
|
||||
[`call-with-port`](api/scheme/base.md#call-with-port)
|
||||
[`call-with-socket`](api/srfi/106.md#call-with-socket)
|
||||
[`call-with-values`](api/scheme/base.md#call-with-values)
|
||||
[`call/cc`](api/scheme/base.md#callcc)
|
||||
[`car `](api/primitives.md#car)
|
||||
[`car+cdr`](api/srfi/1.md#carcdr)
|
||||
[`case-lambda`](api/scheme/case-lambda.md#case-lambda)
|
||||
[`case`](api/scheme/base.md#case)
|
||||
[`cdaaar`](api/scheme/cxr.md#cdaaar)
|
||||
[`cdaadr`](api/scheme/cxr.md#cdaadr)
|
||||
[`cdaar`](api/scheme/cxr.md#cdaar)
|
||||
[`cdadar`](api/scheme/cxr.md#cdadar)
|
||||
[`cdaddr`](api/scheme/cxr.md#cdaddr)
|
||||
[`cdadr`](api/scheme/cxr.md#cdadr)
|
||||
[`cdar `](api/primitives.md#cdar)
|
||||
[`cddaar`](api/scheme/cxr.md#cddaar)
|
||||
[`cddadr`](api/scheme/cxr.md#cddadr)
|
||||
[`cddar`](api/scheme/cxr.md#cddar)
|
||||
[`cdddar`](api/scheme/cxr.md#cdddar)
|
||||
[`cddddr`](api/scheme/cxr.md#cddddr)
|
||||
[`cdddr`](api/scheme/cxr.md#cdddr)
|
||||
[`cddr `](api/primitives.md#cddr)
|
||||
[`cdr `](api/primitives.md#cdr)
|
||||
[`ceiling`](api/scheme/base.md#ceiling)
|
||||
[`cell `](api/primitives.md#cell)
|
||||
[`cell->value `](api/scheme/cyclone/transforms.md#cell-value)
|
||||
[`cell-get `](api/primitives.md#cell-get)
|
||||
[`cell-get->cell `](api/scheme/cyclone/transforms.md#cell-get-cell)
|
||||
[`cell-get? `](api/scheme/cyclone/transforms.md#cell-get)
|
||||
[`cell? `](api/scheme/cyclone/transforms.md#cell)
|
||||
[`char->integer `](api/primitives.md#char-integer)
|
||||
[`char-alphabetic?`](api/scheme/char.md#char-alphabetic)
|
||||
[`char-ci<=?`](api/scheme/char.md#char-ci)
|
||||
[`char-ci<?`](api/scheme/char.md#char-ci-1)
|
||||
[`char-ci=?`](api/scheme/char.md#char-ci-2)
|
||||
[`char-ci>=?`](api/scheme/char.md#char-ci-3)
|
||||
[`char-ci>?`](api/scheme/char.md#char-ci-4)
|
||||
[`char-downcase`](api/scheme/char.md#char-downcase)
|
||||
[`char-foldcase`](api/scheme/char.md#char-foldcase)
|
||||
[`char-lower-case?`](api/scheme/char.md#char-lower-case)
|
||||
[`char-numeric?`](api/scheme/char.md#char-numeric)
|
||||
[`char-upcase`](api/scheme/char.md#char-upcase)
|
||||
[`char-upper-case?`](api/scheme/char.md#char-upper-case)
|
||||
[`char-whitespace?`](api/scheme/char.md#char-whitespace)
|
||||
[`char<=?`](api/scheme/base.md#char)
|
||||
[`char<?`](api/scheme/base.md#char-1)
|
||||
[`char=?`](api/scheme/base.md#char-2)
|
||||
[`char>=?`](api/scheme/base.md#char-3)
|
||||
[`char>?`](api/scheme/base.md#char-4)
|
||||
[`char? `](api/primitives.md#char)
|
||||
[`circular-list?`](api/srfi/1.md#circular-list)
|
||||
[`circular-list`](api/srfi/1.md#circular-list-1)
|
||||
[`clear-mutables `](api/scheme/cyclone/transforms.md#clear-mutables)
|
||||
[`close-input-port `](api/primitives.md#close-input-port)
|
||||
[`close-output-port `](api/primitives.md#close-output-port)
|
||||
[`close-port `](api/primitives.md#close-port)
|
||||
[`closure->env `](api/scheme/cyclone/transforms.md#closure-env)
|
||||
[`closure->fv `](api/scheme/cyclone/transforms.md#closure-fv)
|
||||
[`closure->lam `](api/scheme/cyclone/transforms.md#closure-lam)
|
||||
[`closure-convert `](api/scheme/cyclone/transforms.md#closure-convert)
|
||||
[`closure? `](api/scheme/cyclone/transforms.md#closure)
|
||||
[`command-line-arguments`](api/primitives.md#command-line-arguments)
|
||||
[`command-line`](api/scheme/process-context.md#command-line)
|
||||
[`complex?`](api/scheme/base.md#complex)
|
||||
[`concatenate!`](api/srfi/1.md#concatenate-1)
|
||||
[`concatenate`](api/srfi/1.md#concatenate)
|
||||
[`cond-expand`](api/scheme/base.md#cond-expand)
|
||||
[`cond`](api/scheme/base.md#cond)
|
||||
[`condition-variable-broadcast!`](api/srfi/18.md#condition-variable-broadcast)
|
||||
[`condition-variable-signal!`](api/srfi/18.md#condition-variable-signal)
|
||||
[`condition-variable-wait!`](api/srfi/18.md#condition-variable-wait)
|
||||
[`condition-variable?`](api/srfi/18.md#condition-variable)
|
||||
[`cons `](api/primitives.md#cons)
|
||||
[`cons*`](api/srfi/1.md#cons)
|
||||
[`const? `](api/scheme/cyclone/util.md#const)
|
||||
[`cos`](api/scheme/inexact.md#cos)
|
||||
[`count`](api/srfi/1.md#count)
|
||||
[`cps-convert `](api/scheme/cyclone/transforms.md#cps-convert)
|
||||
[`create-environment`](api/scheme/eval.md#create-environment)
|
||||
[`current-error-port`](api/scheme/base.md#current-error-port)
|
||||
[`current-input-port`](api/scheme/base.md#current-input-port)
|
||||
[`current-jiffy`](api/scheme/time.md#current-jiffy)
|
||||
[`current-output-port`](api/scheme/base.md#current-output-port)
|
||||
[`current-second`](api/scheme/time.md#current-second)
|
||||
[`current-test-applier`](api/scheme/cyclone/test.md#current-test-applier)
|
||||
[`current-test-comparator`](api/scheme/cyclone/test.md#current-test-comparator)
|
||||
[`current-test-epsilon`](api/scheme/cyclone/test.md#current-test-epsilon)
|
||||
[`current-test-group-reporter`](api/scheme/cyclone/test.md#current-test-group-reporter)
|
||||
[`current-test-group`](api/scheme/cyclone/test.md#current-test-group)
|
||||
[`current-test-handler`](api/scheme/cyclone/test.md#current-test-handler)
|
||||
[`current-test-skipper`](api/scheme/cyclone/test.md#current-test-skipper)
|
||||
[`current-test-verbosity`](api/scheme/cyclone/test.md#current-test-verbosity)
|
||||
[`cyc:error `](api/scheme/cyclone/transforms.md#cycerror)
|
||||
|
||||
- - -
|
||||
[`default-random-source`](api/srfi/27.md#default-random-source)
|
||||
[`define->exp `](api/scheme/cyclone/util.md#define-exp)
|
||||
[`define->lambda `](api/scheme/cyclone/transforms.md#define-lambda)
|
||||
[`define->var `](api/scheme/cyclone/util.md#define-var)
|
||||
[`define-c? `](api/scheme/cyclone/util.md#define-c)
|
||||
[`define-lambda? `](api/scheme/cyclone/transforms.md#define-lambda-1)
|
||||
[`define-record-type`](api/scheme/base.md#define-record-type)
|
||||
[`define-syntax?`](api/scheme/cyclone/macros.md#define-syntax)
|
||||
[`define? `](api/scheme/cyclone/util.md#define)
|
||||
[`delay-force`](api/scheme/lazy.md#delay-force)
|
||||
[`delay`](api/scheme/lazy.md#delay)
|
||||
[`delete `](api/scheme/cyclone/util.md#delete)
|
||||
[`delete!`](api/srfi/1.md#delete-1)
|
||||
[`delete-duplicates `](api/scheme/cyclone/util.md#delete-duplicates)
|
||||
[`delete-duplicates!`](api/srfi/1.md#delete-duplicates-1)
|
||||
[`delete-duplicates`](api/srfi/1.md#delete-duplicates)
|
||||
[`delete-file `](api/primitives.md#delete-file)
|
||||
[`delete`](api/srfi/1.md#delete)
|
||||
[`denominator`](api/scheme/base.md#denominator)
|
||||
[`difference `](api/scheme/cyclone/transforms.md#difference)
|
||||
[`digit-value`](api/scheme/char.md#digit-value)
|
||||
[`display`](api/scheme/write.md#display)
|
||||
[`do`](api/scheme/base.md#do)
|
||||
[`dotted-list?`](api/srfi/1.md#dotted-list)
|
||||
[`drop-right!`](api/srfi/1.md#drop-right-1)
|
||||
[`drop-right`](api/srfi/1.md#drop-right)
|
||||
[`drop-while`](api/srfi/1.md#drop-while)
|
||||
[`drop`](api/srfi/1.md#drop)
|
||||
[`dynamic-wind`](api/scheme/base.md#dynamic-wind)
|
||||
|
||||
- - -
|
||||
[`eighth`](api/srfi/1.md#eighth)
|
||||
[`emergency-exit`](api/scheme/process-context.md#emergency-exit)
|
||||
[`emit*`](api/scheme/cyclone/cgen.md#emit-1)
|
||||
[`emit-newline`](api/scheme/cyclone/cgen.md#emit-newline)
|
||||
[`emit`](api/scheme/cyclone/cgen.md#emit)
|
||||
[`emits*`](api/scheme/cyclone/cgen.md#emits-1)
|
||||
[`emits`](api/scheme/cyclone/cgen.md#emits)
|
||||
[`env-get->env `](api/scheme/cyclone/transforms.md#env-get-env)
|
||||
[`env-get->field `](api/scheme/cyclone/transforms.md#env-get-field)
|
||||
[`env-get->id `](api/scheme/cyclone/transforms.md#env-get-id)
|
||||
[`env-get? `](api/scheme/cyclone/transforms.md#env-get)
|
||||
[`env-make->fields `](api/scheme/cyclone/transforms.md#env-make-fields)
|
||||
[`env-make->id `](api/scheme/cyclone/transforms.md#env-make-id)
|
||||
[`env-make->values `](api/scheme/cyclone/transforms.md#env-make-values)
|
||||
[`env-make? `](api/scheme/cyclone/transforms.md#env-make)
|
||||
[`env:_lookup-variable-value `](api/scheme/cyclone/util.md#envlookup-variable-value)
|
||||
[`env:add-binding-to-frame! `](api/scheme/cyclone/util.md#envadd-binding-to-frame)
|
||||
[`env:all-values `](api/scheme/cyclone/util.md#envall-values)
|
||||
[`env:all-variables `](api/scheme/cyclone/util.md#envall-variables)
|
||||
[`env:define-variable! `](api/scheme/cyclone/util.md#envdefine-variable)
|
||||
[`env:enclosing-environment `](api/scheme/cyclone/util.md#envenclosing-environment)
|
||||
[`env:extend-environment `](api/scheme/cyclone/util.md#envextend-environment)
|
||||
[`env:first-frame `](api/scheme/cyclone/util.md#envfirst-frame)
|
||||
[`env:frame-values `](api/scheme/cyclone/util.md#envframe-values)
|
||||
[`env:frame-variables `](api/scheme/cyclone/util.md#envframe-variables)
|
||||
[`env:lookup `](api/scheme/cyclone/util.md#envlookup)
|
||||
[`env:lookup-variable-value `](api/scheme/cyclone/util.md#envlookup-variable-value)
|
||||
[`env:make-frame `](api/scheme/cyclone/util.md#envmake-frame)
|
||||
[`env:set-variable-value! `](api/scheme/cyclone/util.md#envset-variable-value)
|
||||
[`env:the-empty-environment `](api/scheme/cyclone/util.md#envthe-empty-environment)
|
||||
[`eof-object? `](api/primitives.md#eof-object)
|
||||
[`eof-object`](api/scheme/base.md#eof-object)
|
||||
[`eq? `](api/primitives.md#eq)
|
||||
[`equal? `](api/primitives.md#equal)
|
||||
[`eqv? `](api/primitives.md#eqv)
|
||||
[`error `](api/primitives.md#error)
|
||||
[`error`](api/scheme/base.md#error)
|
||||
[`eval`](api/scheme/eval.md#eval)
|
||||
[`even?`](api/scheme/base.md#even)
|
||||
[`every`](api/scheme/base.md#every)
|
||||
[`every`](api/srfi/1.md#every)
|
||||
[`exact-integer?`](api/scheme/base.md#exact-integer)
|
||||
[`exact?`](api/scheme/base.md#exact)
|
||||
[`exact`](api/scheme/base.md#exact)
|
||||
[`exit `](api/primitives.md#exit)
|
||||
[`exp`](api/scheme/inexact.md#exp)
|
||||
[`expand `](api/scheme/cyclone/transforms.md#expand)
|
||||
[`expand-lambda-body `](api/scheme/cyclone/transforms.md#expand-lambda-body)
|
||||
[`expt`](api/scheme/base.md#expt)
|
||||
|
||||
- - -
|
||||
[`features`](api/scheme/base.md#features)
|
||||
[`fifth`](api/srfi/1.md#fifth)
|
||||
[`file-exists? `](api/primitives.md#file-exists)
|
||||
[`filter `](api/scheme/cyclone/util.md#filter)
|
||||
[`filter!`](api/srfi/1.md#filter-1)
|
||||
[`filter-map`](api/srfi/1.md#filter-map)
|
||||
[`filter-unused-variables `](api/scheme/cyclone/transforms.md#filter-unused-variables)
|
||||
[`filter`](api/srfi/1.md#filter)
|
||||
[`find-tail`](api/srfi/1.md#find-tail)
|
||||
[`find`](api/srfi/1.md#find)
|
||||
[`finite?`](api/scheme/inexact.md#finite)
|
||||
[`first`](api/srfi/1.md#first)
|
||||
[`flatten `](api/scheme/cyclone/util.md#flatten)
|
||||
[`floor-quotient`](api/scheme/base.md#floor-quotient)
|
||||
[`floor-remainder`](api/scheme/base.md#floor-remainder )
|
||||
[`floor-remainder`](api/scheme/base.md#floor-remainder)
|
||||
[`floor/`](api/scheme/base.md#floor-1)
|
||||
[`floor`](api/scheme/base.md#floor)
|
||||
[`flush-output-port`](api/scheme/base.md#flush-output-port)
|
||||
[`fold-right`](api/srfi/1.md#fold-right)
|
||||
[`fold`](api/srfi/1.md#fold)
|
||||
[`foldl`](api/scheme/base.md#foldl)
|
||||
[`foldr`](api/scheme/base.md#foldr)
|
||||
[`for-each`](api/scheme/base.md#for-each)
|
||||
[`force`](api/scheme/lazy.md#force)
|
||||
[`formals->list `](api/scheme/cyclone/util.md#formals-list)
|
||||
[`fourth`](api/srfi/1.md#fourth)
|
||||
[`free-vars `](api/scheme/cyclone/transforms.md#free-vars)
|
||||
|
||||
- - -
|
||||
[`gcd`](api/scheme/base.md#gcd)
|
||||
[`gensym `](api/scheme/cyclone/util.md#gensym)
|
||||
[`get-environment-variable`](api/scheme/process-context.md#get-environment-variable)
|
||||
[`get-environment-variables`](api/scheme/process-context.md#get-environment-variables)
|
||||
[`get-macros `](api/scheme/cyclone/transforms.md#get-macros)
|
||||
[`get-output-bytevector`](api/scheme/base.md#get-output-bytevector)
|
||||
[`get-output-string`](api/scheme/base.md#get-output-string)
|
||||
[`global-vars `](api/scheme/cyclone/transforms.md#global-vars)
|
||||
[`guard`](api/scheme/base.md#guard)
|
||||
|
||||
- - -
|
||||
[`has-global? `](api/scheme/cyclone/transforms.md#has-global)
|
||||
[`hash-by-identity`](api/srfi/69.md#hash-by-identity)
|
||||
[`hash-table->alist`](api/srfi/69.md#hash-table-alist)
|
||||
[`hash-table-copy`](api/srfi/69.md#hash-table-copy)
|
||||
[`hash-table-delete!`](api/srfi/69.md#hash-table-delete)
|
||||
[`hash-table-equivalence-function`](api/srfi/69.md#hash-table-equivalence-function)
|
||||
[`hash-table-exists?`](api/srfi/69.md#hash-table-exists)
|
||||
[`hash-table-fold`](api/srfi/69.md#hash-table-fold)
|
||||
[`hash-table-hash-function`](api/srfi/69.md#hash-table-hash-function)
|
||||
[`hash-table-keys`](api/srfi/69.md#hash-table-keys)
|
||||
[`hash-table-merge!`](api/srfi/69.md#hash-table-merge)
|
||||
[`hash-table-ref/default`](api/srfi/69.md#hash-table-refdefault)
|
||||
[`hash-table-ref`](api/srfi/69.md#hash-table-ref)
|
||||
[`hash-table-set!`](api/srfi/69.md#hash-table-set)
|
||||
[`hash-table-size`](api/srfi/69.md#hash-table-size)
|
||||
[`hash-table-update!/default`](api/srfi/69.md#hash-table-updatedefault)
|
||||
[`hash-table-update!`](api/srfi/69.md#hash-table-update)
|
||||
[`hash-table-values`](api/srfi/69.md#hash-table-values)
|
||||
[`hash-table-walk`](api/srfi/69.md#hash-table-walk)
|
||||
[`hash-table?`](api/srfi/69.md#hash-table)
|
||||
[`hash`](api/srfi/69.md#hash)
|
||||
|
||||
- - -
|
||||
[`identifier->symbol `](api/scheme/cyclone/util.md#identifier-symbol)
|
||||
[`identifier=? `](api/scheme/cyclone/util.md#identifier)
|
||||
[`identifier? `](api/scheme/cyclone/util.md#identifier-1)
|
||||
[`if->condition `](api/scheme/cyclone/util.md#if-condition)
|
||||
[`if->else `](api/scheme/cyclone/util.md#if-else)
|
||||
[`if->then `](api/scheme/cyclone/util.md#if-then)
|
||||
[`if-else? `](api/scheme/cyclone/util.md#if-else)
|
||||
[`if? `](api/scheme/cyclone/util.md#if)
|
||||
[`imag-part`](api/scheme/complex.md#imag-part)
|
||||
[`inexact?`](api/scheme/base.md#inexact-1)
|
||||
[`inexact`](api/scheme/base.md#inexact)
|
||||
[`infinite?`](api/scheme/inexact.md#infinite)
|
||||
[`input-port-open?`](api/scheme/base.md#input-port-open)
|
||||
[`input-port?`](api/scheme/base.md#input-port)
|
||||
[`insert `](api/scheme/cyclone/transforms.md#insert)
|
||||
[`integer->char `](api/primitives.md#integer-char)
|
||||
[`integer? `](api/primitives.md#integer)
|
||||
[`iota`](api/srfi/1.md#iota)
|
||||
[`ip-protocol`](api/srfi/106.md#ip-protocol)
|
||||
[`is-mutable? `](api/scheme/cyclone/transforms.md#is-mutable)
|
||||
[`isolate-globals `](api/scheme/cyclone/transforms.md#isolate-globals)
|
||||
|
||||
- - -
|
||||
[`jiffies-per-second`](api/scheme/time.md#jiffies-per-second)
|
||||
|
||||
- - -
|
||||
[`lambda->exp `](api/scheme/cyclone/util.md#lambda-exp)
|
||||
[`lambda->formals `](api/scheme/cyclone/util.md#lambda-formals)
|
||||
[`lambda-formals->list `](api/scheme/cyclone/util.md#lambda-formals-list)
|
||||
[`lambda-formals-type `](api/scheme/cyclone/util.md#lambda-formals-type)
|
||||
[`lambda-num-args `](api/scheme/cyclone/transforms.md#lambda-num-args)
|
||||
[`lambda-varargs-var `](api/scheme/cyclone/util.md#lambda-varargs-var)
|
||||
[`lambda-varargs? `](api/scheme/cyclone/util.md#lambda-varargs)
|
||||
[`lambda? `](api/scheme/cyclone/util.md#lambda)
|
||||
[`last-pair`](api/srfi/1.md#last-pair)
|
||||
[`last`](api/srfi/1.md#last)
|
||||
[`lcm`](api/scheme/base.md#lcm)
|
||||
[`length `](api/primitives.md#length)
|
||||
[`length+`](api/srfi/1.md#length)
|
||||
[`length/obj `](api/scheme/cyclone/util.md#lengthobj)
|
||||
[`let*-values`](api/scheme/base.md#let-values)
|
||||
[`let*`](api/scheme/base.md#let-1)
|
||||
[`let->args `](api/scheme/cyclone/transforms.md#let-args)
|
||||
[`let->bindings `](api/scheme/cyclone/transforms.md#let-bindings)
|
||||
[`let->bound-vars `](api/scheme/cyclone/transforms.md#let-bound-vars)
|
||||
[`let->exp `](api/scheme/cyclone/transforms.md#let-exp)
|
||||
[`let-values`](api/scheme/base.md#let-values-1)
|
||||
[`let=>lambda `](api/scheme/cyclone/transforms.md#letlambda)
|
||||
[`let? `](api/scheme/cyclone/transforms.md#let)
|
||||
[`let`](api/scheme/base.md#let)
|
||||
[`letrec*`](api/scheme/base.md#letrec-1)
|
||||
[`letrec->args `](api/scheme/cyclone/transforms.md#letrec-args)
|
||||
[`letrec->bindings `](api/scheme/cyclone/transforms.md#letrec-bindings)
|
||||
[`letrec->bound-vars `](api/scheme/cyclone/transforms.md#letrec-bound-vars)
|
||||
[`letrec->exp `](api/scheme/cyclone/transforms.md#letrec-exp)
|
||||
[`letrec? `](api/scheme/cyclone/transforms.md#letrec)
|
||||
[`letrec`](api/scheme/base.md#letrec)
|
||||
[`lib:body`](api/scheme/cyclone/libraries.md#libbody)
|
||||
[`lib:exports`](api/scheme/cyclone/libraries.md#libexports)
|
||||
[`lib:get-all-import-deps`](api/scheme/cyclone/libraries.md#libget-all-import-deps)
|
||||
[`lib:get-all`](api/scheme/cyclone/libraries.md#libget-all)
|
||||
[`lib:get-dep-list`](api/scheme/cyclone/libraries.md#libget-dep-list)
|
||||
[`lib:idb:id->import`](api/scheme/cyclone/libraries.md#libidb:id-import)
|
||||
[`lib:idb:ids`](api/scheme/cyclone/libraries.md#libidb:ids)
|
||||
[`lib:import->export-list`](api/scheme/cyclone/libraries.md#libimport-export-list)
|
||||
[`lib:import->filename`](api/scheme/cyclone/libraries.md#libimport-filename)
|
||||
[`lib:import->metalist`](api/scheme/cyclone/libraries.md#libimport-metalist)
|
||||
[`lib:import->path`](api/scheme/cyclone/libraries.md#libimport-path)
|
||||
[`lib:imports->idb`](api/scheme/cyclone/libraries.md#libimports-idb)
|
||||
[`lib:imports`](api/scheme/cyclone/libraries.md#libimports)
|
||||
[`lib:include-c-headers`](api/scheme/cyclone/libraries.md#libinclude-c-headers)
|
||||
[`lib:includes`](api/scheme/cyclone/libraries.md#libincludes)
|
||||
[`lib:list->import-set`](api/scheme/cyclone/libraries.md#liblist-import-set)
|
||||
[`lib:name->string`](api/scheme/cyclone/libraries.md#libname-string)
|
||||
[`lib:name->symbol`](api/scheme/cyclone/libraries.md#libname-symbol)
|
||||
[`lib:name`](api/scheme/cyclone/libraries.md#libname)
|
||||
[`lib:read-imports`](api/scheme/cyclone/libraries.md#libread-imports)
|
||||
[`lib:rename-exports`](api/scheme/cyclone/libraries.md#librename-exports)
|
||||
[`lib:resolve-imports`](api/scheme/cyclone/libraries.md#libresolve-imports)
|
||||
[`lib:resolve-meta`](api/scheme/cyclone/libraries.md#libresolve-meta)
|
||||
[`lib:result`](api/scheme/cyclone/libraries.md#libresult)
|
||||
[`library?`](api/scheme/cyclone/libraries.md#library)
|
||||
[`list->lambda-formals `](api/scheme/cyclone/transforms.md#list-lambda-formals)
|
||||
[`list->pair `](api/scheme/cyclone/transforms.md#list-pair)
|
||||
[`list->string `](api/primitives.md#list-string)
|
||||
[`list->vector `](api/primitives.md#list-vector)
|
||||
[`list-copy`](api/scheme/base.md#list-copy)
|
||||
[`list-copy`](api/srfi/1.md#list-copy)
|
||||
[`list-delete-neighbor-dups!`](api/srfi/132.md#list-delete-neighbor-dups-1)
|
||||
[`list-delete-neighbor-dups`](api/srfi/132.md#list-delete-neighbor-dups)
|
||||
[`list-index `](api/scheme/cyclone/transforms.md#list-index)
|
||||
[`list-index2 `](api/scheme/cyclone/util.md#list-index2)
|
||||
[`list-index`](api/srfi/1.md#list-index)
|
||||
[`list-insert-at! `](api/scheme/cyclone/util.md#list-insert-at)
|
||||
[`list-merge!`](api/srfi/132.md#list-merge-1)
|
||||
[`list-merge`](api/srfi/132.md#list-merge)
|
||||
[`list-prefix? `](api/scheme/cyclone/util.md#list-prefix)
|
||||
[`list-queue-add-back!`](api/srfi/117.md#list-queue-add-back)
|
||||
[`list-queue-add-front!`](api/srfi/117.md#list-queue-add-front)
|
||||
[`list-queue-append!`](api/srfi/117.md#list-queue-append-1)
|
||||
[`list-queue-append!`](api/srfi/117.md#list-queue-append-1)
|
||||
[`list-queue-append`](api/srfi/117.md#list-queue-append)
|
||||
[`list-queue-append`](api/srfi/117.md#list-queue-append)
|
||||
[`list-queue-back`](api/srfi/117.md#list-queue-back)
|
||||
[`list-queue-concatenate`](api/srfi/117.md#list-queue-concatenate)
|
||||
[`list-queue-concatenate`](api/srfi/117.md#list-queue-concatenate)
|
||||
[`list-queue-copy`](api/srfi/117.md#list-queue-copy)
|
||||
[`list-queue-empty?`](api/srfi/117.md#list-queue-empty)
|
||||
[`list-queue-first-last`](api/srfi/117.md#list-queue-first-last)
|
||||
[`list-queue-for-each`](api/srfi/117.md#list-queue-for-each)
|
||||
[`list-queue-front`](api/srfi/117.md#list-queue-front)
|
||||
[`list-queue-list`](api/srfi/117.md#list-queue-list)
|
||||
[`list-queue-map!`](api/srfi/117.md#list-queue-map-1)
|
||||
[`list-queue-map`](api/srfi/117.md#list-queue-map)
|
||||
[`list-queue-remove-all!`](api/srfi/117.md#list-queue-remove-all)
|
||||
[`list-queue-remove-back!`](api/srfi/117.md#list-queue-remove-back)
|
||||
[`list-queue-remove-front!`](api/srfi/117.md#list-queue-remove-front)
|
||||
[`list-queue-set-list!`](api/srfi/117.md#list-queue-set-list)
|
||||
[`list-queue-unfold-right`](api/srfi/117.md#list-queue-unfold-right)
|
||||
[`list-queue-unfold`](api/srfi/117.md#list-queue-unfold)
|
||||
[`list-queue?`](api/srfi/117.md#list-queue-1)
|
||||
[`list-queue`](api/srfi/117.md#list-queue)
|
||||
[`list-ref`](api/scheme/base.md#list-ref)
|
||||
[`list-set!`](api/scheme/base.md#list-set)
|
||||
[`list-sort!`](api/srfi/132.md#list-sort-1)
|
||||
[`list-sort`](api/srfi/132.md#list-sort)
|
||||
[`list-sorted?`](api/srfi/132.md#list-sorted)
|
||||
[`list-stable-sort!`](api/srfi/132.md#list-stable-sort)
|
||||
[`list-stable-sort`](api/srfi/132.md#list-stable-sort)
|
||||
[`list-tabulate`](api/srfi/1.md#list-tabulate)
|
||||
[`list-tail`](api/scheme/base.md#list-tail)
|
||||
[`list=`](api/srfi/1.md#list=)
|
||||
[`list?`](api/scheme/base.md#list-1)
|
||||
[`list`](api/scheme/base.md#list)
|
||||
[`load`](api/scheme/load.md#load)
|
||||
[`log`](api/scheme/inexact.md#log)
|
||||
[`lset-adjoin`](api/srfi/1.md#lset-adjoin)
|
||||
[`lset-diff+intersection`](api/srfi/1.md#lset-diffintersection)
|
||||
[`lset-difference!`](api/srfi/1.md#lset-difference-1)
|
||||
[`lset-difference`](api/srfi/1.md#lset-difference)
|
||||
[`lset-intersection!`](api/srfi/1.md#lset-intersection-1)
|
||||
[`lset-intersection`](api/srfi/1.md#lset-intersection)
|
||||
[`lset-union!`](api/srfi/1.md#lset-union)
|
||||
[`lset-union`](api/srfi/1.md#lset-union)
|
||||
[`lset-xor!`](api/srfi/1.md#lset-xor-1)
|
||||
[`lset-xor`](api/srfi/1.md#lset-xor)
|
||||
[`lset<=`](api/srfi/1.md#lset)
|
||||
[`lset=`](api/srfi/1.md#lset-1)
|
||||
|
||||
- - -
|
||||
[`macro:add!`](api/scheme/cyclone/macros.md#macroadd)
|
||||
[`macro:cleanup`](api/scheme/cyclone/macros.md#macrocleanup)
|
||||
[`macro:expand`](api/scheme/cyclone/macros.md#macroexpand)
|
||||
[`macro:get-defined-macros`](api/scheme/cyclone/macros.md#macroget-defined-macros)
|
||||
[`macro:get-env`](api/scheme/cyclone/macros.md#macroget-env)
|
||||
[`macro:load-env!`](api/scheme/cyclone/macros.md#macroload-env)
|
||||
[`macro:macro?`](api/scheme/cyclone/macros.md#macromacro)
|
||||
[`magnitude`](api/scheme/complex.md#magnitude)
|
||||
[`make-bytevector `](api/primitives.md#make-bytevector)
|
||||
[`make-client-socket`](api/srfi/106.md#make-client-socket)
|
||||
[`make-condition-variable`](api/srfi/18.md#make-condition-variable)
|
||||
[`make-constructor`](api/scheme/base.md#make-constructor)
|
||||
[`make-getter`](api/scheme/base.md#make-getter)
|
||||
[`make-hash-table`](api/srfi/69.md#make-hash-table)
|
||||
[`make-list-queue`](api/srfi/117.md#make-list-queue)
|
||||
[`make-list`](api/scheme/base.md#make-list)
|
||||
[`make-list`](api/srfi/1.md#make-list)
|
||||
[`make-mutex`](api/srfi/18.md#make-mutex)
|
||||
[`make-parameter`](api/scheme/base.md#make-parameter)
|
||||
[`make-polar`](api/scheme/complex.md#make-polar)
|
||||
[`make-promise`](api/scheme/lazy.md#make-promise)
|
||||
[`make-random-source`](api/srfi/27.md#make-random-source)
|
||||
[`make-rectangular`](api/scheme/complex.md#make-rectangular)
|
||||
[`make-server-socket`](api/srfi/106.md#make-server-socket)
|
||||
[`make-setter`](api/scheme/base.md#make-setter)
|
||||
[`make-string`](api/scheme/base.md#make-string)
|
||||
[`make-thread`](api/srfi/18.md#make-thread)
|
||||
[`make-type-predicate`](api/scheme/base.md#make-type-predicate)
|
||||
[`make-vector `](api/primitives.md#make-vector)
|
||||
[`mangle `](api/scheme/cyclone/util.md#mangle)
|
||||
[`mangle-global `](api/scheme/cyclone/util.md#mangle-global)
|
||||
[`map!`](api/srfi/1.md#map)
|
||||
[`map-in-order`](api/srfi/1.md#map-in-order)
|
||||
[`map`](api/scheme/base.md#map)
|
||||
[`mark-mutable `](api/scheme/cyclone/transforms.md#mark-mutable)
|
||||
[`max`](api/scheme/base.md#max)
|
||||
[`member`](api/scheme/base.md#member)
|
||||
[`memq`](api/scheme/base.md#memq)
|
||||
[`memv`](api/scheme/base.md#memv)
|
||||
[`message-type`](api/srfi/106.md#message-type)
|
||||
[`min`](api/scheme/base.md#min)
|
||||
[`modulo`](api/scheme/base.md#modulo)
|
||||
[`mta:code-gen`](api/scheme/cyclone/cgen.md#mtacode-gen)
|
||||
[`mutex-lock!`](api/srfi/18.md#mutex-lock)
|
||||
[`mutex-unlock!`](api/srfi/18.md#mutex-unlock)
|
||||
[`mutex?`](api/srfi/18.md#mutex)
|
||||
|
||||
- - -
|
||||
[`nan?`](api/scheme/inexact.md#nan)
|
||||
[`negative?`](api/scheme/base.md#negative)
|
||||
[`newline`](api/scheme/base.md#newline)
|
||||
[`ninth`](api/srfi/1.md#ninth)
|
||||
[`not-pair?`](api/srfi/1.md#not-pair)
|
||||
[`not`](api/scheme/base.md#not)
|
||||
[`null-list?`](api/srfi/1.md#null-list)
|
||||
[`null? `](api/primitives.md#null)
|
||||
[`number->string `](api/primitives.md#number-string)
|
||||
[`number? `](api/primitives.md#number)
|
||||
[`numerator`](api/scheme/base.md#numerator)
|
||||
|
||||
- - -
|
||||
[`odd?`](api/scheme/base.md#odd)
|
||||
[`one-instance-of-new-mutable-obj?`](api/scheme/cyclone/cps-optimizations.md#one-instance-of-new-mutable-obj)
|
||||
[`open-input-bytevector`](api/scheme/base.md#open-input-bytevector)
|
||||
[`open-input-file `](api/primitives.md#open-input-file)
|
||||
[`open-input-string`](api/scheme/base.md#open-input-string)
|
||||
[`open-output-bytevector`](api/scheme/base.md#open-output-bytevector)
|
||||
[`open-output-file `](api/primitives.md#open-output-file)
|
||||
[`open-output-string`](api/scheme/base.md#open-output-string)
|
||||
[`opt:contract`](api/scheme/cyclone/cps-optimizations.md#optcontract)
|
||||
[`opt:inline-prims`](api/scheme/cyclone/cps-optimizations.md#optinline-prims)
|
||||
[`optimize-cps`](api/scheme/cyclone/cps-optimizations.md#optimize-cps)
|
||||
[`or`](api/scheme/base.md#or)
|
||||
[`output-port-open?`](api/scheme/base.md#output-port-open)
|
||||
[`output-port?`](api/scheme/base.md#output-port)
|
||||
|
||||
- - -
|
||||
[`pack-lambda-arguments `](api/scheme/cyclone/util.md#pack-lambda-arguments)
|
||||
[`pair->list `](api/scheme/cyclone/util.md#pair-list)
|
||||
[`pair-fold-right`](api/srfi/1.md#pair-fold-right)
|
||||
[`pair-fold`](api/srfi/1.md#pair-fold)
|
||||
[`pair-for-each`](api/srfi/1.md#pair-for-each)
|
||||
[`pair? `](api/primitives.md#pair)
|
||||
[`parameterize`](api/scheme/base.md#parameterize)
|
||||
[`partition!`](api/srfi/1.md#partition-1)
|
||||
[`partition`](api/srfi/1.md#partition)
|
||||
[`peek-char `](api/primitives.md#peek-char)
|
||||
[`port? `](api/primitives.md#port)
|
||||
[`pos-in-list `](api/scheme/cyclone/transforms.md#pos-in-list)
|
||||
[`positive?`](api/scheme/base.md#positive)
|
||||
[`precompute-prim-app? `](api/scheme/cyclone/transforms.md#precompute-prim-app)
|
||||
[`pretty-print`](api/scheme/cyclone/pretty-print.md#pretty-print)
|
||||
[`prim->c-func`](api/scheme/cyclone/primitives.md#prim-c-func)
|
||||
[`prim-call?`](api/scheme/cyclone/primitives.md#prim-call)
|
||||
[`prim/c-var-assign`](api/scheme/cyclone/primitives.md#primc-var-assign)
|
||||
[`prim/cvar?`](api/scheme/cyclone/primitives.md#primcvar)
|
||||
[`prim/data-arg?`](api/scheme/cyclone/primitives.md#primdata-arg)
|
||||
[`prim:allocates-object?)`](api/scheme/cyclone/primitives.md#primallocates-object)
|
||||
[`prim:arg-count?`](api/scheme/cyclone/primitives.md#primarg-count)
|
||||
[`prim:check-arg-count`](api/scheme/cyclone/primitives.md#primcheck-arg-count)
|
||||
[`prim:cont/no-args?`](api/scheme/cyclone/primitives.md#primcontno-args)
|
||||
[`prim:cont?`](api/scheme/cyclone/primitives.md#primcont)
|
||||
[`prim:mutates?`](api/scheme/cyclone/primitives.md#primmutates)
|
||||
[`prim?`](api/scheme/cyclone/primitives.md#prim)
|
||||
[`print-exception`](api/scheme/cyclone/test.md#print-exception)
|
||||
[`procedure? `](api/primitives.md#procedure)
|
||||
[`promise?`](api/scheme/lazy.md#promise)
|
||||
[`proper-list?`](api/srfi/1.md#proper-list)
|
||||
|
||||
- - -
|
||||
[`quasiquote`](api/scheme/base.md#quasiquote)
|
||||
[`quote? `](api/scheme/cyclone/util.md#quote)
|
||||
[`quotient`](api/scheme/base.md#quotient)
|
||||
|
||||
- - -
|
||||
[`raise-continuable`](api/scheme/base.md#raise-continuable)
|
||||
[`raise`](api/scheme/base.md#raise)
|
||||
[`random-integer`](api/srfi/27.md#random-integer)
|
||||
[`random-real`](api/srfi/27.md#random-real)
|
||||
[`random-source-make-integers`](api/srfi/27.md#random-source-make-integers)
|
||||
[`random-source-make-reals`](api/srfi/27.md#random-source-make-reals)
|
||||
[`random-source-pseudo-randomize!`](api/srfi/27.md#random-source-pseudo-randomize)
|
||||
[`random-source-randomize!`](api/srfi/27.md#random-source-randomize)
|
||||
[`random-source-state-ref`](api/srfi/27.md#random-source-state-ref)
|
||||
[`random-source-state-set!`](api/srfi/27.md#random-source-state-set)
|
||||
[`random-source?`](api/srfi/27.md#random-source)
|
||||
[`rational?`](api/scheme/base.md#rational)
|
||||
[`read-all`](api/scheme/read.md#read-all)
|
||||
[`read-char `](api/primitives.md#read-char)
|
||||
[`read-line`](api/scheme/base.md#read-line)
|
||||
[`read-string`](api/scheme/base.md#read-string)
|
||||
[`read`](api/scheme/read.md#read)
|
||||
[`real-part`](api/scheme/complex.md#real-part)
|
||||
[`real? `](api/primitives.md#real)
|
||||
[`receive`](api/scheme/base.md#receive)
|
||||
[`record?`](api/scheme/base.md#record)
|
||||
[`reduce `](api/scheme/cyclone/transforms.md#reduce)
|
||||
[`reduce-right`](api/srfi/1.md#reduce-right)
|
||||
[`reduce`](api/srfi/1.md#reduce)
|
||||
[`ref? `](api/scheme/cyclone/util.md#ref)
|
||||
[`remainder`](api/scheme/base.md#remainder)
|
||||
[`remove `](api/scheme/cyclone/transforms.md#remove)
|
||||
[`remove!`](api/srfi/1.md#remove-1)
|
||||
[`remove`](api/srfi/1.md#remove)
|
||||
[`reverse!`](api/srfi/1.md#reverse)
|
||||
[`reverse-list->vector`](api/srfi/133.md#reverse-list-vector)
|
||||
[`reverse-vector->list`](api/srfi/133.md#reverse-vector-list)
|
||||
[`reverse`](api/scheme/base.md#reverse)
|
||||
[`round`](api/scheme/base.md#round)
|
||||
|
||||
- - -
|
||||
[`second`](api/srfi/1.md#second)
|
||||
[`set!->exp `](api/scheme/cyclone/util.md#set-exp)
|
||||
[`set!->var `](api/scheme/cyclone/util.md#set-var)
|
||||
[`set!? `](api/scheme/cyclone/util.md#set)
|
||||
[`set-box!`](api/srfi/111.md#set-box)
|
||||
[`set-car! `](api/primitives.md#set-car)
|
||||
[`set-cdr! `](api/primitives.md#set-cdr)
|
||||
[`set-cell! `](api/primitives.md#set-cell)
|
||||
[`set-cell!->cell `](api/scheme/cyclone/transforms.md#set-cell-cell)
|
||||
[`set-cell!->value `](api/scheme/cyclone/transforms.md#set-cell-value)
|
||||
[`set-cell!? `](api/scheme/cyclone/transforms.md#set-cell)
|
||||
[`setup-environment`](api/scheme/eval.md#setup-environment)
|
||||
[`seventh`](api/srfi/1.md#seventh)
|
||||
[`shutdown-method`](api/srfi/106.md#shutdown-method)
|
||||
[`simple-lambda?`](api/scheme/cyclone/cps-optimizations.md#simple-lambda)
|
||||
[`sin`](api/scheme/inexact.md#sin)
|
||||
[`sixth`](api/srfi/1.md#sixth)
|
||||
[`slot-set!`](api/scheme/base.md#slot-set)
|
||||
[`socket-accept`](api/srfi/106.md#socket-accept)
|
||||
[`socket-close`](api/srfi/106.md#socket-close)
|
||||
[`socket-domain`](api/srfi/106.md#socket-domain)
|
||||
[`socket-input-port`](api/srfi/106.md#socket-input-port)
|
||||
[`socket-merge-flags`](api/srfi/106.md#socket-merge-flags)
|
||||
[`socket-output-port`](api/srfi/106.md#socket-output-port)
|
||||
[`socket-purge-flags`](api/srfi/106.md#socket-purge-flags)
|
||||
[`socket-recv`](api/srfi/106.md#socket-recv)
|
||||
[`socket-send`](api/srfi/106.md#socket-send)
|
||||
[`socket-shutdown`](api/srfi/106.md#socket-shutdown)
|
||||
[`socket?`](api/srfi/106.md#socket)
|
||||
[`span!`](api/srfi/1.md#span-1)
|
||||
[`span`](api/srfi/1.md#span)
|
||||
[`split-at!`](api/srfi/1.md#split-at-1)
|
||||
[`split-at`](api/srfi/1.md#split-at)
|
||||
[`sqrt`](api/scheme/inexact.md#sqrt)
|
||||
[`square`](api/scheme/base.md#square)
|
||||
[`string->list`](api/scheme/base.md#string-list)
|
||||
[`string->number `](api/primitives.md#string-number)
|
||||
[`string->symbol `](api/primitives.md#string-symbol)
|
||||
[`string->utf8`](api/scheme/base.md#string-utf8)
|
||||
[`string->vector`](api/scheme/base.md#string-vector)
|
||||
[`string-append `](api/primitives.md#string-append)
|
||||
[`string-ci-hash`](api/srfi/69.md#string-ci-hash)
|
||||
[`string-ci<=?`](api/scheme/char.md#string-ci)
|
||||
[`string-ci<?`](api/scheme/char.md#string-ci-1)
|
||||
[`string-ci=?`](api/scheme/char.md#string-ci-2)
|
||||
[`string-ci>=?`](api/scheme/char.md#string-ci-3)
|
||||
[`string-ci>?`](api/scheme/char.md#string-ci-4)
|
||||
[`string-cmp `](api/primitives.md#string-cmp)
|
||||
[`string-copy!`](api/scheme/base.md#string-copy-1)
|
||||
[`string-copy`](api/scheme/base.md#string-copy)
|
||||
[`string-downcase`](api/scheme/char.md#string-downcase)
|
||||
[`string-fill!`](api/scheme/base.md#string-fill)
|
||||
[`string-foldcase`](api/scheme/char.md#string-foldcase)
|
||||
[`string-for-each`](api/scheme/base.md#string-for-each)
|
||||
[`string-hash`](api/srfi/69.md#string-hash)
|
||||
[`string-join`](api/scheme/cyclone/cgen.md#string-join)
|
||||
[`string-length `](api/primitives.md#string-length)
|
||||
[`string-map`](api/scheme/base.md#string-map)
|
||||
[`string-ref `](api/primitives.md#string-ref)
|
||||
[`string-replace-all `](api/scheme/cyclone/util.md#string-replace-all)
|
||||
[`string-set! `](api/primitives.md#string-set)
|
||||
[`string-upcase`](api/scheme/char.md#string-upcase)
|
||||
[`string<=?`](api/scheme/base.md#string-1)
|
||||
[`string<?`](api/scheme/base.md#string-2)
|
||||
[`string=?`](api/scheme/base.md#string-3)
|
||||
[`string>=?`](api/scheme/base.md#string-4)
|
||||
[`string>?`](api/scheme/base.md#string-5)
|
||||
[`string? `](api/primitives.md#string)
|
||||
[`string`](api/scheme/base.md#string)
|
||||
[`substring `](api/primitives.md#substring)
|
||||
[`symbol->string `](api/primitives.md#symbol-string)
|
||||
[`symbol<? `](api/scheme/cyclone/transforms.md#symbol)
|
||||
[`symbol=?`](api/scheme/base.md#symbol)
|
||||
[`symbol? `](api/primitives.md#symbol)
|
||||
[`syntax-error`](api/scheme/base.md#syntax-error)
|
||||
[`system `](api/primitives.md#system)
|
||||
|
||||
- - -
|
||||
[`tagged-list? `](api/scheme/cyclone/util.md#tagged-list?)
|
||||
[`take `](api/scheme/cyclone/util.md#take)
|
||||
[`take!`](api/srfi/1.md#take-1)
|
||||
[`take-right`](api/srfi/1.md#take-right)
|
||||
[`take-while!`](api/srfi/1.md#take-while-1)
|
||||
[`take-while`](api/srfi/1.md#take-while)
|
||||
[`take`](api/srfi/1.md#take)
|
||||
[`tan`](api/scheme/inexact.md#tan)
|
||||
[`tenth`](api/srfi/1.md#tenth)
|
||||
[`test-assert`](api/scheme/cyclone/test.md#test-assert)
|
||||
[`test-begin`](api/scheme/cyclone/test.md#test-begin)
|
||||
[`test-end`](api/scheme/cyclone/test.md#test-end)
|
||||
[`test-equal`](api/scheme/cyclone/test.md#test-equal)
|
||||
[`test-error`](api/scheme/cyclone/test.md#test-error)
|
||||
[`test-exit`](api/scheme/cyclone/test.md#test-exit)
|
||||
[`test-failure-count`](api/scheme/cyclone/test.md#test-failure-count)
|
||||
[`test-group-inc!`](api/scheme/cyclone/test.md#test-group-inc)
|
||||
[`test-group`](api/scheme/cyclone/test.md#test-group)
|
||||
[`test-not`](api/scheme/cyclone/test.md#test-not)
|
||||
[`test-propagate-info`](api/scheme/cyclone/test.md#test-propagate-info)
|
||||
[`test-run`](api/scheme/cyclone/test.md#test-run)
|
||||
[`test-syntax-error`](api/scheme/cyclone/test.md#test-syntax-error)
|
||||
[`test-values`](api/scheme/cyclone/test.md#test-values)
|
||||
[`test-vars`](api/scheme/cyclone/test.md#test-vars)
|
||||
[`test`](api/scheme/cyclone/test.md#test)
|
||||
[`third`](api/srfi/1.md#third)
|
||||
[`thread-name`](api/srfi/18.md#thread-name)
|
||||
[`thread-sleep!`](api/srfi/18.md#thread-sleep)
|
||||
[`thread-specific-set!`](api/srfi/18.md#thread-specific-set)
|
||||
[`thread-specific`](api/srfi/18.md#thread-specific)
|
||||
[`thread-start!`](api/srfi/18.md#thread-start)
|
||||
[`thread-terminate!`](api/srfi/18.md#thread-terminate)
|
||||
[`thread-yield!`](api/srfi/18.md#thread-yield)
|
||||
[`thread?`](api/srfi/18.md#thread)
|
||||
[`trace `](api/scheme/cyclone/transforms.md#trace)
|
||||
[`trace:debug `](api/scheme/cyclone/transforms.md#tracedebug)
|
||||
[`trace:error `](api/scheme/cyclone/transforms.md#traceerror)
|
||||
[`trace:info `](api/scheme/cyclone/transforms.md#traceinfo)
|
||||
[`trace:warn `](api/scheme/cyclone/transforms.md#tracewarn)
|
||||
[`tree-copy`](api/srfi/1.md#tree-copy)
|
||||
[`truncate-quotient`](api/scheme/base.md#truncate-quotient)
|
||||
[`truncate-remainder`](api/scheme/base.md#truncate-remainder)
|
||||
[`truncate/`](api/scheme/base.md#truncate-1)
|
||||
[`truncate`](api/scheme/base.md#truncate)
|
||||
[`type-slot-offset`](api/scheme/base.md#type-slot-offset)
|
||||
|
||||
- - -
|
||||
[`unbox`](api/srfi/111.md#unbox)
|
||||
[`unfold-right`](api/srfi/1.md#unfold-right)
|
||||
[`unfold`](api/srfi/1.md#unfold)
|
||||
[`union `](api/scheme/cyclone/transforms.md#union)
|
||||
[`unless`](api/scheme/base.md#unless)
|
||||
[`unzip1`](api/srfi/1.md#unzip1)
|
||||
[`unzip2`](api/srfi/1.md#unzip2)
|
||||
[`unzip3`](api/srfi/1.md#unzip3)
|
||||
[`unzip4`](api/srfi/1.md#unzip4)
|
||||
[`unzip5`](api/srfi/1.md#unzip5)
|
||||
[`utf8->string`](api/scheme/base.md#utf8-string)
|
||||
|
||||
- - -
|
||||
[`values`](api/scheme/base.md#values)
|
||||
[`vector->list`](api/scheme/base.md#vector-list)
|
||||
[`vector->string`](api/scheme/base.md#vector-string)
|
||||
[`vector-any`](api/srfi/133.md#vector-any)
|
||||
[`vector-append-subvectors`](api/srfi/133.md#vector-append-subvectors)
|
||||
[`vector-append`](api/scheme/base.md#vector-append)
|
||||
[`vector-binary-search`](api/srfi/133.md#vector-binary-search)
|
||||
[`vector-concatenate`](api/srfi/133.md#vector-concatenate)
|
||||
[`vector-copy!`](api/scheme/base.md#vector-copy-1)
|
||||
[`vector-copy`](api/scheme/base.md#vector-copy)
|
||||
[`vector-count`](api/srfi/133.md#vector-count)
|
||||
[`vector-cumulate`](api/srfi/133.md#vector-cumulate)
|
||||
[`vector-delete-neighbor-dups!`](api/srfi/132.md#vector-delete-neighbor-dups-1)
|
||||
[`vector-delete-neighbor-dups`](api/srfi/132.md#vector-delete-neighbor-dups)
|
||||
[`vector-empty?`](api/srfi/133.md#vector-empty)
|
||||
[`vector-every`](api/srfi/133.md#vector-every)
|
||||
[`vector-fill!`](api/scheme/base.md#vector-fill)
|
||||
[`vector-fold-right`](api/srfi/133.md#vector-fold-right)
|
||||
[`vector-fold`](api/srfi/133.md#vector-fold)
|
||||
[`vector-for-each`](api/scheme/base.md#vector-for-each)
|
||||
[`vector-index-right`](api/srfi/133.md#vector-index-right)
|
||||
[`vector-index`](api/srfi/133.md#vector-index)
|
||||
[`vector-length `](api/primitives.md#vector-length)
|
||||
[`vector-map!`](api/srfi/133.md#vector-map)
|
||||
[`vector-map`](api/scheme/base.md#vector-map)
|
||||
[`vector-merge!`](api/srfi/132.md#vector-merge-1)
|
||||
[`vector-merge`](api/srfi/132.md#vector-merge)
|
||||
[`vector-partition`](api/srfi/133.md#vector-partition)
|
||||
[`vector-ref `](api/primitives.md#vector-ref)
|
||||
[`vector-reverse!`](api/srfi/133.md#vector-reverse)
|
||||
[`vector-reverse-copy!`](api/srfi/133.md#vector-reverse-copy)
|
||||
[`vector-reverse-copy`](api/srfi/133.md#vector-reverse-copy)
|
||||
[`vector-set! `](api/primitives.md#vector-set)
|
||||
[`vector-skip-right`](api/srfi/133.md#vector-skip-right)
|
||||
[`vector-skip`](api/srfi/133.md#vector-skip)
|
||||
[`vector-sort!`](api/srfi/132.md#vector-sort-1)
|
||||
[`vector-sort`](api/srfi/132.md#vector-sort)
|
||||
[`vector-sorted?`](api/srfi/132.md#vector-sorted)
|
||||
[`vector-stable-sort!`](api/srfi/132.md#vector-stable-sort)
|
||||
[`vector-stable-sort`](api/srfi/132.md#vector-stable-sort)
|
||||
[`vector-swap!`](api/srfi/133.md#vector-swap)
|
||||
[`vector-unfold!`](api/srfi/133.md#vector-unfold)
|
||||
[`vector-unfold-right!`](api/srfi/133.md#vector-unfold-right)
|
||||
[`vector-unfold-right`](api/srfi/133.md#vector-unfold-right)
|
||||
[`vector-unfold`](api/srfi/133.md#vector-unfold)
|
||||
[`vector=`](api/srfi/133.md#vector)
|
||||
[`vector? `](api/primitives.md#vector)
|
||||
[`vector`](api/scheme/base.md#vector)
|
||||
|
||||
- - -
|
||||
[`warning`](api/scheme/cyclone/test.md#warning)
|
||||
[`when`](api/scheme/base.md#when)
|
||||
[`with-exception-handler`](api/scheme/base.md#with-exception-handler)
|
||||
[`with-input-from-file`](api/scheme/file.md#with-input-from-file)
|
||||
[`with-output-to-file`](api/scheme/file.md#with-output-to-file)
|
||||
[`wrap-mutables `](api/scheme/cyclone/transforms.md#wrap-mutables)
|
||||
[`write-char`](api/scheme/base.md#write-char)
|
||||
[`write-shared`](api/scheme/write.md#write-shared)
|
||||
[`write-simple`](api/scheme/write.md#write-simple)
|
||||
[`write-string`](api/scheme/base.md#write-string)
|
||||
[`write`](api/scheme/write.md#write)
|
||||
|
||||
- - -
|
||||
[`xcons`](api/srfi/1.md#xcons)
|
||||
|
||||
- - -
|
||||
[`zero?`](api/scheme/base.md#zero)
|
||||
[`zip`](api/srfi/1.md#zip)
|
||||
|
|
|
|||
317
docs/api/primitives.md
Normal file
317
docs/api/primitives.md
Normal file
|
|
@ -0,0 +1,317 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Primitives
|
||||
|
||||
This section contains all of the primitives and other objects that are included in the Cyclone runtime. These objects are always available regardless of library imports.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../r7rs.pdf).
|
||||
|
||||
- [`*`](#)
|
||||
- [`+`](#-1)
|
||||
- [`-`](#-)
|
||||
- [`/`](#-2)
|
||||
- [`<`](#-3)
|
||||
- [`<=`](#-4)
|
||||
- [`=`](#-5)
|
||||
- [`>`](#-6)
|
||||
- [`>=`](#-7)
|
||||
- [`apply `](#apply)
|
||||
- [`boolean? `](#boolean)
|
||||
- [`bytevector `](#bytevector)
|
||||
- [`bytevector-append `](#bytevector-append)
|
||||
- [`bytevector-length `](#bytevector-length)
|
||||
- [`bytevector-u8-ref `](#bytevector-u8-ref)
|
||||
- [`bytevector-u8-set! `](#bytevector-u8-set)
|
||||
- [`bytevector? `](#bytevector)
|
||||
- [`caar `](#caar)
|
||||
- [`cadr `](#cadr)
|
||||
- [`car `](#car)
|
||||
- [`cdar `](#cdar)
|
||||
- [`cddr `](#cddr)
|
||||
- [`cdr `](#cdr)
|
||||
- [`char->integer `](#char-integer)
|
||||
- [`char? `](#char)
|
||||
- [`close-input-port `](#close-input-port)
|
||||
- [`close-output-port `](#close-output-port)
|
||||
- [`close-port `](#close-port)
|
||||
- [`command-line-arguments`](#command-line-arguments)
|
||||
- [`cons `](#cons)
|
||||
- [`delete-file `](#delete-file)
|
||||
- [`eof-object? `](#eof-object)
|
||||
- [`eq? `](#eq)
|
||||
- [`equal? `](#equal)
|
||||
- [`eqv? `](#eqv)
|
||||
- [`error `](#error)
|
||||
- [`exit `](#exit)
|
||||
- [`file-exists? `](#file-exists)
|
||||
- [`integer->char `](#integer-char)
|
||||
- [`integer? `](#integer)
|
||||
- [`length `](#length)
|
||||
- [`list->string `](#list-string)
|
||||
- [`list->vector `](#list-vector)
|
||||
- [`make-bytevector `](#make-bytevector)
|
||||
- [`make-vector `](#make-vector)
|
||||
- [`null? `](#null)
|
||||
- [`number->string `](#number-string)
|
||||
- [`number? `](#number)
|
||||
- [`open-input-file `](#open-input-file)
|
||||
- [`open-output-file `](#open-output-file)
|
||||
- [`pair? `](#pair)
|
||||
- [`peek-char `](#peek-char)
|
||||
- [`port? `](#port)
|
||||
- [`procedure? `](#procedure)
|
||||
- [`read-char `](#read-char)
|
||||
- [`real? `](#real)
|
||||
- [`set-car! `](#set-car)
|
||||
- [`set-cdr! `](#set-cdr)
|
||||
- [`string->number `](#string-number)
|
||||
- [`string->symbol `](#string-symbol)
|
||||
- [`string-append `](#string-append)
|
||||
- [`string-cmp `](#string-cmp)
|
||||
- [`string-length `](#string-length)
|
||||
- [`string-ref `](#string-ref)
|
||||
- [`string-set! `](#string-set)
|
||||
- [`string? `](#string)
|
||||
- [`substring `](#substring)
|
||||
- [`symbol->string `](#symbol-string)
|
||||
- [`symbol? `](#symbol)
|
||||
- [`system `](#system)
|
||||
- [`vector-length `](#vector-length)
|
||||
- [`vector-ref `](#vector-ref)
|
||||
- [`vector-set! `](#vector-set)
|
||||
- [`vector? `](#vector)
|
||||
|
||||
#\*
|
||||
(* z1 ...)
|
||||
Return the product of the arguments.
|
||||
#+
|
||||
(+ z1 ...)
|
||||
Return the sum of the arguments.
|
||||
#-
|
||||
(- z)
|
||||
(- z1 z2 ...)
|
||||
With two or more arguments return their difference. With one argument return the additive inverse.
|
||||
#/
|
||||
(/ z)
|
||||
(/ z1 z2 ...)
|
||||
With two or more arguments return the quotient of the arguments. With one argument return the multiplicative inverse.
|
||||
#<
|
||||
(< x1 x2 ...)
|
||||
Return `#t` if the arguments are monotonically increasing, or `#f` otherwise.
|
||||
#<=
|
||||
(<= x1 x2 ...)
|
||||
Return `#t` if the arguments are monotonically non-decreasing, or `#f` otherwise.
|
||||
#=
|
||||
(= x1 x2 ...)
|
||||
Return `#t` if the arguments are equal, or `#f` otherwise.
|
||||
#>
|
||||
(> x1 x2 ...)
|
||||
Return `#t` if the arguments are monotonically decreasing, or `#f` otherwise.
|
||||
#>=
|
||||
(>= x1 x2 ...)
|
||||
Return `#t` if the arguments are monotonically non-increasing, or `#f` otherwise.
|
||||
#apply
|
||||
(apply proc arg1 ... args)
|
||||
The `apply` procedure calls `proc` with the elements of the list `(append (list arg1 ...) args)` as the actual arguments.
|
||||
#boolean?
|
||||
(boolean? obj)
|
||||
Determine if `obj` is a boolean.
|
||||
#bytevector
|
||||
(bytevector byte ...)
|
||||
Create a new bytevector consisting of the given bytes.
|
||||
#bytevector-append
|
||||
(bytevector-append bytevector ...)
|
||||
Append give bytevectors to create a new bytevector.
|
||||
#bytevector-length
|
||||
(bytevector-length bytevector)
|
||||
Return the length of the given bytevector.
|
||||
#bytevector-u8-ref
|
||||
(bytevector-u8-ref bytevector k)
|
||||
Return the bytevector element at index `k`.
|
||||
#bytevector-u8-set!
|
||||
(bytevector-u8-set! bytevector k byte)
|
||||
Change the value at index `k` of the bytevector to `byte`.
|
||||
#bytevector?
|
||||
(bytevector? obj)
|
||||
Determine if `obj` is a bytevector.
|
||||
#caar
|
||||
(caar pair)
|
||||
Return `(car (car pair))`
|
||||
#cadr
|
||||
(cadr pair)
|
||||
Return `(car (cdr pair))`
|
||||
#car
|
||||
(car pair)
|
||||
Return the contents of the car field of `pair`.
|
||||
#cdar
|
||||
(cdar pair)
|
||||
Return `(cdr (car pair))`
|
||||
#cddr
|
||||
(cddr pair)
|
||||
Return `(cdr (cdr pair))`
|
||||
#cdr
|
||||
(cdr pair)
|
||||
Return the contents of the cdr field of `pair`.
|
||||
#char->integer
|
||||
(char->integer char)
|
||||
Return the `char` as an integer value.
|
||||
#char?
|
||||
(char? obj)
|
||||
Determine if `obj` is a character.
|
||||
#close-input-port
|
||||
(close-input-port port)
|
||||
Close the given input port.
|
||||
#close-output-port
|
||||
(close-output-port port)
|
||||
Close the given output port.
|
||||
#close-port
|
||||
(close-port port)
|
||||
Close the given port.
|
||||
#command-line-arguments
|
||||
(command-line-arguments)
|
||||
Return the command line arguments to the program as a list of strings.
|
||||
#cons
|
||||
(cons a b)
|
||||
Create a new pair with its car field set to `a` and its cdr field set to `b`.
|
||||
#delete-file
|
||||
(delete-file string)
|
||||
Delete a file with the given filename.
|
||||
#eof-object?
|
||||
(eof-object? obj)
|
||||
Determine if the given object is an EOF object.
|
||||
#eq?
|
||||
(eq? a b)
|
||||
Determine if `a` and `b` are equal by comparing their pointer values. This operation is guaranteed to be a single comparison no matter the type of each object passed to the function.
|
||||
#equal?
|
||||
(equal? a b)
|
||||
Determine if `a` and `b` are equal by doing a "deep" comparison. For lists and vectors this means each element in the data structures will be compared until either the end of the structure is reached or an inequality is found. `equal?` is guaranteed to work for circular lists.
|
||||
#eqv?
|
||||
(eqv? a b)
|
||||
An alias of `eq?`.
|
||||
#error
|
||||
(error message obj ...)
|
||||
Raises an exception by calling `raise` with the given message and objects.
|
||||
#exit
|
||||
(exit)
|
||||
(exit obj)
|
||||
Exit the program.
|
||||
#file-exists?
|
||||
(file-exists? string)
|
||||
Determine if the file with filename `string` exists.
|
||||
#integer->char
|
||||
(integer->char x)
|
||||
Return a character with the same value as the given integer.
|
||||
#integer?
|
||||
(integer? obj)
|
||||
Determine if the given object is an integer.
|
||||
#length
|
||||
(length list)
|
||||
Returns the length of `list`.
|
||||
#list->string
|
||||
(list->string list)
|
||||
Convert the given list of characters to a string.
|
||||
#list->vector
|
||||
(list->vector list)
|
||||
Convert the given list to a vector.
|
||||
#make-bytevector
|
||||
(make-bytevector k)
|
||||
(make-bytevector k byte)
|
||||
Create a new bytevector of length `k`. If `byte` is provided, each element of the bytevector will be assigned this value.
|
||||
#make-vector
|
||||
(make-vector k)
|
||||
(make-vector k obj)
|
||||
Create a new vector of length `k`. If `obj` is provided, each element of the vector will be assigned this value.
|
||||
#null?
|
||||
(null? obj)
|
||||
Determine if the given object is the empty list.
|
||||
#number->string
|
||||
(number->string z)
|
||||
(number->string z radix)
|
||||
Return a string representation of the given number.
|
||||
#number?
|
||||
(number? obj)
|
||||
Determine if the given object is a number.
|
||||
#open-input-file
|
||||
(open-input-file string)
|
||||
Return an input port that can deliver data from the file `string`.
|
||||
#open-output-file
|
||||
(open-output-file string)
|
||||
Return an output port that can deliver data from the file `string`.
|
||||
#pair?
|
||||
(pair? obj)
|
||||
Determine if `obj` is a pair.
|
||||
#peek-char
|
||||
(peek-char)
|
||||
(peek-char port)
|
||||
Returns the next character available from the input port. If no characters are available and end-of-file object is returned.
|
||||
#port?
|
||||
(port? obj)
|
||||
Determine if `obj` is a port.
|
||||
#procedure?
|
||||
(procedure? obj)
|
||||
Determine if `obj` is a function.
|
||||
#read-char
|
||||
(read-char)
|
||||
(read-char port)
|
||||
Read a character from the input port.
|
||||
#real?
|
||||
(real? obj)
|
||||
Determine if `obj` is a real number.
|
||||
#set-car!
|
||||
(set-car! pair obj)
|
||||
Set the car field of `pair` to `obj`.
|
||||
#set-cdr!
|
||||
(set-cdr! pair obj)
|
||||
Set the car field of `pair` to `obj`.
|
||||
#string->number
|
||||
(string->number string)
|
||||
(string->number string radix)
|
||||
Return the number represented by the given string.
|
||||
#string->symbol
|
||||
(string->symbol string)
|
||||
Convert given string to a symbol.
|
||||
#string-append
|
||||
(string-append string ...)
|
||||
Returns a new string whose characters are the concatenation of the given strings.
|
||||
#string-cmp
|
||||
(string-cmp string1 string2)
|
||||
Compare both strings and return 0 if the strings are equal, a positive number if `string1` is "greater than" `string2`, and a negative number otherwise.
|
||||
#string-length
|
||||
(string-length string)
|
||||
Return the length of `string`.
|
||||
#string-ref
|
||||
(string-ref string k)
|
||||
Return the character at position `k` of `string`.
|
||||
#string-set!
|
||||
(string-set! string k char)
|
||||
Set the character of `string` at position `k` to `char`.
|
||||
#string?
|
||||
(string? obj)
|
||||
Determine if `obj` is a string.
|
||||
#substring
|
||||
(substring string start end)
|
||||
Return a newly-allocatd string consisting of the characters of `string` starting from position `start` and ending at `end`.
|
||||
#symbol->string
|
||||
(symbol->string symbol)
|
||||
Return a string based on the given symbol.
|
||||
#symbol?
|
||||
(symbol? obj)
|
||||
Determine if `obj` is a symbol.
|
||||
#system
|
||||
(system string)
|
||||
Execute an OS command `string` and return the resulting status as a number.
|
||||
#vector-length
|
||||
(vector-length vector)
|
||||
Return the length of `vector`.
|
||||
#vector-ref
|
||||
(vector-ref vector k)
|
||||
Return the element at position `k` of `vector`.
|
||||
#vector-set!
|
||||
(vector-set! vector k obj)
|
||||
Set the element of `vector` at position `k` to `obj`.
|
||||
#vector?
|
||||
(vector? obj)
|
||||
Determine if `obj` is a vector.
|
||||
510
docs/api/scheme/base.md
Normal file
510
docs/api/scheme/base.md
Normal file
|
|
@ -0,0 +1,510 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# 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)
|
||||
20
docs/api/scheme/case-lambda.md
Normal file
20
docs/api/scheme/case-lambda.md
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Case-Lambda Library
|
||||
|
||||
The `(scheme case-lambda)` library exports the `case-lambda` syntax.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`case-lambda`](#case-lambda)
|
||||
|
||||
#case-lambda
|
||||
|
||||
(case-lambda {clause} ...)
|
||||
|
||||
Syntax: Each `{clause}` is of the form `({formals} {body})`, where `{formals}` and `{body}` have the same syntax as in a lambda expression.
|
||||
|
||||
Semantics: A `case-lambda` expression evaluates to a procedure that accepts a variable number of arguments and is lexically scoped in the same manner as a procedure resulting from a lambda expression.
|
||||
79
docs/api/scheme/char.md
Normal file
79
docs/api/scheme/char.md
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Char Library
|
||||
|
||||
The `(scheme char)` library provides the procedures for dealing with characters.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`char-alphabetic?`](#char-alphabetic)
|
||||
- [`char-ci<=?`](#char-ci)
|
||||
- [`char-ci<?`](#char-ci-1)
|
||||
- [`char-ci=?`](#char-ci-2)
|
||||
- [`char-ci>=?`](#char-ci-3)
|
||||
- [`char-ci>?`](#char-ci-4)
|
||||
- [`char-downcase`](#char-downcase)
|
||||
- [`char-foldcase`](#char-foldcase)
|
||||
- [`char-lower-case?`](#char-lower-case)
|
||||
- [`char-numeric?`](#char-numeric)
|
||||
- [`char-upcase`](#char-upcase)
|
||||
- [`char-upper-case?`](#char-upper-case)
|
||||
- [`char-whitespace?`](#char-whitespace)
|
||||
- [`digit-value`](#digit-value)
|
||||
- [`string-ci<=?`](#string-ci)
|
||||
- [`string-ci<?`](#string-ci-1)
|
||||
- [`string-ci=?`](#string-ci-2)
|
||||
- [`string-ci>=?`](#string-ci-3)
|
||||
- [`string-ci>?`](#string-ci-4)
|
||||
- [`string-downcase`](#string-downcase)
|
||||
- [`string-foldcase`](#string-foldcase)
|
||||
- [`string-upcase`](#string-upcase)
|
||||
|
||||
#char-alphabetic?
|
||||
(char-alphabetic? c)
|
||||
#char-ci<=?
|
||||
(char-ci<=? c1 c2 . cs)
|
||||
#char-ci<?
|
||||
(char-ci<? c1 c2 . cs)
|
||||
#char-ci=?
|
||||
(char-ci=? c1 c2 . cs)
|
||||
#char-ci>=?
|
||||
(char-ci>=? c1 c2 . cs)
|
||||
#char-ci>?
|
||||
(char-ci>? c1 c2 . cs)
|
||||
#char-downcase
|
||||
(char-downcase c)
|
||||
#char-foldcase
|
||||
(char-foldcase c)
|
||||
#char-lower-case?
|
||||
(char-lower-case? c)
|
||||
#char-numeric?
|
||||
(char-numeric? c)
|
||||
#char-upcase
|
||||
(char-upcase c)
|
||||
#char-upper-case?
|
||||
(char-upper-case? c)
|
||||
#char-whitespace?
|
||||
(char-whitespace? c)
|
||||
#digit-value
|
||||
(digit-value c)
|
||||
#string-ci<=?
|
||||
(string-ci<=? s1 s2)
|
||||
#string-ci<?
|
||||
(string-ci<? s1 s2)
|
||||
#string-ci=?
|
||||
(string-ci=? s1 s2)
|
||||
#string-ci>=?
|
||||
(string-ci>=? s1 s2)
|
||||
#string-ci>?
|
||||
(string-ci>? s1 s2)
|
||||
#string-downcase
|
||||
(string-downcase str)
|
||||
#string-foldcase
|
||||
(string-foldcase str)
|
||||
#string-upcase
|
||||
(string-upcase str)
|
||||
|
||||
30
docs/api/scheme/complex.md
Normal file
30
docs/api/scheme/complex.md
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Complex Library
|
||||
|
||||
The `(scheme complex)` library exports procedures which are typically only useful with non-real numbers.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`angle`](#angle)
|
||||
- [`imag-part`](#imag-part)
|
||||
- [`magnitude`](#magnitude)
|
||||
- [`make-polar`](#make-polar)
|
||||
- [`make-rectangular`](#make-rectangular)
|
||||
- [`real-part`](#real-part)
|
||||
|
||||
#angle
|
||||
(angle z)
|
||||
#imag-part
|
||||
(imag-part x)
|
||||
#magnitude
|
||||
(magnitude z)
|
||||
#make-polar
|
||||
(make-polar x y)
|
||||
#make-rectangular
|
||||
(make-rectangular x y)
|
||||
#real-part
|
||||
(real-part x)
|
||||
89
docs/api/scheme/cxr.md
Normal file
89
docs/api/scheme/cxr.md
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# CxR Library
|
||||
|
||||
The `(scheme cxr)` library exports twenty-four procedures which are the compositions of from three to four `car` and `cdr` operations. For example `caddar` is defined by:
|
||||
|
||||
(define caddar
|
||||
(lambda (x) (car (cdr (cdr (car x))))))
|
||||
|
||||
The procedures `car` and `cdr` themselves and the four two-level compositions are included in the base library.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`caaar`](#caaar)
|
||||
- [`caadr`](#caadr)
|
||||
- [`cadar`](#cadar)
|
||||
- [`caddr`](#caddr)
|
||||
- [`cdaar`](#cdaar)
|
||||
- [`cdadr`](#cdadr)
|
||||
- [`cddar`](#cddar)
|
||||
- [`cdddr`](#cdddr)
|
||||
- [`caaaar`](#caaaar)
|
||||
- [`caaadr`](#caaadr)
|
||||
- [`caadar`](#caadar)
|
||||
- [`caaddr`](#caaddr)
|
||||
- [`cadaar`](#cadaar)
|
||||
- [`cadadr`](#cadadr)
|
||||
- [`caddar`](#caddar)
|
||||
- [`cadddr`](#cadddr)
|
||||
- [`cdaaar`](#cdaaar)
|
||||
- [`cdaadr`](#cdaadr)
|
||||
- [`cdadar`](#cdadar)
|
||||
- [`cdaddr`](#cdaddr)
|
||||
- [`cddaar`](#cddaar)
|
||||
- [`cddadr`](#cddadr)
|
||||
- [`cdddar`](#cdddar)
|
||||
- [`cddddr`](#cddddr)
|
||||
|
||||
#caaar
|
||||
(caaar list)
|
||||
#caadr
|
||||
(caadr list)
|
||||
#cadar
|
||||
(cadar list)
|
||||
#caddr
|
||||
(caddr list)
|
||||
#cdaar
|
||||
(cdaar list)
|
||||
#cdadr
|
||||
(cdadr list)
|
||||
#cddar
|
||||
(cddar list)
|
||||
#cdddr
|
||||
(cdddr list)
|
||||
#caaaar
|
||||
(caaaar list)
|
||||
#caaadr
|
||||
(caaadr list)
|
||||
#caadar
|
||||
(caadar list)
|
||||
#caaddr
|
||||
(caaddr list)
|
||||
#cadaar
|
||||
(cadaar list)
|
||||
#cadadr
|
||||
(cadadr list)
|
||||
#caddar
|
||||
(caddar list)
|
||||
#cadddr
|
||||
(cadddr list)
|
||||
#cdaaar
|
||||
(cdaaar list)
|
||||
#cdaadr
|
||||
(cdaadr list)
|
||||
#cdadar
|
||||
(cdadar list)
|
||||
#cdaddr
|
||||
(cdaddr list)
|
||||
#cddaar
|
||||
(cddaar list)
|
||||
#cddadr
|
||||
(cddadr list)
|
||||
#cdddar
|
||||
(cdddar list)
|
||||
#cddddr
|
||||
(cddddr list)
|
||||
37
docs/api/scheme/cyclone/ast.md
Normal file
37
docs/api/scheme/cyclone/ast.md
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# AST library
|
||||
|
||||
The `(scheme cyclone ast)` library defines abstract syntax tree types used during compilation.
|
||||
|
||||
- [`ast:make-lambda`](#astmake-lambda)
|
||||
- [`ast:%make-lambda`](#astmake-lambda-1)
|
||||
- [`ast:lambda?`](#astlambda)
|
||||
- [`ast:lambda-id`](#astlambda-id)
|
||||
- [`ast:lambda-args`](#astlambda-args)
|
||||
- [`ast:set-lambda-args!`](#astset-lambda-args)
|
||||
- [`ast:lambda-body`](#astlambda-body)
|
||||
- [`ast:set-lambda-body!`](#astset-lambda-body)
|
||||
|
||||
#ast:make-lambda
|
||||
(ast:make-lambda args body)
|
||||
|
||||
#ast:%make-lambda
|
||||
(ast:%make-lambda lambda-id args body)
|
||||
|
||||
#ast:lambda?
|
||||
(ast:lambda? obj)
|
||||
|
||||
#ast:lambda-id
|
||||
(ast:lambda-id lambda-obj)
|
||||
#ast:lambda-args
|
||||
(ast:lambda-args lambda-obj)
|
||||
#ast:set-lambda-args!
|
||||
(ast:set-lambda-args! lambda-obj args)
|
||||
#ast:lambda-body
|
||||
(ast:lambda-body lambda-obj)
|
||||
#ast:set-lambda-body!
|
||||
(ast:set-lambda-body! lambda-obj body)
|
||||
38
docs/api/scheme/cyclone/cgen.md
Normal file
38
docs/api/scheme/cyclone/cgen.md
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# C Code Generation Library
|
||||
|
||||
The `(scheme cyclone cgen)` library compiles scheme code to a Cheney-on-the-MTA C runtime.
|
||||
|
||||
- [`mta:code-gen`](#mtacode-gen)
|
||||
- [`emit`](#emit)
|
||||
- [`emit*`](#emit-1)
|
||||
- [`emits`](#emits)
|
||||
- [`emits*`](#emits-1)
|
||||
- [`emit-newline`](#emit-newline)
|
||||
- [`string-join`](#string-join)
|
||||
|
||||
#mta:code-gen
|
||||
(mta:code-gen input-program program? lib-name lib-exports imported-globals globals c-headers required-libs src-file)
|
||||
Convert the given input program - as pre-processed Scheme AST - into C code. This function cannot be called directly on a Scheme program, but must be called on Scheme code that has already been processed by all of the compiler's Scheme transformations, including CPS and closure conversions.
|
||||
#emit
|
||||
(emit string)
|
||||
`display` the string to the output port with a trailing newline.
|
||||
#emit\*
|
||||
(emit* string ...)
|
||||
Emit all of the given strings and add a trailing newline.
|
||||
#emits
|
||||
(emits string)
|
||||
`display` the string to the output port.
|
||||
#emits\*
|
||||
(emits* string ...)
|
||||
Call `emits` for each of the given strings.
|
||||
#emit-newline
|
||||
(emit-newline)
|
||||
`display` a newline to the current output port.
|
||||
#string-join
|
||||
(string-join list deliminator)
|
||||
Create a single string from a list of strings, adding `deliminator` between each of the strings.
|
||||
28
docs/api/scheme/cyclone/common.md
Normal file
28
docs/api/scheme/cyclone/common.md
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Common Library
|
||||
|
||||
The `(scheme cyclone common)` library contains definitions used by the compiler and interpreter.
|
||||
|
||||
- [`*Cyc-version-banner*`](#Cyc-version-banner)
|
||||
- [`*version*`](#version)
|
||||
- [`*version-number*`](#version-number)
|
||||
- [`*version-name*`](#version-name)
|
||||
- [`*version-banner*`](#version-banner)
|
||||
- [`*c-file-header-comment*`](#c-file-header-comment)
|
||||
|
||||
#\*Cyc-version-banner\*
|
||||
The version banner printed when `icyc` starts.
|
||||
#\*version\*
|
||||
The version number and name.
|
||||
#\*version-number\*
|
||||
The current version number.
|
||||
#\*version-name\*
|
||||
The current version name.
|
||||
#\*version-banner\*
|
||||
The version banner printed when `icyc` starts.
|
||||
#\*c-file-header-comment\*
|
||||
The header comment added to C files.
|
||||
80
docs/api/scheme/cyclone/cps-optimizations.md
Normal file
80
docs/api/scheme/cyclone/cps-optimizations.md
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# CPS Optimization Library
|
||||
|
||||
The `(scheme cyclone optimizations)` library performs CPS analysis and optimizations.
|
||||
|
||||
- [`optimize-cps`](#optimize-cps)
|
||||
- [`analyze-cps`](#analyze-cps)
|
||||
- [`opt:contract`](#optcontract)
|
||||
- [`opt:inline-prims`](#optinline-prims)
|
||||
- [`adb:clear!`](#adbclear)
|
||||
- [`adb:get`](#adbget)
|
||||
- [`adb:get/default`](#adbgetdefault)
|
||||
- [`adb:set!`](#adbset)
|
||||
- [`adb:get-db`](#adbget-db)
|
||||
- [`simple-lambda?`](#simple-lambda)
|
||||
- [`one-instance-of-new-mutable-obj?`](#one-instance-of-new-mutable-obj)
|
||||
- [`adb:make-var`](#adbmake-var)
|
||||
- [`%adb:make-var`](#adbmake-var-1)
|
||||
- [`adb:variable?`](#adbvariable)
|
||||
- [`adbv:global?`](#adbvglobal)
|
||||
- [`adbv:set-global!`](#adbvset-global)
|
||||
- [`adbv:defined-by`](#adbvdefined-by)
|
||||
- [`adbv:set-defined-by!`](#adbvset-defined-by)
|
||||
- [`adbv:reassigned?`](#adbvreassigned)
|
||||
- [`adbv:set-reassigned!`](#adbvset-reassigned)
|
||||
- [`adbv:assigned-value`](#adbvassigned-value)
|
||||
- [`adbv:set-assigned-value!`](#adbvset-assigned-value)
|
||||
- [`adbv:const?`](#adbvconst)
|
||||
- [`adbv:set-const!`](#adbvset-const)
|
||||
- [`adbv:const-value`](#adbvconst-value)
|
||||
- [`adbv:set-const-value!`](#adbvset-const-value)
|
||||
- [`adbv:ref-by`](#adbvref-by)
|
||||
- [`adbv:set-ref-by!`](#adbvset-ref-by)
|
||||
- [`adb:make-fnc`](#adbmake-fnc)
|
||||
- [`%adb:make-fnc`](#adbmake-fnc-1)
|
||||
- [`adb:function?`](#adbfunction)
|
||||
- [`adbf:simple`](#adbfsimple)
|
||||
- [`adbf:set-simple!`](#adbfset-simple)
|
||||
- [`adbf:unused-params`](#adbfunused-params)
|
||||
- [`adbf:set-unused-params!`](#adbfset-unused-params)
|
||||
|
||||
#optimize-cps
|
||||
#analyze-cps
|
||||
#opt:contract
|
||||
#opt:inline-prims
|
||||
#adb:clear!
|
||||
#adb:get
|
||||
#adb:get/default
|
||||
#adb:set!
|
||||
#adb:get-db
|
||||
#simple-lambda?
|
||||
#one-instance-of-new-mutable-obj?
|
||||
#adb:make-var
|
||||
#%adb:make-var
|
||||
#adb:variable?
|
||||
#adbv:global?
|
||||
#adbv:set-global!
|
||||
#adbv:defined-by
|
||||
#adbv:set-defined-by!
|
||||
#adbv:reassigned?
|
||||
#adbv:set-reassigned!
|
||||
#adbv:assigned-value
|
||||
#adbv:set-assigned-value!
|
||||
#adbv:const?
|
||||
#adbv:set-const!
|
||||
#adbv:const-value
|
||||
#adbv:set-const-value!
|
||||
#adbv:ref-by
|
||||
#adbv:set-ref-by!
|
||||
#adb:make-fnc
|
||||
#%adb:make-fnc
|
||||
#adb:function?
|
||||
#adbf:simple
|
||||
#adbf:set-simple!
|
||||
#adbf:unused-params
|
||||
#adbf:set-unused-params!
|
||||
61
docs/api/scheme/cyclone/libraries.md
Normal file
61
docs/api/scheme/cyclone/libraries.md
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# R7RS Library Interface Library
|
||||
|
||||
The `(scheme cyclone libraries)` library implements r7rs libraries.
|
||||
|
||||
- [`library?`](#library)
|
||||
- [`lib:list->import-set`](#liblist-import-set)
|
||||
- [`lib:name`](#libname)
|
||||
- [`lib:name->string`](#libname-string)
|
||||
- [`lib:name->symbol`](#libname-symbol)
|
||||
- [`lib:result`](#libresult)
|
||||
- [`lib:exports`](#libexports)
|
||||
- [`lib:rename-exports`](#librename-exports)
|
||||
- [`lib:imports`](#libimports)
|
||||
- [`lib:body`](#libbody)
|
||||
- [`lib:includes`](#libincludes)
|
||||
- [`lib:include-c-headers`](#libinclude-c-headers)
|
||||
- [`lib:import->filename`](#libimport-filename)
|
||||
- [`lib:import->metalist`](#libimport-metalist)
|
||||
- [`lib:import->path`](#libimport-path)
|
||||
- [`lib:read-imports`](#libread-imports)
|
||||
- [`lib:import->export-list`](#libimport-export-list)
|
||||
- [`lib:resolve-imports`](#libresolve-imports)
|
||||
- [`lib:resolve-meta`](#libresolve-meta)
|
||||
- [`lib:get-all`](#libget-all)
|
||||
- [`lib:get-all-import-deps`](#libget-all-import-deps)
|
||||
- [`lib:get-dep-list`](#libget-dep-list)
|
||||
- [`lib:imports->idb`](#libimports-idb)
|
||||
- [`lib:idb:ids`](#libidb:ids)
|
||||
- [`lib:idb:id->import`](#libidb:id-import)
|
||||
|
||||
#library?
|
||||
(library? obj)
|
||||
#lib:list->import-set
|
||||
#lib:name
|
||||
#lib:name->string
|
||||
#lib:name->symbol
|
||||
#lib:result
|
||||
#lib:exports
|
||||
#lib:rename-exports
|
||||
#lib:imports
|
||||
#lib:body
|
||||
#lib:includes
|
||||
#lib:include-c-headers
|
||||
#lib:import->filename
|
||||
#lib:import->metalist
|
||||
#lib:import->path
|
||||
#lib:read-imports
|
||||
#lib:import->export-list
|
||||
#lib:resolve-imports
|
||||
#lib:resolve-meta
|
||||
#lib:get-all
|
||||
#lib:get-all-import-deps
|
||||
#lib:get-dep-list
|
||||
#lib:imports->idb
|
||||
#lib:idb:ids
|
||||
#lib:idb:id->import
|
||||
26
docs/api/scheme/cyclone/macros.md
Normal file
26
docs/api/scheme/cyclone/macros.md
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Macro Library
|
||||
|
||||
The `(scheme cyclone macro)` library contains code to deal with macros.
|
||||
|
||||
- [`define-syntax?`](#define-syntax)
|
||||
- [`macro:macro?`](#macromacro)
|
||||
- [`macro:expand`](#macroexpand)
|
||||
- [`macro:add!`](#macroadd)
|
||||
- [`macro:cleanup`](#macrocleanup)
|
||||
- [`macro:load-env!`](#macroload-env)
|
||||
- [`macro:get-env`](#macroget-env)
|
||||
- [`macro:get-defined-macros`](#macroget-defined-macros)
|
||||
|
||||
#define-syntax?
|
||||
#macro:macro?
|
||||
#macro:expand
|
||||
#macro:add!
|
||||
#macro:cleanup
|
||||
#macro:load-env!
|
||||
#macro:get-env
|
||||
#macro:get-defined-macros
|
||||
15
docs/api/scheme/cyclone/pretty-print.md
Normal file
15
docs/api/scheme/cyclone/pretty-print.md
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Pretty Print Library
|
||||
|
||||
The `(scheme cyclone pretty-print)` library provides a pretty-printer for code formatting.
|
||||
|
||||
- [`pretty-print`](#pretty-print)
|
||||
|
||||
#pretty-print
|
||||
(pretty-print obj)
|
||||
(pretty-print obj port)
|
||||
Outputs object to the given output port, or the current output port if none is given. The output is automatically indented just like it would be in a source code file, to make it easier to read.
|
||||
38
docs/api/scheme/cyclone/primitives.md
Normal file
38
docs/api/scheme/cyclone/primitives.md
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Primitives Library
|
||||
|
||||
The `(scheme cyclone primitives)` library contains information about Cyclone's scheme primitives.
|
||||
|
||||
- [`prim?`](#prim)
|
||||
- [`*primitives*`](#primitives)
|
||||
- [`*primitives-num-args*`](#primitives-num-args)
|
||||
- [`prim-call?`](#prim-call)
|
||||
- [`prim->c-func`](#prim-c-func)
|
||||
- [`prim/data-arg?`](#primdata-arg)
|
||||
- [`prim/c-var-assign`](#primc-var-assign)
|
||||
- [`prim/cvar?`](#primcvar)
|
||||
- [`prim:check-arg-count`](#primcheck-arg-count)
|
||||
- [`prim:mutates?`](#primmutates)
|
||||
- [`prim:cont?`](#primcont)
|
||||
- [`prim:cont/no-args?`](#primcontno-args)
|
||||
- [`prim:arg-count?`](#primarg-count)
|
||||
- [`prim:allocates-object?)`](#primallocates-object)
|
||||
|
||||
#prim?
|
||||
#\*primitives\*
|
||||
#\*primitives-num-args\*
|
||||
#prim-call?
|
||||
#prim->c-func
|
||||
#prim/data-arg?
|
||||
#prim/c-var-assign
|
||||
#prim/cvar?
|
||||
#prim:check-arg-count
|
||||
#prim:mutates?
|
||||
#prim:cont?
|
||||
#prim:cont/no-args?
|
||||
#prim:arg-count?
|
||||
#prim:allocates-object?)
|
||||
62
docs/api/scheme/cyclone/test.md
Normal file
62
docs/api/scheme/cyclone/test.md
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Test Library
|
||||
|
||||
The `(scheme cyclone test)` library contains a testing framework ported from `(chibi test)` which in turn was ported from CHICKEN.
|
||||
|
||||
- [`warning`](#warning)
|
||||
- [`test-group-inc!`](#test-group-inc)
|
||||
- [`print-exception`](#print-exception)
|
||||
- [`test`](#test)
|
||||
- [`test-equal`](#test-equal)
|
||||
- [`test-error`](#test-error)
|
||||
- [`test-assert`](#test-assert)
|
||||
- [`test-not`](#test-not)
|
||||
- [`test-values`](#test-values)
|
||||
- [`test-group`](#test-group)
|
||||
- [`current-test-group`](#current-test-group)
|
||||
- [`test-begin`](#test-begin)
|
||||
- [`test-end`](#test-end)
|
||||
- [`test-syntax-error`](#test-syntax-error)
|
||||
- [`test-propagate-info`](#test-propagate-info)
|
||||
- [`test-vars`](#test-vars)
|
||||
- [`test-run`](#test-run)
|
||||
- [`test-exit`](#test-exit)
|
||||
- [`current-test-verbosity`](#current-test-verbosity)
|
||||
- [`current-test-applier`](#current-test-applier)
|
||||
- [`current-test-handler`](#current-test-handler)
|
||||
- [`current-test-skipper`](#current-test-skipper)
|
||||
- [`current-test-group-reporter`](#current-test-group-reporter)
|
||||
- [`test-failure-count`](#test-failure-count)
|
||||
- [`current-test-epsilon`](#current-test-epsilon)
|
||||
- [`current-test-comparator`](#current-test-comparator)
|
||||
|
||||
#warning
|
||||
#test-group-inc!
|
||||
#print-exception
|
||||
#test
|
||||
#test-equal
|
||||
#test-error
|
||||
#test-assert
|
||||
#test-not
|
||||
#test-values
|
||||
#test-group
|
||||
#current-test-group
|
||||
#test-begin
|
||||
#test-end
|
||||
#test-syntax-error
|
||||
#test-propagate-info
|
||||
#test-vars
|
||||
#test-run
|
||||
#test-exit
|
||||
#current-test-verbosity
|
||||
#current-test-applier
|
||||
#current-test-handler
|
||||
#current-test-skipper
|
||||
#current-test-group-reporter
|
||||
#test-failure-count
|
||||
#current-test-epsilon
|
||||
#current-test-comparator
|
||||
170
docs/api/scheme/cyclone/transforms.md
Normal file
170
docs/api/scheme/cyclone/transforms.md
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Transforms Library
|
||||
|
||||
The `(scheme cyclone transforms)` library performs Scheme-to-Scheme transformations, and also contains various utility functions used by the compiler.
|
||||
|
||||
- [`*defined-macros* `](#*defined-macros)
|
||||
- [`*do-code-gen* `](#*do-code-gen)
|
||||
- [`*primitives* `](#*primitives)
|
||||
- [`*trace-level* `](#*trace-level)
|
||||
- [`alpha-convert `](#alpha-convert)
|
||||
- [`analyze-mutable-variables `](#analyze-mutable-variables)
|
||||
- [`app->args `](#app-args)
|
||||
- [`app->fun `](#app-fun)
|
||||
- [`assq-remove-key `](#assq-remove-key)
|
||||
- [`assq-remove-keys `](#assq-remove-keys)
|
||||
- [`ast:lambda-formals->list `](#astlambda-formals-list)
|
||||
- [`ast:lambda-formals-type `](#astlambda-formals-type)
|
||||
- [`azip `](#azip)
|
||||
- [`basename `](#basename)
|
||||
- [`begin->exps `](#begin-exps)
|
||||
- [`built-in-syms `](#built-in-syms)
|
||||
- [`cell->value `](#cell-value)
|
||||
- [`cell-get->cell `](#cell-get-cell)
|
||||
- [`cell-get? `](#cell-get)
|
||||
- [`cell? `](#cell)
|
||||
- [`clear-mutables `](#clear-mutables)
|
||||
- [`closure->env `](#closure-env)
|
||||
- [`closure->fv `](#closure-fv)
|
||||
- [`closure->lam `](#closure-lam)
|
||||
- [`closure-convert `](#closure-convert)
|
||||
- [`closure? `](#closure)
|
||||
- [`cps-convert `](#cps-convert)
|
||||
- [`cyc:error `](#cycerror)
|
||||
- [`define->lambda `](#define-lambda)
|
||||
- [`define-lambda? `](#define-lambda-1)
|
||||
- [`difference `](#difference)
|
||||
- [`env-get->env `](#env-get-env)
|
||||
- [`env-get->field `](#env-get-field)
|
||||
- [`env-get->id `](#env-get-id)
|
||||
- [`env-get? `](#env-get)
|
||||
- [`env-make->fields `](#env-make-fields)
|
||||
- [`env-make->id `](#env-make-id)
|
||||
- [`env-make->values `](#env-make-values)
|
||||
- [`env-make? `](#env-make)
|
||||
- [`expand `](#expand)
|
||||
- [`expand-lambda-body `](#expand-lambda-body)
|
||||
- [`filter-unused-variables `](#filter-unused-variables)
|
||||
- [`free-vars `](#free-vars)
|
||||
- [`get-macros `](#get-macros)
|
||||
- [`global-vars `](#global-vars)
|
||||
- [`has-global? `](#has-global)
|
||||
- [`insert `](#insert)
|
||||
- [`is-mutable? `](#is-mutable)
|
||||
- [`isolate-globals `](#isolate-globals)
|
||||
- [`lambda-num-args `](#lambda-num-args)
|
||||
- [`let->args `](#let-args)
|
||||
- [`let->bindings `](#let-bindings)
|
||||
- [`let->bound-vars `](#let-bound-vars)
|
||||
- [`let->exp `](#let-exp)
|
||||
- [`let=>lambda `](#letlambda)
|
||||
- [`let? `](#let)
|
||||
- [`letrec->args `](#letrec-args)
|
||||
- [`letrec->bindings `](#letrec-bindings)
|
||||
- [`letrec->bound-vars `](#letrec-bound-vars)
|
||||
- [`letrec->exp `](#letrec-exp)
|
||||
- [`letrec? `](#letrec)
|
||||
- [`list->lambda-formals `](#list-lambda-formals)
|
||||
- [`list->pair `](#list-pair)
|
||||
- [`list-index `](#list-index)
|
||||
- [`mark-mutable `](#mark-mutable)
|
||||
- [`pos-in-list `](#pos-in-list)
|
||||
- [`precompute-prim-app? `](#precompute-prim-app)
|
||||
- [`reduce `](#reduce)
|
||||
- [`remove `](#remove)
|
||||
- [`set-cell!->cell `](#set-cell-cell)
|
||||
- [`set-cell!->value `](#set-cell-value)
|
||||
- [`set-cell!? `](#set-cell)
|
||||
- [`symbol<? `](#symbol)
|
||||
- [`trace `](#trace)
|
||||
- [`trace:debug `](#tracedebug)
|
||||
- [`trace:error `](#traceerror)
|
||||
- [`trace:info `](#traceinfo)
|
||||
- [`trace:warn `](#tracewarn)
|
||||
- [`union `](#union)
|
||||
- [`wrap-mutables `](#wrap-mutables)
|
||||
|
||||
#\*defined-macros\*
|
||||
#\*do-code-gen\*
|
||||
#\*primitives\*
|
||||
#\*trace-level\*
|
||||
#alpha-convert
|
||||
#analyze-mutable-variables
|
||||
#app->args
|
||||
#app->fun
|
||||
#assq-remove-key
|
||||
#assq-remove-keys
|
||||
#ast:lambda-formals->list
|
||||
#ast:lambda-formals-type
|
||||
#azip
|
||||
#basename
|
||||
#begin->exps
|
||||
#built-in-syms
|
||||
#cell->value
|
||||
#cell-get->cell
|
||||
#cell-get?
|
||||
#cell?
|
||||
#clear-mutables
|
||||
#closure->env
|
||||
#closure->fv
|
||||
#closure->lam
|
||||
#closure-convert
|
||||
#closure?
|
||||
#cps-convert
|
||||
#cyc:error
|
||||
#define->lambda
|
||||
#define-lambda?
|
||||
#difference
|
||||
#env-get->env
|
||||
#env-get->field
|
||||
#env-get->id
|
||||
#env-get?
|
||||
#env-make->fields
|
||||
#env-make->id
|
||||
#env-make->values
|
||||
#env-make?
|
||||
#expand
|
||||
#expand-lambda-body
|
||||
#filter-unused-variables
|
||||
#free-vars
|
||||
#get-macros
|
||||
#global-vars
|
||||
#has-global?
|
||||
#insert
|
||||
#is-mutable?
|
||||
#isolate-globals
|
||||
#lambda-num-args
|
||||
#let->args
|
||||
#let->bindings
|
||||
#let->bound-vars
|
||||
#let->exp
|
||||
#let=>lambda
|
||||
#let?
|
||||
#letrec->args
|
||||
#letrec->bindings
|
||||
#letrec->bound-vars
|
||||
#letrec->exp
|
||||
#letrec?
|
||||
#list->lambda-formals
|
||||
#list->pair
|
||||
#list-index
|
||||
#mark-mutable
|
||||
#pos-in-list
|
||||
#precompute-prim-app?
|
||||
#reduce
|
||||
#remove
|
||||
#set-cell!->cell
|
||||
#set-cell!->value
|
||||
#set-cell!?
|
||||
#symbol<?
|
||||
#trace
|
||||
#trace:debug
|
||||
#trace:error
|
||||
#trace:info
|
||||
#trace:warn
|
||||
#union
|
||||
#wrap-mutables
|
||||
132
docs/api/scheme/cyclone/util.md
Normal file
132
docs/api/scheme/cyclone/util.md
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Util Library
|
||||
|
||||
The `(scheme cyclone util`) library contains various utility functions.
|
||||
|
||||
- [`Cyc-er-compare? `](#Cyc-er-compare)
|
||||
- [`Cyc-er-rename `](#Cyc-er-rename)
|
||||
- [`app? `](#app)
|
||||
- [`begin? `](#begin)
|
||||
- [`const? `](#const)
|
||||
- [`define->exp `](#define-exp)
|
||||
- [`define->var `](#define-var)
|
||||
- [`define-c? `](#define-c)
|
||||
- [`define? `](#define)
|
||||
- [`delete `](#delete)
|
||||
- [`delete-duplicates `](#delete-duplicates)
|
||||
- [`env:_lookup-variable-value `](#envlookup-variable-value)
|
||||
- [`env:add-binding-to-frame! `](#envadd-binding-to-frame)
|
||||
- [`env:all-values `](#envall-values)
|
||||
- [`env:all-variables `](#envall-variables)
|
||||
- [`env:define-variable! `](#envdefine-variable)
|
||||
- [`env:enclosing-environment `](#envenclosing-environment)
|
||||
- [`env:extend-environment `](#envextend-environment)
|
||||
- [`env:first-frame `](#envfirst-frame)
|
||||
- [`env:frame-values `](#envframe-values)
|
||||
- [`env:frame-variables `](#envframe-variables)
|
||||
- [`env:lookup `](#envlookup)
|
||||
- [`env:lookup-variable-value `](#envlookup-variable-value)
|
||||
- [`env:make-frame `](#envmake-frame)
|
||||
- [`env:set-variable-value! `](#envset-variable-value)
|
||||
- [`env:the-empty-environment `](#envthe-empty-environment)
|
||||
- [`filter `](#filter)
|
||||
- [`flatten `](#flatten)
|
||||
- [`formals->list `](#formals-list)
|
||||
- [`gensym `](#gensym)
|
||||
- [`identifier->symbol `](#identifier-symbol)
|
||||
- [`identifier=? `](#identifier)
|
||||
- [`identifier? `](#identifier-1)
|
||||
- [`if->condition `](#if-condition)
|
||||
- [`if->else `](#if-else)
|
||||
- [`if->then `](#if-then)
|
||||
- [`if-else? `](#if-else)
|
||||
- [`if? `](#if)
|
||||
- [`lambda->exp `](#lambda-exp)
|
||||
- [`lambda->formals `](#lambda-formals)
|
||||
- [`lambda-formals->list `](#lambda-formals-list)
|
||||
- [`lambda-formals-type `](#lambda-formals-type)
|
||||
- [`lambda-varargs-var `](#lambda-varargs-var)
|
||||
- [`lambda-varargs? `](#lambda-varargs)
|
||||
- [`lambda? `](#lambda)
|
||||
- [`length/obj `](#lengthobj)
|
||||
- [`list-index2 `](#list-index2)
|
||||
- [`list-insert-at! `](#list-insert-at)
|
||||
- [`list-prefix? `](#list-prefix)
|
||||
- [`mangle `](#mangle)
|
||||
- [`mangle-global `](#mangle-global)
|
||||
- [`pack-lambda-arguments `](#pack-lambda-arguments)
|
||||
- [`pair->list `](#pair-list)
|
||||
- [`quote? `](#quote)
|
||||
- [`ref? `](#ref)
|
||||
- [`set!->exp `](#set-exp)
|
||||
- [`set!->var `](#set-var)
|
||||
- [`set!? `](#set)
|
||||
- [`string-replace-all `](#string-replace-all)
|
||||
- [`tagged-list? `](#tagged-list?)
|
||||
- [`take `](#take)
|
||||
|
||||
#Cyc-er-compare?
|
||||
#Cyc-er-rename
|
||||
#app?
|
||||
#begin?
|
||||
#const?
|
||||
#define->exp
|
||||
#define->var
|
||||
#define-c?
|
||||
#define?
|
||||
#delete
|
||||
#delete-duplicates
|
||||
#env:\_lookup-variable-value
|
||||
#env:add-binding-to-frame!
|
||||
#env:all-values
|
||||
#env:all-variables
|
||||
#env:define-variable!
|
||||
#env:enclosing-environment
|
||||
#env:extend-environment
|
||||
#env:first-frame
|
||||
#env:frame-values
|
||||
#env:frame-variables
|
||||
#env:lookup
|
||||
#env:lookup-variable-value
|
||||
#env:make-frame
|
||||
#env:set-variable-value!
|
||||
#env:the-empty-environment
|
||||
#filter
|
||||
#flatten
|
||||
#formals->list
|
||||
#gensym
|
||||
#identifier->symbol
|
||||
#identifier=?
|
||||
#identifier?
|
||||
#if->condition
|
||||
#if->else
|
||||
#if->then
|
||||
#if-else?
|
||||
#if?
|
||||
#lambda->exp
|
||||
#lambda->formals
|
||||
#lambda-formals->list
|
||||
#lambda-formals-type
|
||||
#lambda-varargs-var
|
||||
#lambda-varargs?
|
||||
#lambda?
|
||||
#length/obj
|
||||
#list-index2
|
||||
#list-insert-at!
|
||||
#list-prefix?
|
||||
#mangle
|
||||
#mangle-global
|
||||
#pack-lambda-arguments
|
||||
#pair->list
|
||||
#quote?
|
||||
#ref?
|
||||
#set!->exp
|
||||
#set!->var
|
||||
#set!?
|
||||
#string-replace-all
|
||||
#tagged-list?
|
||||
#take
|
||||
37
docs/api/scheme/eval.md
Normal file
37
docs/api/scheme/eval.md
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Eval Library
|
||||
|
||||
The `(scheme eval)` library exports procedures for evaluating Scheme data as programs.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`eval`] (#eval)
|
||||
- [`create-environment`](#create-environment)
|
||||
- [`setup-environment`] (#setup-environment)
|
||||
|
||||
#eval
|
||||
|
||||
(eval expr . environment)
|
||||
|
||||
Evaluate `expr` in the specified environment and return the resulting value(s).
|
||||
|
||||
A non-standard extension is provided to supply a default global environment if the `environment` argument is not specified.
|
||||
|
||||
#create-environment
|
||||
|
||||
(create-environment vars values)
|
||||
|
||||
A non-standard function to create a new environment on top of the default one.
|
||||
|
||||
`vars` is a list of identifiers in the new environment, and `values` is a list of each value assigned to each identifier.
|
||||
|
||||
#setup-environment
|
||||
|
||||
|
||||
(setup-environment)
|
||||
|
||||
A non-standard function to initialize a new global environment.
|
||||
39
docs/api/scheme/file.md
Normal file
39
docs/api/scheme/file.md
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# File Library
|
||||
|
||||
The `(scheme file)` library provides procedures for accessing files.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`call-with-input-file` ](#call-with-input-file)
|
||||
- [`call-with-output-file`](#call-with-output-file)
|
||||
- [`with-input-from-file`](#with-input-from-file)
|
||||
- [`with-output-to-file`](#with-output-to-file)
|
||||
|
||||
#call-with-input-file
|
||||
|
||||
(call-with-input-file string proc)
|
||||
|
||||
Open given filename for input, pass the resulting port to `proc`, and close the port after `proc` returns.
|
||||
|
||||
#call-with-output-file
|
||||
|
||||
(call-with-output-file string proc)
|
||||
|
||||
Open given filename for output, pass the resulting port to `proc`, and close the port after `proc` returns.
|
||||
|
||||
#with-input-from-file
|
||||
|
||||
(with-input-from-file string thunk)
|
||||
|
||||
Open given filename for input and change the current input to that port for the duration of `thunk`.
|
||||
|
||||
#with-output-to-file
|
||||
|
||||
(with-output-to-file string thunk)
|
||||
|
||||
Open given filename for output and change the current output to that port for the duration of `thunk`.
|
||||
72
docs/api/scheme/inexact.md
Normal file
72
docs/api/scheme/inexact.md
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Inexact Library
|
||||
|
||||
The `(scheme inexact)` library exports procedures which are typically only useful with inexact values.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`acos`](#acos)
|
||||
- [`asin`](#asin)
|
||||
- [`atan`](#atan)
|
||||
- [`cos`](#cos)
|
||||
- [`exp`](#exp)
|
||||
- [`finite?`](#finite)
|
||||
- [`infinite?`](#infinite)
|
||||
- [`log`](#log)
|
||||
- [`nan?`](#nan)
|
||||
- [`sin`](#sin)
|
||||
- [`sqrt`](#sqrt)
|
||||
- [`tan`](#tan)
|
||||
|
||||
#acos
|
||||
|
||||
(acos z)
|
||||
|
||||
#asin
|
||||
|
||||
(asin z)
|
||||
|
||||
#atan
|
||||
|
||||
(atan z)
|
||||
|
||||
#cos
|
||||
|
||||
(cos z)
|
||||
|
||||
#exp
|
||||
|
||||
(exp z)
|
||||
|
||||
#finite?
|
||||
|
||||
(finite? z)
|
||||
|
||||
#infinite?
|
||||
|
||||
(infinite? z)
|
||||
|
||||
#log
|
||||
|
||||
(log z)
|
||||
|
||||
#nan?
|
||||
|
||||
(nan? z)
|
||||
|
||||
#sin
|
||||
|
||||
(sin z)
|
||||
|
||||
#sqrt
|
||||
|
||||
(sqrt z)
|
||||
|
||||
#tan
|
||||
|
||||
(tan z)
|
||||
|
||||
44
docs/api/scheme/lazy.md
Normal file
44
docs/api/scheme/lazy.md
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Lazy Library
|
||||
|
||||
The `(scheme lazy)` library exports procedures and syntax keywords for lazy evaluation.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`delay`](#delay)
|
||||
- [`force`](#force)
|
||||
- [`delay-force`](#delay-force)
|
||||
- [`make-promise`](#make-promise)
|
||||
- [`promise?`](#promise)
|
||||
|
||||
#delay
|
||||
|
||||
(delay {expression})
|
||||
|
||||
Return a promise object that can be asked in the future (via `force`) to evaluate `{expression}` and return the result.
|
||||
|
||||
#force
|
||||
|
||||
(force promise)
|
||||
|
||||
Force the value of a promise.
|
||||
|
||||
#delay-force
|
||||
|
||||
(delay-force {expression})
|
||||
|
||||
#make-promise
|
||||
|
||||
(make-promise obj)
|
||||
|
||||
Return a promise which will return `obj` when forced. This function is similar to delay but does not delay its argument: it is a procedure rather than syntax. If `obj` is already a promise, it is returned.
|
||||
|
||||
#promise
|
||||
|
||||
(promise? obj)
|
||||
|
||||
Returns `#t` if object is a promise, and `#f` otherwise.
|
||||
20
docs/api/scheme/load.md
Normal file
20
docs/api/scheme/load.md
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Load Library
|
||||
|
||||
The `(scheme load)` library exports procedures for loading Scheme expressions from files.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`load`](#load)
|
||||
|
||||
#load
|
||||
|
||||
(load filename)
|
||||
|
||||
The `load` procedure reads expressions and definitions from the file and evaluates them sequentially.
|
||||
|
||||
Note that when using `load` in a compiled program, the file will be processed at runtime using `eval`. The file contents will not be compiled.
|
||||
40
docs/api/scheme/process-context.md
Normal file
40
docs/api/scheme/process-context.md
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Process-Context Library
|
||||
|
||||
The `(scheme process-context)` library exports procedures for accessing with the program's calling context.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`command-line`](#command-line)
|
||||
- [`emergency-exit`](#emergency-exit)
|
||||
- [`get-environment-variable`](#get-environment-variable)
|
||||
- [`get-environment-variables`](#get-environment-variables)
|
||||
|
||||
#command-line
|
||||
|
||||
(command-line)
|
||||
|
||||
Returns the command line passed to the program as a list of strings.
|
||||
|
||||
#emergency-exit
|
||||
|
||||
(emergency-exit)
|
||||
|
||||
Terminates the program immediately. This is an alias of `exit`.
|
||||
|
||||
#get-environment-variable
|
||||
|
||||
(get-environment-variable name)
|
||||
|
||||
Return the value of the given environment variable.
|
||||
|
||||
#get-environment-variables
|
||||
|
||||
(get-environment-variables)
|
||||
|
||||
Return a list of all the environment variables and their values.
|
||||
|
||||
27
docs/api/scheme/read.md
Normal file
27
docs/api/scheme/read.md
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Read Library
|
||||
|
||||
The `(scheme read)` library provides procedures for reading Scheme objects.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`read`](#read)
|
||||
- [`read-all`](#read-all)
|
||||
|
||||
#read
|
||||
|
||||
(read)
|
||||
(read port)
|
||||
|
||||
Read a single Scheme object from the input port.
|
||||
|
||||
#read-all
|
||||
|
||||
(read-all)
|
||||
(read-all port)
|
||||
|
||||
Read all objects from a port and return them as a list.
|
||||
32
docs/api/scheme/time.md
Normal file
32
docs/api/scheme/time.md
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Time Library
|
||||
|
||||
The `(scheme time)` library provides access to time-related values.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`current-jiffy`](#current-jiffy)
|
||||
- [`current-second`](#current-second)
|
||||
- [`jiffies-per-second`](#jiffies-per-second)
|
||||
|
||||
#current-jiffy
|
||||
|
||||
(current-jiffy)
|
||||
|
||||
Get the number of jiffies since the program started. This function can return the same value if the program runs longer than approximately 72 minutes on a 32-bit platform.
|
||||
|
||||
#current-second
|
||||
|
||||
(current-second)
|
||||
|
||||
Get the current number of seconds since the UNIX epoch.
|
||||
|
||||
#jiffies-per-second
|
||||
|
||||
(jiffies-per-second)
|
||||
|
||||
The number of jiffies per second.
|
||||
40
docs/api/scheme/write.md
Normal file
40
docs/api/scheme/write.md
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# Write Library
|
||||
|
||||
The `(scheme write)` library provides procedures for writing Scheme objects.
|
||||
|
||||
For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.pdf).
|
||||
|
||||
- [`display`](#display)
|
||||
- [`write`](#write)
|
||||
- [`write-simple`](#write-simple)
|
||||
- [`write-shared`](#write-shared)
|
||||
|
||||
#display
|
||||
|
||||
(display obj)
|
||||
(display obj port)
|
||||
|
||||
Write object to the given output port, or the current output if none is given. Strings and characters are output using only the characters that they represent, without any enclosing quotes, etc.
|
||||
|
||||
#write
|
||||
|
||||
(write obj)
|
||||
(write obj port)
|
||||
|
||||
Write object to the given output port, or the current output if none is given. Objects are written exactly as they are represented in code.
|
||||
|
||||
|
||||
#write-shared
|
||||
|
||||
(write-shared obj)
|
||||
(write-shared obj port)
|
||||
|
||||
#write-simple
|
||||
|
||||
(write-simple obj)
|
||||
(write-simple obj port)
|
||||
215
docs/api/srfi/1.md
Normal file
215
docs/api/srfi/1.md
Normal file
|
|
@ -0,0 +1,215 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 1 - List library
|
||||
|
||||
The `(srfi 1)` provides a coherent and comprehensive set of list-processing procedures.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-1/srfi-1.html) for more information.
|
||||
|
||||
- [`xcons`](#xcons)
|
||||
- [`tree-copy`](#tree-copy)
|
||||
- [`make-list`](#make-list)
|
||||
- [`list-tabulate`](#list-tabulate)
|
||||
- [`cons*`](#cons)
|
||||
- [`list-copy`](#list-copy)
|
||||
- [`proper-list?`](#proper-list)
|
||||
- [`circular-list?`](#circular-list)
|
||||
- [`dotted-list?`](#dotted-list)
|
||||
- [`not-pair?`](#not-pair)
|
||||
- [`null-list?`](#null-list)
|
||||
- [`list=`](#list=)
|
||||
- [`circular-list`](#circular-list-1)
|
||||
- [`length+`](#length)
|
||||
- [`iota`](#iota)
|
||||
- [`first`](#first)
|
||||
- [`second`](#second)
|
||||
- [`third`](#third)
|
||||
- [`fourth`](#fourth)
|
||||
- [`fifth`](#fifth)
|
||||
- [`sixth`](#sixth)
|
||||
- [`seventh`](#seventh)
|
||||
- [`eighth`](#eighth)
|
||||
- [`ninth`](#ninth)
|
||||
- [`tenth`](#tenth)
|
||||
- [`car+cdr`](#carcdr)
|
||||
- [`take`](#take)
|
||||
- [`drop`](#drop)
|
||||
- [`take-right`](#take-right)
|
||||
- [`drop-right`](#drop-right)
|
||||
- [`take!`](#take-1)
|
||||
- [`drop-right!`](#drop-right-1)
|
||||
- [`split-at`](#split-at)
|
||||
- [`split-at!`](#split-at-1)
|
||||
- [`last`](#last)
|
||||
- [`last-pair`](#last-pair)
|
||||
- [`zip`](#zip)
|
||||
- [`unzip1`](#unzip1)
|
||||
- [`unzip2`](#unzip2)
|
||||
- [`unzip3`](#unzip3)
|
||||
- [`unzip4`](#unzip4)
|
||||
- [`unzip5`](#unzip5)
|
||||
- [`count`](#count)
|
||||
- [`append!`](#append)
|
||||
- [`append-reverse`](#append-reverse)
|
||||
- [`append-reverse!`](#append-reverse-1)
|
||||
- [`concatenate`](#concatenate)
|
||||
- [`concatenate!`](#concatenate-1)
|
||||
- [`unfold`](#unfold)
|
||||
- [`fold`](#fold)
|
||||
- [`pair-fold`](#pair-fold)
|
||||
- [`reduce`](#reduce)
|
||||
- [`unfold-right`](#unfold-right)
|
||||
- [`fold-right`](#fold-right)
|
||||
- [`pair-fold-right`](#pair-fold-right)
|
||||
- [`reduce-right`](#reduce-right)
|
||||
- [`append-map`](#append-map)
|
||||
- [`append-map!`](#append-map-1)
|
||||
- [`map!`](#map)
|
||||
- [`pair-for-each`](#pair-for-each)
|
||||
- [`filter-map`](#filter-map)
|
||||
- [`map-in-order`](#map-in-order)
|
||||
- [`filter`](#filter)
|
||||
- [`partition`](#partition)
|
||||
- [`remove`](#remove)
|
||||
- [`filter!`](#filter-1)
|
||||
- [`partition!`](#partition-1)
|
||||
- [`remove!`](#remove-1)
|
||||
- [`find`](#find)
|
||||
- [`find-tail`](#find-tail)
|
||||
- [`any`](#any)
|
||||
- [`every`](#every)
|
||||
- [`list-index`](#list-index)
|
||||
- [`take-while`](#take-while)
|
||||
- [`drop-while`](#drop-while)
|
||||
- [`take-while!`](#take-while-1)
|
||||
- [`span`](#span)
|
||||
- [`break`](#break)
|
||||
- [`span!`](#span-1)
|
||||
- [`break!`](#break-1)
|
||||
- [`delete`](#delete)
|
||||
- [`delete!`](#delete-1)
|
||||
- [`alist-cons`](#alist-cons)
|
||||
- [`alist-copy`](#alist-copy)
|
||||
- [`delete-duplicates`](#delete-duplicates)
|
||||
- [`delete-duplicates!`](#delete-duplicates-1)
|
||||
- [`alist-delete`](#alist-delete)
|
||||
- [`alist-delete!`](#alist-delete-1)
|
||||
- [`reverse!`](#reverse)
|
||||
- [`lset<=`](#lset)
|
||||
- [`lset=`](#lset-1)
|
||||
- [`lset-adjoin`](#lset-adjoin)
|
||||
- [`lset-union`](#lset-union)
|
||||
- [`lset-intersection`](#lset-intersection)
|
||||
- [`lset-difference`](#lset-difference)
|
||||
- [`lset-xor`](#lset-xor)
|
||||
- [`lset-diff+intersection`](#lset-diffintersection)
|
||||
- [`lset-union!`](#lset-union)
|
||||
- [`lset-intersection!`](#lset-intersection-1)
|
||||
- [`lset-difference!`](#lset-difference-1)
|
||||
- [`lset-xor!`](#lset-xor-1)
|
||||
|
||||
#xcons
|
||||
#tree-copy
|
||||
#make-list
|
||||
#list-tabulate
|
||||
#cons*
|
||||
#list-copy
|
||||
#proper-list?
|
||||
#circular-list?
|
||||
#dotted-list?
|
||||
#not-pair?
|
||||
#null-list?
|
||||
#list=
|
||||
#circular-list
|
||||
#length+
|
||||
#iota
|
||||
#first
|
||||
#second
|
||||
#third
|
||||
#fourth
|
||||
#fifth
|
||||
#sixth
|
||||
#seventh
|
||||
#eighth
|
||||
#ninth
|
||||
#tenth
|
||||
#car+cdr
|
||||
#take
|
||||
#drop
|
||||
#take-right
|
||||
#drop-right
|
||||
#take!
|
||||
#drop-right!
|
||||
#split-at
|
||||
#split-at!
|
||||
#last
|
||||
#last-pair
|
||||
#zip
|
||||
#unzip1
|
||||
#unzip2
|
||||
#unzip3
|
||||
#unzip4
|
||||
#unzip5
|
||||
#count
|
||||
#append!
|
||||
#append-reverse
|
||||
#append-reverse!
|
||||
#concatenate
|
||||
#concatenate!
|
||||
#unfold
|
||||
#fold
|
||||
#pair-fold
|
||||
#reduce
|
||||
#unfold-right
|
||||
#fold-right
|
||||
#pair-fold-right
|
||||
#reduce-right
|
||||
#append-map
|
||||
#append-map!
|
||||
#map!
|
||||
#pair-for-each
|
||||
#filter-map
|
||||
#map-in-order
|
||||
#filter
|
||||
#partition
|
||||
#remove
|
||||
#filter!
|
||||
#partition!
|
||||
#remove!
|
||||
#find
|
||||
#find-tail
|
||||
#any
|
||||
#every
|
||||
#list-index
|
||||
#take-while
|
||||
#drop-while
|
||||
#take-while!
|
||||
#span
|
||||
#break
|
||||
#span!
|
||||
#break!
|
||||
#delete
|
||||
#delete!
|
||||
#alist-cons
|
||||
#alist-copy
|
||||
#delete-duplicates
|
||||
#delete-duplicates!
|
||||
#alist-delete
|
||||
#alist-delete!
|
||||
#reverse!
|
||||
#lset<=
|
||||
#lset=
|
||||
#lset-adjoin
|
||||
#lset-union
|
||||
#lset-intersection
|
||||
#lset-difference
|
||||
#lset-xor
|
||||
#lset-diff+intersection
|
||||
#lset-union!
|
||||
#lset-intersection!
|
||||
#lset-difference!
|
||||
#lset-xor!
|
||||
|
||||
88
docs/api/srfi/106.md
Normal file
88
docs/api/srfi/106.md
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 106 - Basic socket interface
|
||||
|
||||
The `(srfi 106)` library provides a basic socket interface.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-106/srfi-106.html) for more information.
|
||||
|
||||
- [`make-client-socket`](#make-client-socket)
|
||||
- [`make-server-socket`](#make-server-socket)
|
||||
- [`socket?`](#socket)
|
||||
- [`socket-accept`](#socket-accept)
|
||||
- [`socket-send`](#socket-send)
|
||||
- [`socket-recv`](#socket-recv)
|
||||
- [`socket-shutdown`](#socket-shutdown)
|
||||
- [`socket-close`](#socket-close)
|
||||
- [`socket-input-port`](#socket-input-port)
|
||||
- [`socket-output-port`](#socket-output-port)
|
||||
- [`call-with-socket`](#call-with-socket)
|
||||
- [`address-family`](#address-family)
|
||||
- [`address-info`](#address-info)
|
||||
- [`socket-domain`](#socket-domain)
|
||||
- [`ip-protocol`](#ip-protocol)
|
||||
- [`message-type`](#message-type)
|
||||
- [`shutdown-method`](#shutdown-method)
|
||||
- [`socket-merge-flags`](#socket-merge-flags)
|
||||
- [`socket-purge-flags`](#socket-purge-flags)
|
||||
- [`*af-unspec*`](#af-unspec)
|
||||
- [`*af-inet*`](#af-inet)
|
||||
- [`*af-inet6*`](#af-inet6)
|
||||
- [`*sock-stream*`](#sock-stream)
|
||||
- [`*sock-dgram*`](#sock-dgram)
|
||||
- [`*ai-canonname*`](#ai-canonname)
|
||||
- [`*ai-numerichost*`](#ai-numerichost)
|
||||
- [`*ai-v4mapped*`](#ai-v4mapped)
|
||||
- [`*ai-all*`](#ai-all)
|
||||
- [`*ai-addrconfig*`](#ai-addrconfig)
|
||||
- [`*ipproto-ip*`](#ipproto-ip)
|
||||
- [`*ipproto-tcp*`](#ipproto-tcp)
|
||||
- [`*ipproto-udp*`](#ipproto-udp)
|
||||
- [`*msg-peek*`](#msg-peek)
|
||||
- [`*msg-oob*`](#msg-oob)
|
||||
- [`*msg-waitall*`](#msg-waitall)
|
||||
- [`*shut-rd*`](#shut-rd)
|
||||
- [`*shut-wr*`](#shut-wr)
|
||||
- [`*shut-rdwr*`](#shut-rdwr)
|
||||
|
||||
#make-client-socket
|
||||
#make-server-socket
|
||||
#socket?
|
||||
#socket-accept
|
||||
#socket-send
|
||||
#socket-recv
|
||||
#socket-shutdown
|
||||
#socket-close
|
||||
#socket-input-port
|
||||
#socket-output-port
|
||||
#call-with-socket
|
||||
#address-family
|
||||
#address-info
|
||||
#socket-domain
|
||||
#ip-protocol
|
||||
#message-type
|
||||
#shutdown-method
|
||||
#socket-merge-flags
|
||||
#socket-purge-flags
|
||||
#\*af-unspec\*
|
||||
#\*af-inet\*
|
||||
#\*af-inet6\*
|
||||
#\*sock-stream\*
|
||||
#\*sock-dgram\*
|
||||
#\*ai-canonname\*
|
||||
#\*ai-numerichost\*
|
||||
#\*ai-v4mapped\*
|
||||
#\*ai-all\*
|
||||
#\*ai-addrconfig\*
|
||||
#\*ipproto-ip\*
|
||||
#\*ipproto-tcp\*
|
||||
#\*ipproto-udp\*
|
||||
#\*msg-peek\*
|
||||
#\*msg-oob\*
|
||||
#\*msg-waitall\*
|
||||
#\*shut-rd\*
|
||||
#\*shut-wr\*
|
||||
#\*shut-rdwr\*
|
||||
29
docs/api/srfi/111.md
Normal file
29
docs/api/srfi/111.md
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 111 - Boxes
|
||||
|
||||
The `(srfi 111)` library defines boxes, a container for an object of any Scheme type, including another box. Boxes are normally used as minimal mutable storage, and can inject a controlled amount of mutability into an otherwise immutable data structure (or one that is conventionally treated as immutable).
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-111/srfi-111.html) for more information.
|
||||
|
||||
- [`box`] (#box)
|
||||
- [`box?`] (#box-1)
|
||||
- [`unbox`] (#unbox)
|
||||
- [`set-box!`](#set-box)
|
||||
|
||||
#box
|
||||
(box value)
|
||||
Constructor. Returns a newly allocated box initialized to value.
|
||||
#box?
|
||||
(box? object)
|
||||
Predicate. Returns #t if object is a box, and #f otherwise.
|
||||
#unbox
|
||||
(unbox box)
|
||||
Accessor. Returns the current value of box.
|
||||
#set-box!
|
||||
(set-box! box value)
|
||||
Mutator. Changes box to hold value.
|
||||
|
||||
64
docs/api/srfi/117.md
Normal file
64
docs/api/srfi/117.md
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 117 - Queues based on lists
|
||||
|
||||
The `(srfi 117)` library defines list queues; mutable ordered collections that can contain any Scheme object. Each list queue is based on an ordinary Scheme list containing the elements of the list queue by maintaining pointers to the first and last pairs of the list. It's cheap to add or remove elements from the front of the list or to add elements to the back, but not to remove elements from the back.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-117/srfi-117.html) for more information.
|
||||
|
||||
- [`make-list-queue`](#make-list-queue)
|
||||
- [`list-queue`](#list-queue)
|
||||
- [`list-queue-copy`](#list-queue-copy)
|
||||
- [`list-queue-unfold`](#list-queue-unfold)
|
||||
- [`list-queue-unfold-right`](#list-queue-unfold-right)
|
||||
- [`list-queue?`](#list-queue-1)
|
||||
- [`list-queue-empty?`](#list-queue-empty)
|
||||
- [`list-queue-front`](#list-queue-front)
|
||||
- [`list-queue-back`](#list-queue-back)
|
||||
- [`list-queue-list`](#list-queue-list)
|
||||
- [`list-queue-first-last`](#list-queue-first-last)
|
||||
- [`list-queue-add-front!`](#list-queue-add-front)
|
||||
- [`list-queue-add-back!`](#list-queue-add-back)
|
||||
- [`list-queue-remove-front!`](#list-queue-remove-front)
|
||||
- [`list-queue-remove-back!`](#list-queue-remove-back)
|
||||
- [`list-queue-remove-all!`](#list-queue-remove-all)
|
||||
- [`list-queue-set-list!`](#list-queue-set-list)
|
||||
- [`list-queue-append`](#list-queue-append)
|
||||
- [`list-queue-append!`](#list-queue-append-1)
|
||||
- [`list-queue-concatenate`](#list-queue-concatenate)
|
||||
- [`list-queue-append`](#list-queue-append)
|
||||
- [`list-queue-append!`](#list-queue-append-1)
|
||||
- [`list-queue-concatenate`](#list-queue-concatenate)
|
||||
- [`list-queue-map`](#list-queue-map)
|
||||
- [`list-queue-map!`](#list-queue-map-1)
|
||||
- [`list-queue-for-each`](#list-queue-for-each)
|
||||
|
||||
#make-list-queue
|
||||
#list-queue
|
||||
#list-queue-copy
|
||||
#list-queue-unfold
|
||||
#list-queue-unfold-right
|
||||
#list-queue?
|
||||
#list-queue-empty?
|
||||
#list-queue-front
|
||||
#list-queue-back
|
||||
#list-queue-list
|
||||
#list-queue-first-last
|
||||
#list-queue-add-front!
|
||||
#list-queue-add-back!
|
||||
#list-queue-remove-front!
|
||||
#list-queue-remove-back!
|
||||
#list-queue-remove-all!
|
||||
#list-queue-set-list!
|
||||
#list-queue-append
|
||||
#list-queue-append!
|
||||
#list-queue-concatenate
|
||||
#list-queue-append
|
||||
#list-queue-append!
|
||||
#list-queue-concatenate
|
||||
#list-queue-map
|
||||
#list-queue-map!
|
||||
#list-queue-for-each
|
||||
48
docs/api/srfi/132.md
Normal file
48
docs/api/srfi/132.md
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 132 - Sort Libraries
|
||||
|
||||
The `(srfi 132)` library implements the the API for a full-featured sort toolkit.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-132/srfi-132.html) for more information.
|
||||
|
||||
- [`list-sorted?`](#list-sorted)
|
||||
- [`vector-sorted?`](#vector-sorted)
|
||||
- [`list-merge`](#list-merge)
|
||||
- [`vector-merge`](#vector-merge)
|
||||
- [`list-sort`](#list-sort)
|
||||
- [`vector-sort`](#vector-sort)
|
||||
- [`list-stable-sort`](#list-stable-sort)
|
||||
- [`vector-stable-sort`](#vector-stable-sort)
|
||||
- [`list-merge!`](#list-merge-1)
|
||||
- [`vector-merge!`](#vector-merge-1)
|
||||
- [`list-sort!`](#list-sort-1)
|
||||
- [`vector-sort!`](#vector-sort-1)
|
||||
- [`list-stable-sort!`](#list-stable-sort)
|
||||
- [`vector-stable-sort!`](#vector-stable-sort)
|
||||
- [`list-delete-neighbor-dups`](#list-delete-neighbor-dups)
|
||||
- [`vector-delete-neighbor-dups`](#vector-delete-neighbor-dups)
|
||||
- [`list-delete-neighbor-dups!`](#list-delete-neighbor-dups-1)
|
||||
- [`vector-delete-neighbor-dups!`](#vector-delete-neighbor-dups-1)
|
||||
|
||||
#list-sorted?
|
||||
#vector-sorted?
|
||||
#list-merge
|
||||
#vector-merge
|
||||
#list-sort
|
||||
#vector-sort
|
||||
#list-stable-sort
|
||||
#vector-stable-sort
|
||||
#list-merge!
|
||||
#vector-merge!
|
||||
#list-sort!
|
||||
#vector-sort!
|
||||
#list-stable-sort!
|
||||
#vector-stable-sort!
|
||||
#list-delete-neighbor-dups
|
||||
#vector-delete-neighbor-dups
|
||||
#list-delete-neighbor-dups!
|
||||
#vector-delete-neighbor-dups!
|
||||
66
docs/api/srfi/133.md
Normal file
66
docs/api/srfi/133.md
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 133 - Sort Libraries
|
||||
|
||||
The `(srfi 133)` provides a vector library.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-133/srfi-133.html) for more information.
|
||||
|
||||
- [`vector-unfold`](#vector-unfold)
|
||||
- [`vector-unfold-right`](#vector-unfold-right)
|
||||
- [`vector-reverse-copy`](#vector-reverse-copy)
|
||||
- [`vector-concatenate`](#vector-concatenate)
|
||||
- [`vector-append-subvectors`](#vector-append-subvectors)
|
||||
- [`vector-empty?`](#vector-empty)
|
||||
- [`vector=`](#vector)
|
||||
- [`vector-fold`](#vector-fold)
|
||||
- [`vector-fold-right`](#vector-fold-right)
|
||||
- [`vector-map!`](#vector-map)
|
||||
- [`vector-count`](#vector-count)
|
||||
- [`vector-cumulate`](#vector-cumulate)
|
||||
- [`vector-index`](#vector-index)
|
||||
- [`vector-index-right`](#vector-index-right)
|
||||
- [`vector-skip`](#vector-skip)
|
||||
- [`vector-skip-right`](#vector-skip-right)
|
||||
- [`vector-binary-search`](#vector-binary-search)
|
||||
- [`vector-any`](#vector-any)
|
||||
- [`vector-every`](#vector-every)
|
||||
- [`vector-partition`](#vector-partition)
|
||||
- [`vector-swap!`](#vector-swap)
|
||||
- [`vector-reverse!`](#vector-reverse)
|
||||
- [`vector-reverse-copy!`](#vector-reverse-copy)
|
||||
- [`vector-unfold!`](#vector-unfold)
|
||||
- [`vector-unfold-right!`](#vector-unfold-right)
|
||||
- [`reverse-vector->list`](#reverse-vector-list)
|
||||
- [`reverse-list->vector`](#reverse-list-vector)
|
||||
|
||||
#vector-unfold
|
||||
#vector-unfold-right
|
||||
#vector-reverse-copy
|
||||
#vector-concatenate
|
||||
#vector-append-subvectors
|
||||
#vector-empty?
|
||||
#vector=
|
||||
#vector-fold
|
||||
#vector-fold-right
|
||||
#vector-map!
|
||||
#vector-count
|
||||
#vector-cumulate
|
||||
#vector-index
|
||||
#vector-index-right
|
||||
#vector-skip
|
||||
#vector-skip-right
|
||||
#vector-binary-search
|
||||
#vector-any
|
||||
#vector-every
|
||||
#vector-partition
|
||||
#vector-swap!
|
||||
#vector-reverse!
|
||||
#vector-reverse-copy!
|
||||
#vector-unfold!
|
||||
#vector-unfold-right!
|
||||
#reverse-vector->list
|
||||
#reverse-list->vector
|
||||
100
docs/api/srfi/18.md
Normal file
100
docs/api/srfi/18.md
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 18 - Multithreading support
|
||||
|
||||
The `(srfi 18)` library provides multithreading support.
|
||||
|
||||
See the [Multithreading support SRFI documentation](http://srfi.schemers.org/srfi-18/srfi-18.html) for more information.
|
||||
|
||||
- [`thread?`](#thread)
|
||||
- [`make-thread`](#make-thread)
|
||||
- [`thread-name`](#thread-name)
|
||||
- [`thread-specific`](#thread-specific)
|
||||
- [`thread-specific-set!`](#thread-specific-set)
|
||||
- [`thread-start!`](#thread-start)
|
||||
- [`thread-sleep!`](#thread-sleep)
|
||||
- [`thread-yield!`](#thread-yield)
|
||||
- [`thread-terminate!`](#thread-terminate)
|
||||
- [`mutex?`](#mutex)
|
||||
- [`make-mutex`](#make-mutex)
|
||||
- [`mutex-lock!`](#mutex-lock)
|
||||
- [`mutex-unlock!`](#mutex-unlock)
|
||||
- [`condition-variable?`](#condition-variable)
|
||||
- [`make-condition-variable`](#make-condition-variable)
|
||||
- [`condition-variable-wait!`](#condition-variable-wait)
|
||||
- [`condition-variable-signal!`](#condition-variable-signal)
|
||||
- [`condition-variable-broadcast!`](#condition-variable-broadcast)
|
||||
- [`->heap`](#-heap)
|
||||
- [`Cyc-minor-gc`](#Cyc-minor-gc)
|
||||
|
||||
#thread?
|
||||
(thread? obj)
|
||||
Determine if the given object is a thread object.
|
||||
#make-thread
|
||||
(make-thread thunk)
|
||||
(make-thread thunk name)
|
||||
Create a new thread object.
|
||||
#thread-name
|
||||
(thread-name t) (vector-ref t 3))
|
||||
Retrieve the name of the given thread object.
|
||||
#thread-specific
|
||||
(thread-specific t)
|
||||
Retrieve thread-specific data.
|
||||
#thread-specific-set!
|
||||
(thread-specific-set! t obj)
|
||||
Set thread-specific data.
|
||||
#thread-start!
|
||||
(thread-start! t)
|
||||
Makes thread runnable. The thread must be a new thread. thread-start! returns the thread.
|
||||
#thread-sleep!
|
||||
(thread-sleep! timeout)
|
||||
Block the current thread for `timeout` milliseconds.
|
||||
#thread-yield!
|
||||
(thread-yield!) (thread-sleep! 1))
|
||||
The current thread exits the running state as if its quantum had expired.
|
||||
#thread-terminate!
|
||||
(thread-terminate!
|
||||
Immediately abort the current thread.
|
||||
#mutex?
|
||||
(mutex? obj)
|
||||
Determine if the given object is a mutex.
|
||||
#make-mutex
|
||||
(make-mutex)
|
||||
Create a new mutex object.
|
||||
|
||||
NOTE: Creates a new mutex by allocating it on the heap. This is different than other types of objects because by definition a mutex will be used by multiple threads, so no need to risk having the non-creating thread pick up a stack object reference by mistake.
|
||||
#mutex-lock!
|
||||
(mutex-lock! mutex)
|
||||
Lock the given mutex if it is unlocked. If the mutex is currently locked, the current thread waits until the mutex is unlocked.
|
||||
#mutex-unlock!
|
||||
(mutex-unlock! mutex)
|
||||
(mutex-unlock! mutex condition-variable)
|
||||
Unlock the given mutex. If there are threads waiting on the mutex, one of those threads will be unblocked. If condition-variable is supplied, the current thread is blocked and added to the condition-variable before unlocking mutex; the thread can unblock at any time but no later than when an appropriate call to condition-variable-signal! or condition-variable-broadcast! is performed (see below). See SRFI documentation for more information on condition variables.
|
||||
#condition-variable?
|
||||
(condition-variable? obj)
|
||||
Determine if the given object is a condition variable.
|
||||
#make-condition-variable
|
||||
(make-condition-variable)
|
||||
Create a new condition variable. Like mutex objects, condition variables are always allocated directly on the heap since they are expected to be shared by more than one thread.
|
||||
#condition-variable-wait!
|
||||
(condition-variable-wait! condition-variable mutex)
|
||||
Wait on a condition variable. The mutex must be locked by the calling thread, and will be locked upon successful return of this function.
|
||||
#condition-variable-signal!
|
||||
(condition-variable-signal! condition-variable)
|
||||
If there are threads blocked on the condition-variable, the scheduler selects a thread and unblocks it.
|
||||
#condition-variable-broadcast!
|
||||
(condition-variable-broadcast! condition-variable)
|
||||
Unblocks all the threads blocked on the condition-variable.
|
||||
#->heap
|
||||
(->heap obj)
|
||||
|
||||
Take a single object and if it is on the stack, return a copy of it that is allocated on the heap. NOTE the original object will still live on the stack, and will eventually be moved itself to the heap if it is referenced during minor GC.
|
||||
|
||||
#Cyc-minor-gc
|
||||
(Cyc-minor-gc)
|
||||
|
||||
Trigger a minor garbage collection. This is potentially useful to evacuate all objects from a thread's stack to the heap. An object must be moved to the heap before it can be safely used by more than one thread.
|
||||
|
||||
28
docs/api/srfi/2.md
Normal file
28
docs/api/srfi/2.md
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 2 - `and-let*`
|
||||
|
||||
The `(srfi 2)` library provides the `and-let*` macro, an `and` with local bindings.
|
||||
|
||||
Like an ordinary `and`, an `and-let*` special form evaluates its arguments -- expressions -- one after another in order, till the first one that yields `#f`. Unlike `and`, however, a non-#f result of one expression can be bound to a fresh variable and used in the subsequent expressions. `and-let*` is a cross-breed between `let*` and `and`.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-2/srfi-2.html) for more information.
|
||||
|
||||
- [`and-let*`](#and-let)
|
||||
|
||||
#and-let*
|
||||
(and-let* (claws) body
|
||||
|
||||
claws ::= '() | (cons claw claws)
|
||||
claw ::= (variable expression) | (expression) |
|
||||
bound-variable
|
||||
|
||||
- The `claws` are evaluated in the strict left-to-right order
|
||||
- For each `claw`, the `expression` part is evaluated first (or `bound-variable` is looked up)
|
||||
- If the result is #f, `and-let*` immediately returns #f
|
||||
- Otherwise, if the `claw` is of the form `(variable expression)` the `expression`'s value is bound to a freshly made `variable`
|
||||
- The `variable` is available for the rest of the `claws` , and the `body`
|
||||
- As usual, all `variable`s must be unique (like in `let*`)
|
||||
49
docs/api/srfi/27.md
Normal file
49
docs/api/srfi/27.md
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 27 - Sources of random bits
|
||||
|
||||
The `(srfi 27)` library provides sources of random bits. See the
|
||||
[SRFI document](http://srfi.schemers.org/srfi-27/srfi-27.html) for
|
||||
more information.
|
||||
|
||||
- [`random-integer`](#random-integer)
|
||||
- [`random-real`](#random-real)
|
||||
- [`default-random-source`](#default-random-source)
|
||||
- [`make-random-source`](#make-random-source)
|
||||
- [`random-source?`](#random-source)
|
||||
- [`random-source-state-ref`](#random-source-state-ref)
|
||||
- [`random-source-state-set!`](#random-source-state-set)
|
||||
- [`random-source-randomize!`](#random-source-randomize)
|
||||
- [`random-source-pseudo-randomize!`](#random-source-pseudo-randomize)
|
||||
- [`random-source-make-integers`](#random-source-make-integers)
|
||||
- [`random-source-make-reals`](#random-source-make-reals)
|
||||
|
||||
#random-integer
|
||||
(random-integer n)
|
||||
Return the next integer in {0, ..., n-1}.
|
||||
#random-real
|
||||
(random-real)
|
||||
The next number `x` such that 0 < x 1.
|
||||
#default-random-source
|
||||
A random source from which random-integer and random-real have been derived using random-source-make-integers and random-source-make-reals. Note that an assignment to default-random-source does not change random or random-real; it is also strongly recommended not to assign a new value.
|
||||
#make-random-source
|
||||
(make-random-source)
|
||||
Create a new random source.
|
||||
#random-source?
|
||||
(random-source? obj)
|
||||
Determine if the given object is a random source.
|
||||
#random-source-state-ref
|
||||
(random-source-state-ref s)
|
||||
#random-source-state-set!
|
||||
(random-source-state-set! s state)
|
||||
#random-source-randomize!
|
||||
(random-source-randomize! s)
|
||||
#random-source-pseudo-randomize!
|
||||
(random-source-pseudo-randomize! s i j)
|
||||
#random-source-make-integers
|
||||
(random-source-make-integers s)
|
||||
#random-source-make-reals
|
||||
(random-source-make-reals s)
|
||||
125
docs/api/srfi/69.md
Normal file
125
docs/api/srfi/69.md
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 69 - Basic hash tables
|
||||
|
||||
The `(srfi 69)` library defines basic hash tables.
|
||||
|
||||
Hash tables are widely recognised as a fundamental data structure for a wide variety of applications. A hash table is a data structure that:
|
||||
|
||||
- provides a mapping from some set of keys to some set of values associated to those keys
|
||||
- has no intrinsic order for the (key, value) associations it contains
|
||||
- supports in-place modification as the primary means of setting the contents of a hash table
|
||||
- provides key lookup and destructive update in amortised constant time, provided that a good hash function is used
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-69/srfi-69.html) for more information.
|
||||
|
||||
- [`make-hash-table`](#make-hash-table)
|
||||
- [`hash-table?`](#hash-table)
|
||||
- [`alist->hash-table`](#alist-hash-table)
|
||||
- [`hash-table-equivalence-function`](#hash-table-equivalence-function)
|
||||
- [`hash-table-hash-function`](#hash-table-hash-function)
|
||||
- [`hash-table-ref`](#hash-table-ref)
|
||||
- [`hash-table-ref/default`](#hash-table-refdefault)
|
||||
- [`hash-table-set!`](#hash-table-set)
|
||||
- [`hash-table-delete!`](#hash-table-delete)
|
||||
- [`hash-table-exists?`](#hash-table-exists)
|
||||
- [`hash-table-update!`](#hash-table-update)
|
||||
- [`hash-table-update!/default`](#hash-table-updatedefault)
|
||||
- [`hash-table-size`](#hash-table-size)
|
||||
- [`hash-table-keys`](#hash-table-keys)
|
||||
- [`hash-table-values`](#hash-table-values)
|
||||
- [`hash-table-walk`](#hash-table-walk)
|
||||
- [`hash-table-fold`](#hash-table-fold)
|
||||
- [`hash-table->alist`](#hash-table-alist)
|
||||
- [`hash-table-copy`](#hash-table-copy)
|
||||
- [`hash-table-merge!`](#hash-table-merge)
|
||||
- [`hash`](#hash)
|
||||
- [`string-hash`](#string-hash)
|
||||
- [`string-ci-hash`](#string-ci-hash)
|
||||
- [`hash-by-identity`](#hash-by-identity)
|
||||
|
||||
#make-hash-table
|
||||
(make-hash-table)
|
||||
(make-hash-table equal?)
|
||||
(make-hash-table equal? hash)
|
||||
(make-hash-table equal? hash size)
|
||||
Create a new hash table.
|
||||
#hash-table?
|
||||
(hash-table? obj)
|
||||
Determine if the given object is a hash table.
|
||||
#alist->hash-table
|
||||
(alist->hash-table alist)
|
||||
(alist->hash-table alist equal?)
|
||||
(alist->hash-table alist equal? hash)
|
||||
Convert given association list to a hash table.
|
||||
#hash-table-equivalence-function
|
||||
(hash-table-equivalence-function hash-table)
|
||||
Returns the equivalence predicate used for keys of hash-table.
|
||||
#hash-table-hash-function
|
||||
(hash-table-hash-function hash-table)
|
||||
Returns the hash function used for keys of hash-table.
|
||||
#hash-table-ref
|
||||
(hash-table-ref hash-table key)
|
||||
(hash-table-ref hash-table key thunk)
|
||||
This procedure returns the value associated to key in hash-table. If no value is associated to key and thunk is given, it is called with no arguments and its value is returned.
|
||||
#hash-table-ref/default
|
||||
(hash-table-ref/default hash-table key default)
|
||||
Return the value associated to `key` in the hash table, or `default` if the key is not found.
|
||||
#hash-table-set!
|
||||
(hash-table-set! hash-table key value)
|
||||
Sets the `value` associated to `key` in the given hash table.
|
||||
#hash-table-delete!
|
||||
(hash-table-delete! hash-table key)
|
||||
Removes any value association for `key` in the given hash table.
|
||||
#hash-table-exists?
|
||||
(hash-table-exists? hash-table key)
|
||||
Determines if the given key exists in the hash table.
|
||||
#hash-table-update!
|
||||
(hash-table-update! hash-table key function)
|
||||
(hash-table-update! hash-table key function thunk)
|
||||
#hash-table-update!/default
|
||||
(hash-table-update!/default hash-table key function default)
|
||||
#hash-table-size
|
||||
(hash-table-size hash-table)
|
||||
Return the number of associations in the hash table.
|
||||
#hash-table-keys
|
||||
(hash-table-keys hash-table)
|
||||
Return a list of keys in the hash table.
|
||||
#hash-table-values
|
||||
(hash-table-values hash-table)
|
||||
Return a list of values in the hash table.
|
||||
#hash-table-walk
|
||||
(hash-table-walk hash-table proc)
|
||||
proc should be a function taking two arguments, a key and a value. This procedure calls proc for each association in hash-table, giving the key of the association as key and the value of the association as value. The results of proc are discarded.
|
||||
#hash-table-fold
|
||||
(hash-table-fold hash-table f init-value)
|
||||
This procedure calls f for every association in hash-table with three arguments: the key of the association key, the value of the association value, and an accumulated value, val. val is init-value for the first invocation of f, and for subsequent invocations of f, the return value of the previous invocation of f. The value final-value returned by hash-table-fold is the return value of the last invocation of f.
|
||||
#hash-table->alist
|
||||
(hash-table->alist hash-table)
|
||||
Return an association list using the keys and values from the hash table.
|
||||
#hash-table-copy
|
||||
(hash-table-copy hash-table)
|
||||
Return a new hash table with the same data as the original.
|
||||
#hash-table-merge!
|
||||
(hash-table-merge! hash-table1 hash-table2)
|
||||
Adds all mappings in hash-table2 into hash-table1 and returns the resulting hash table.
|
||||
#hash
|
||||
(hash object)
|
||||
(hash object bound)
|
||||
Return a hash value for object in the range `0` to `bound`.
|
||||
#string-hash
|
||||
(string-hash string)
|
||||
(string-hash string bound)
|
||||
Same as `hash` except the argument must be a string.
|
||||
#string-ci-hash
|
||||
(string-ci-hash string)
|
||||
(string-ci-hash string bound)
|
||||
Case insensitive version of `string-hash`.
|
||||
#hash-by-identity
|
||||
(hash-by-identity object)
|
||||
(hash-by-identity object bound)
|
||||
The same as `hash`, except that this function is only guaranteed to be acceptable for `eq?`.
|
||||
|
||||
10
docs/api/srfi/8.md
Normal file
10
docs/api/srfi/8.md
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
---
|
||||
layout: main
|
||||
title: API
|
||||
---
|
||||
|
||||
# SRFI 8 - Binding to multiple values
|
||||
|
||||
The `(srfi 8)` library provides the `receive` macro to bind variables to multiple values. The macro is actually provided as in the `(scheme base)` library.
|
||||
|
||||
See the [SRFI document](http://srfi.schemers.org/srfi-8/srfi-8.html) for more information.
|
||||
Loading…
Add table
Reference in a new issue