Files
slime/manual/manual.html
T
2019-11-14 00:36:12 +01:00

3237 lines
88 KiB
HTML

<!doctype html>
<html lang="en">
<head>
<title>The Slime 1.0 Manual</title>
<!-- 2019-11-10 So 23:51 -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="generator" content="Org-mode">
<meta name="author" content="Felix Brendel">
<link href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.5/css/bootstrap.min.css" rel="stylesheet">
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.5/js/bootstrap.min.js"></script>
<style type="text/css">
/* org mode styles on top of twbs */
html {
position: relative;
min-height: 100%;
}
body {
font-size: 18px;
margin-bottom: 105px;
}
footer {
position: absolute;
bottom: 0;
width: 100%;
height: 101px;
background-color: #f5f5f5;
}
footer > div {
padding: 10px;
}
footer p {
margin: 0 0 5px;
text-align: center;
font-size: 16px;
}
#table-of-contents {
margin-top: 20px;
margin-bottom: 20px;
}
blockquote p {
font-size: 18px;
}
pre {
font-size: 16px;
}
.footpara {
display: inline-block;
}
figcaption {
font-size: 16px;
color: #666;
font-style: italic;
padding-bottom: 15px;
}
/* from twbs docs */
.bs-docs-sidebar.affix {
position: static;
}
@media (min-width: 768px) {
.bs-docs-sidebar {
padding-left: 20px;
}
}
/* All levels of nav */
.bs-docs-sidebar .nav > li > a {
display: block;
padding: 4px 20px;
font-size: 14px;
font-weight: 500;
color: #999;
}
.bs-docs-sidebar .nav > li > a:hover,
.bs-docs-sidebar .nav > li > a:focus {
padding-left: 19px;
color: #A1283B;
text-decoration: none;
background-color: transparent;
border-left: 1px solid #A1283B;
}
.bs-docs-sidebar .nav > .active > a,
.bs-docs-sidebar .nav > .active:hover > a,
.bs-docs-sidebar .nav > .active:focus > a {
padding-left: 18px;
font-weight: bold;
color: #A1283B;
background-color: transparent;
border-left: 2px solid #A1283B;
}
/* Nav: second level (shown on .active) */
.bs-docs-sidebar .nav .nav {
display: none; /* Hide by default, but at >768px, show it */
padding-bottom: 10px;
}
.bs-docs-sidebar .nav .nav > li > a {
padding-top: 1px;
padding-bottom: 1px;
padding-left: 30px;
font-size: 12px;
font-weight: normal;
}
.bs-docs-sidebar .nav .nav > li > a:hover,
.bs-docs-sidebar .nav .nav > li > a:focus {
padding-left: 29px;
}
.bs-docs-sidebar .nav .nav > .active > a,
.bs-docs-sidebar .nav .nav > .active:hover > a,
.bs-docs-sidebar .nav .nav > .active:focus > a {
padding-left: 28px;
font-weight: 500;
}
/* Nav: third level (shown on .active) */
.bs-docs-sidebar .nav .nav .nav {
padding-bottom: 10px;
}
.bs-docs-sidebar .nav .nav .nav > li > a {
padding-top: 1px;
padding-bottom: 1px;
padding-left: 40px;
font-size: 12px;
font-weight: normal;
}
.bs-docs-sidebar .nav .nav .nav > li > a:hover,
.bs-docs-sidebar .nav .nav .nav > li > a:focus {
padding-left: 39px;
}
.bs-docs-sidebar .nav .nav .nav > .active > a,
.bs-docs-sidebar .nav .nav .nav > .active:hover > a,
.bs-docs-sidebar .nav .nav .nav > .active:focus > a {
padding-left: 38px;
font-weight: 500;
}
/* Show and affix the side nav when space allows it */
@media (min-width: 992px) {
.bs-docs-sidebar .nav > .active > ul {
display: block;
}
/* Widen the fixed sidebar */
.bs-docs-sidebar.affix,
.bs-docs-sidebar.affix-bottom {
width: 213px;
}
.bs-docs-sidebar.affix {
position: fixed; /* Undo the static from mobile first approach */
top: 20px;
}
.bs-docs-sidebar.affix-bottom {
position: absolute; /* Undo the static from mobile first approach */
}
.bs-docs-sidebar.affix .bs-docs-sidenav,.bs-docs-sidebar.affix-bottom .bs-docs-sidenav {
margin-top: 0;
margin-bottom: 0
}
}
@media (min-width: 1200px) {
/* Widen the fixed sidebar again */
.bs-docs-sidebar.affix-bottom,
.bs-docs-sidebar.affix {
width: 263px;
}
}
</style>
<script type="text/javascript">
$(function() {
'use strict';
$('.bs-docs-sidebar li').first().addClass('active');
$(document.body).scrollspy({target: '.bs-docs-sidebar'});
$('.bs-docs-sidebar').affix();
});
</script>
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
displayAlign: "center",
displayIndent: "2em",
messageStyle: "none",
"HTML-CSS": {
scale: 100,
styles: {
".MathJax_Display": {
"font-size": "100%"
}
}
},
"SVG": {
scale: 100,
styles: {
".MathJax_SVG_Display": {
"font-size": "100%",
"margin-left": "-2.281em"
}
}
}
});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_SVG"></script>
</head>
<body>
<div id="content" class="container">
<div class="row"><div class="col-md-12"><h1 class="title">The Slime 1.0 Manual</h1>
<div class="abstract">
<p>
abstract
</p>
</div>
<p>
\tableofcontents
</p>
<div id="outline-container-sec-1" class="outline-2">
<h2 id="sec-1"><span class="section-number-2">1</span> Lisp languages</h2>
<div class="outline-text-2" id="text-1">
<p>
Lisp is not one language but rather a family of programming languages. The family is devided by some
characteristics. There are Lisp-1 and Lisp-2 dialects and there is a difference between a Lisp with
lexical scoping as opposed to dynamic scoping. These differences will be explained in later
sections.
</p>
<p>
Like most Lisps, Slime is dynamically typed. That means that like in statically typed Languages
Slime has different data types, but they are associated not with variables but with the Lisp objects
themselves. Variables can be assigend Lisp objects of any internal type.
</p>
<p>
The Lisp language family is known to be highly flexible and applicable in all areas by creating
domain specific languages in Lisp itself through a powerful macro system. The central data structure
in Lisp is the list. The reason why lisp is so powerful is because the program source code itself is
represented as lists. The nested lists make up the syntax tree of the lisp program. It is therfore
computationally easy to parse lisp programs as the source code itself is already structured in the
form of the syntax tree; allowing for parsing in linear time.
</p>
<p>
The macro system in Slime works by recognizing macros at parse-time and running them, and replacing
the macro call in the program code with the return value of the macro and then checking if further
macros have to be expanded in the replaced code. Therefore the macros can be used to pre-compute
values or rewrite expressions (creating syntactic sugar) or themselves define macros.
</p>
</div>
</div>
<div id="outline-container-sec-2" class="outline-2">
<h2 id="sec-2"><span class="section-number-2">2</span> Lists</h2>
<div class="outline-text-2" id="text-2">
<p>
As mentioned in <a href="#sec-1">Lisp languages</a>, the central data structure in all Lisps is the list. Lists are
implemented as singly linked lists, made up of pairs (historically called <code>cons-cells</code>), each pair
has two slots, the <code>first</code> and the <code>rest</code> (historically <code>car</code> and <code>cdr</code>). A linked lsit ist then
constructed by the convention that the <code>first</code> field of a pair points to the first element of the
list and the <code>rest</code> field points to the rest of the list. Following this description, the list is a
recursive data structure. For the end of the list a special value <code>nil</code> is used in the <code>rest</code> field.
</p>
<p>
A helpful way to visualize lists made up of pairs is using box diagrams. A simple box diagram can be
seen in <a href="#simpleBoxDiagram">1</a>. Each rectangle is divided in two. The left part represents the <code>first</code>
field, the right part represents the <code>rest</code>. The arrows point to the values in these fields.
</p>
<p>
The diagram in <a href="#simpleBoxDiagram">1</a> shows a simple list containing the values 1, 2 and 3. The first pair
stores the number 1 its <code>first</code> field and the <code>rest</code> points to the rest of the list. The last pair
points to the special value <code>nil</code> in its <code>rest</code> to denote the end of the list.
</p>
<p>
<a href="diagrams/list123.eps">diagrams/list123.eps</a>
</p>
<p>
However the <code>rest</code> of a pair needs not to be a pair or nil, it could also point to any other value.
By doing this the list is no longer "well formed" but rather "ill formed". Ill formed lsits can be
used as an optimization when using the list for storing data. In <a href="#illFormedList">2</a> an ill formed list
can be seen, that also contains the values 1, 2 and 3 but stores them using only two pairs instead
of 3.
</p>
<p>
<a href="diagrams/list12.3.eps">diagrams/list12.3.eps</a>
</p>
</div>
<div id="outline-container-sec-2-1" class="outline-3">
<h3 id="sec-2-1"><span class="section-number-3">2.1</span> representing lists in Lisp</h3>
<div class="outline-text-3" id="text-2-1">
<p>
In Slime and in most Lisps, lists are represented using round parenthesis where <code>(</code> denotes the
start of the list and <code>)</code> denotes the end. Eeach element inside these parenthesis separated by one
or more spaces will be interpreted as an element of that list. For example the list from
<a href="#simpleBoxDiagram">1</a> would be represented as <code>(1 2 3)</code>. During parse time, the Lisp parser transforms
the parenthesised list into the pairs that are in the end stored in memory.
</p>
<p>
To also be able to represent ill formed lists in Lisp there is a special syntax using the <code>.</code> (dot
symbol). If the parser encounters a <code>.</code> inside of a list, it will treat the next element as the
<code>rest</code>. If there is no or more than one element after the <code>.</code> an parsing error will be thrown. Using
this syntax we can represent the ill formed list from <a href="#illFormedList">2</a> as <code>(1 2 . 3)</code>. We can also
write well formed lists using the dot notation if we point the rest to another list. So the well
formed list from <a href="#simpleBoxDiagram">1</a> can also be written as \[\texttt{(1 . (2 . (3)))}\]
</p>
</div>
</div>
<div id="outline-container-sec-2-2" class="outline-3">
<h3 id="sec-2-2"><span class="section-number-3">2.2</span> representing function calls in Lisp</h3>
<div class="outline-text-3" id="text-2-2">
<p>
If we tried to enter the Lisp representation of the lists like <code>(1 2 3)</code> discussed in <a href="#sec-2-1">representing lists in Lisp</a> directly into an Lisp interpreter we would get an error. That doesn't mean that the
explanation given in the section is wrong, it is in fact correct: the lisp parser will transform the
lisp syntax into the pairs in memory. The reason we would get an error is, that when reading Lisp
code, the Lisp interpreter first parses the code and then tries to evaluate it and return the result
back to the user.
</p>
<p>
In Lisp by default, a list corresponds to a function call. As mentioned in <a href="#sec-1">Lisp languages</a> Lisp
represents lists and Lisp programms as lists. If a list is treated as a function call, the first
element will be treated as the function and the rest of the elements will be the arguments to that
function. If we would wnter <code>(1 2 3)</code> directly into the Lisp interpreter we would get an error
saying it cannot find the function <code>1</code>.
</p>
<p>
If we would want to compute the sum of the numbers 5 and 3 we could do this by invoking the <code>+</code>
function with 5 and 3 as its arguments. <code>(+ 5 3)</code> will evaluate to 8. We can also nest functions
calls and use the return values as parameters to other functions: <code>(+ (- 12 4) (/ 24 4))</code> will
evaluate to 14. The box diagramm showing the internal structure of that computation can be seen in
<a href="#moreComplexBoxDiagram">3</a>.
</p>
<p>
<a href="diagrams/simpleMath.eps">diagrams/simpleMath.eps</a>
</p>
</div>
</div>
</div>
<div id="outline-container-sec-3" class="outline-2">
<h2 id="sec-3"><span class="section-number-2">3</span> Evaluation order</h2>
<div class="outline-text-2" id="text-3">
<p>
As a first step of evaluation of a regular function, all its arguments are getting evaluated, and
then the function is applied to the evaluated arguments. For example when evaluating the nested
expression in <a href="#code:complex-math">1</a> the outermost function is the <code>+</code> function with three arguments: <code>(*
3 4)</code>, <code>(- 100 (+ 12 13 14 15))</code> and <code>2</code>. So before the outhermost <code>+</code> gets invoked, the three
arguments are getting evaluated recursively.
</p>
<div class="org-src-container">
<label class="org-src-name">A more complex nested arithmetic expression. Nested expressions can be written more readable by aligning subsequent arguments vertically underneeth each other</label>
<pre class="src src-slime" id="code:complex-math"><span style="color: #ff8c00;">(</span><span style="color: #859900;">print</span> <span style="color: #ff1493;">(</span><span style="color: #859900;">+</span> <span style="color: #7fff00;">(</span><span style="color: #859900;">*</span> 3 4<span style="color: #7fff00;">)</span>
<span style="color: #7fff00;">(</span><span style="color: #859900;">-</span> 100 <span style="color: #00bfff;">(</span><span style="color: #859900;">+</span> 12 13 14 15<span style="color: #00bfff;">)</span><span style="color: #7fff00;">)</span>
2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
60
</pre>
</div>
<div id="outline-container-sec-3-1" class="outline-3">
<h3 id="sec-3-1"><span class="section-number-3">3.1</span> Special forms</h3>
<div class="outline-text-3" id="text-3-1">
<p>
The given evaluation rule &#x2013; to evaluate all the arguments first and then allpying them to the
funciton &#x2013; as described in <a href="#sec-3">Evaluation order</a> is only valid for regular functions. There is a class
of functions that do not follow this evaluation rule called <b>special forms</b>. Special forms are
needed when you do not wish to evaluate all arguments. For example the built-in <code>if</code> function should
only evaluate the "then-expression" if the condition evaluates to a truthy value and not otherwise.
Consider the example in <a href="#code:special-forms">2</a>. The if expression only evaluates the then-expression. If
the <code>if</code> function would follow the evaluation order of regular functions, first all three arguments
<code>(&lt; 1 2)</code>, <code>(print "I knew it!!\n")</code> but also <code>(print "Oh, it is not?!\n")</code> could get evaluated and
so both messages would be printed. In the given <code>if</code> expression, the condition evaluates to a truthy
value and only <code>I knew it!!</code> will be printed.
</p>
<div class="org-src-container">
<label class="org-src-name">The <code>if</code> function is a special form because it does not evaluate all of its arguments</label>
<pre class="src src-slime" id="code:special-forms"><span style="color: #ff8c00;">(</span><span style="color: #859900;">if</span> <span style="color: #ff1493;">(</span><span style="color: #859900;">&lt;</span> 1 2<span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"I knew it!!\n"</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"Oh, it is not?!\n"</span><span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
I knew it!!
</pre>
<p>
The programmer can also define their own special forms using <code>special-lambda</code> and macros, which will
be explained in <a href="#sec-6-1">Special lambdas</a> and <a href="#sec-9">Macros</a>.
</p>
</div>
</div>
</div>
<div id="outline-container-sec-4" class="outline-2">
<h2 id="sec-4"><span class="section-number-2">4</span> Symbols and keywords</h2>
</div>
<div id="outline-container-sec-5" class="outline-2">
<h2 id="sec-5"><span class="section-number-2">5</span> Truthyness</h2>
</div>
<div id="outline-container-sec-6" class="outline-2">
<h2 id="sec-6"><span class="section-number-2">6</span> Lambdas</h2>
<div class="outline-text-2" id="text-6">
<p>
Slime allows for creating anonymous functions called <b>lambdas</b>. We did not talk about binding
variables, we will do this in <a href="#sec-7">Define</a>, but we can still use lambdas now. Remember that Lisp
interpretes the first argument of a list in the source code as a function and the rest as the
arguments. The <code>lambda</code> special form evaluates to a <b>regular function object</b> that can then stand in
the first position of the function call list. The basic syntax for the lambda special form is:
\[\texttt{(lambda (arg1 arg2 ...) (body1) ...)}\] the first arguemnt to <code>lambda</code> is a list of the
arguments. All the following arguments will be the body of the lambda. They will be executed when
the lambda is invoked. The return value of a lambda is the value of the last evaluated expression in
the body.
</p>
<p>
Probably the simplest function to write as a lambda is the identity function. It takes one argument
and returns it. The identity lambda and a few other simple examples of lambdas can be seen in
<a href="#code:simple-lambdas">3</a>.
</p>
<div class="org-src-container">
<label class="org-src-name">Some simle lambdas</label>
<pre class="src src-slime" id="code:simple-lambdas"><span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span><span style="color: #7fff00;">(</span><span style="color: #859900;">lambda</span> <span style="color: #00bfff;">(</span>x<span style="color: #00bfff;">)</span> x<span style="color: #7fff00;">)</span> 1<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span><span style="color: #7fff00;">(</span><span style="color: #859900;">lambda</span> <span style="color: #00bfff;">(</span>x y<span style="color: #00bfff;">)</span> <span style="color: #00bfff;">(</span><span style="color: #859900;">+</span> x y<span style="color: #00bfff;">)</span><span style="color: #7fff00;">)</span> 3 5<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span><span style="color: #7fff00;">(</span><span style="color: #859900;">lambda</span> <span style="color: #00bfff;">(</span>x y z<span style="color: #00bfff;">)</span> <span style="color: #00bfff;">(</span><span style="color: #859900;">list</span> x y z<span style="color: #00bfff;">)</span><span style="color: #7fff00;">)</span> 1 2 3<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
1
8
(1 2 3)
</pre>
<p>
Additionally Slime lambdas have the possibility to take <b>optional arguments</b> in the form of <b>keyword
arguemnts</b> as well as a <b>rest argument</b> which allows for accepting any number of arguments. Since
these concepts are most useful when the function is actually bound to a variable, they will be
introduced when we learned how to do that in <a href="#sec-7">Define</a>.
</p>
</div>
<div id="outline-container-sec-6-1" class="outline-3">
<h3 id="sec-6-1"><span class="section-number-3">6.1</span> Special lambdas</h3>
<div class="outline-text-3" id="text-6-1">
<p>
The <code>lambda</code> special form creates a function object that represents a regular function. So the basic
evaluation rules count: when the lambda is invoked all it's arguments are evaluated and then the
lambda is applied to the evaluated arguments. If this is not wanted in some rare cases, the
programmer also has the possibility to define a special form using <code>special-lambda</code>, which, when
invoked does not evaluare any argument. The programmer has to evaluate the arguments in the body
themselves using <code>eval</code>. The rest of the syntax between <code>lambda</code> and <code>special-lambda</code> are the same.
</p>
<div class="org-src-container">
<label class="org-src-name">Special lambdas do not evaluate their arguments</label>
<pre class="src src-slime" id="code:special-lambdas"><span style="color: #ff8c00;">(</span><span style="color: #ff1493;">(</span><span style="color: #859900;">lambda</span> <span style="color: #7fff00;">(</span>x<span style="color: #7fff00;">)</span> <span style="color: #7fff00;">(</span>printf x<span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span> <span style="color: #ff1493;">(</span><span style="color: #859900;">+</span> 1 2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span><span style="color: #ff1493;">(</span><span style="color: #859900;">special-lambda</span> <span style="color: #7fff00;">(</span>x<span style="color: #7fff00;">)</span> <span style="color: #7fff00;">(</span>printf x<span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span> <span style="color: #ff1493;">(</span><span style="color: #859900;">+</span> 1 2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #46BA3C; font-style: italic;">;; </span><span style="color: #46BA3C; font-style: italic;">Special lambdas make it possible to write</span>
<span style="color: #46BA3C; font-style: italic;">;; </span><span style="color: #46BA3C; font-style: italic;">code that inspects code</span>
<span style="color: #ff8c00;">(</span><span style="color: #ff1493;">(</span><span style="color: #859900;">special-lambda</span> <span style="color: #7fff00;">(</span>expr<span style="color: #7fff00;">)</span>
<span style="color: #7fff00;">(</span>printf <span style="color: #2aa198;">"The function to be called is"</span>
<span style="color: #00bfff;">(</span><span style="color: #859900;">first</span> expr<span style="color: #00bfff;">)</span>
<span style="color: #2aa198;">"and the result is"</span>
<span style="color: #00bfff;">(</span><span style="color: #859900;">eval</span> expr<span style="color: #00bfff;">)</span><span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">+</span> 1 2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
3
(+ 1 2)
The function to be called is + and the result is 3.
</pre>
</div>
</div>
</div>
<div id="outline-container-sec-7" class="outline-2">
<h2 id="sec-7"><span class="section-number-2">7</span> Define</h2>
<div class="outline-text-2" id="text-7">
<p>
To assign a value to a symbol you can use the <code>define</code> built-in special form. The syntax for
<code>define</code> is: \[\texttt{(define symbol value)}\] and some usages can be seen in
<a href="#code:variable-defines">5</a>.
</p>
<div class="org-src-container">
<label class="org-src-name">Simple definition of variables</label>
<pre class="src src-slime" id="code:variable-defines"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> var1 1<span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> var2 <span style="color: #d33682;">"Hello World"</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> var3 <span style="color: #ff1493;">(</span><span style="color: #859900;">+</span> 1 2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf var1 var2 var3<span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
1 Hello World 3
</pre>
</div>
<div id="outline-container-sec-7-1" class="outline-3">
<h3 id="sec-7-1"><span class="section-number-3">7.1</span> Defining functions</h3>
<div class="outline-text-3" id="text-7-1">
<p>
In <a href="#sec-6">Lambdas</a> we learned how to create function objects using the <code>lambda</code> built-in form. Using
<code>define</code> every Lisp Object can be assigned to a symbol making no exception for the function objects.
In <a href="#code:lambda-defines">6</a> you can see what that would look like.
</p>
<div class="org-src-container">
<label class="org-src-name">Definition of functions using lambdas</label>
<pre class="src src-slime" id="code:lambda-defines"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> hypothenuse
<span style="color: #ff1493;">(</span><span style="color: #859900;">lambda</span> <span style="color: #7fff00;">(</span>a b<span style="color: #7fff00;">)</span>
<span style="color: #7fff00;">(</span><span style="color: #859900;">**</span> <span style="color: #00bfff;">(</span><span style="color: #859900;">+</span> <span style="color: #ffff00;">(</span><span style="color: #859900;">*</span> a a<span style="color: #ffff00;">)</span> <span style="color: #ffff00;">(</span><span style="color: #859900;">*</span> b b<span style="color: #ffff00;">)</span><span style="color: #00bfff;">)</span> 0.5<span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>hypothenuse 3 4<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
5
</pre>
<p>
Since defining functions is so common, there is a syntactic shorthand that does not require to write
out the whole <code>lambda</code> definition. In this case the first argument to the call to <code>define</code> is a
list. The frist element of the list is the name of the function to define and the other elemens are
the arguments to that function. An example can be seen in <a href="#code:function-defines">7</a>. Note that the
definition looks like a call to the function we are constructing, making it easier to see what a
call to that function will look like.
</p>
<div class="org-src-container">
<label class="org-src-name">Definition of functions using the shorthand syntax of define</label>
<pre class="src src-slime" id="code:function-defines"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> <span style="color: #ff1493;">(</span><span style="color: #b58900;">hypothenuse</span> a b<span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">**</span> <span style="color: #7fff00;">(</span><span style="color: #859900;">+</span> <span style="color: #00bfff;">(</span><span style="color: #859900;">*</span> a a<span style="color: #00bfff;">)</span> <span style="color: #00bfff;">(</span><span style="color: #859900;">*</span> b b<span style="color: #00bfff;">)</span><span style="color: #7fff00;">)</span> 0.5<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>hypothenuse 3 4<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
5
</pre>
</div>
</div>
<div id="outline-container-sec-7-2" class="outline-3">
<h3 id="sec-7-2"><span class="section-number-3">7.2</span> Functions with keyword arguments</h3>
<div class="outline-text-3" id="text-7-2">
<p>
A sometimes more convenient way of passing arguments to a function is using keyword arguments. Using
keyword arguments a function call could look like this: \[\texttt{(function :arg1 value1 :arg2
value2)}\] here the function accepts two arguments named <code>arg1</code> and <code>arg2</code>. The user of this
function can see more clearly excatly which argument will be assigned wich value. This notation also
allows for switching the argument order. The following function call is equivalent to the call
above. \[\texttt{(function :arg2 value2 :arg1 value1)}\].
</p>
<p>
For this to work however, the function must be defined to accept these keyword arguments. To do this
the special marker <code>:keys</code> has to be inserted into the argument list of a <code>lambda</code> or a function
<code>define</code>. All following arguments <b>must</b> be supplied as keyword arguments, <i>unless</i> they are also
supplied with a default value, in which case they do not need to be supplied. To attach a default
value to a keyword argument, insert <code>:defaults-to &lt;value&gt;</code> after the keyword argument name. An
example of all of this can be seen in <a href="#code:keyword-args">8</a>. Important note: keyword arguments must be
defined and supplied after all the regular arguments.
</p>
<div class="org-src-container">
<label class="org-src-name">A more complex functoin definition using keyword arguments</label>
<pre class="src src-slime" id="code:keyword-args"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> <span style="color: #ff1493;">(</span><span style="color: #b58900;">complex</span> required1 required2 <span style="color: #6c71c4;">:keys</span>
key1
key2 <span style="color: #6c71c4;">:defaults-to</span> 3
key3<span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">*</span> <span style="color: #7fff00;">(</span><span style="color: #859900;">+</span> required1 required2<span style="color: #7fff00;">)</span>
key1
key2
key3<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>complex 1 2 <span style="color: #6c71c4;">:key1</span> 2 <span style="color: #6c71c4;">:key2</span> 2 <span style="color: #6c71c4;">:key3</span> 3<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>complex 1 2 <span style="color: #6c71c4;">:key1</span> 2 <span style="color: #6c71c4;">:key3</span> 3<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>complex 1 2 <span style="color: #6c71c4;">:key3</span> 3 <span style="color: #6c71c4;">:key1</span> 2<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
36
54
54
</pre>
</div>
</div>
<div id="outline-container-sec-7-3" class="outline-3">
<h3 id="sec-7-3"><span class="section-number-3">7.3</span> Functions with rest arguments</h3>
<div class="outline-text-3" id="text-7-3">
<p>
If the programmer wants to create a function that can accept any number of arguments, they can use
the <code>rest</code> argument. It is defined after the special marker <code>:rest</code> and after the rest argument, no
other arguments can be defined. In the execution of the fuction, the rest arguent will be assigned
to a list containing all the supplied values. The rest argument can be used in conjunction with the
other argument types, regular arguments and keyword arguments.
</p>
<div class="org-src-container">
<label class="org-src-name">A more complex functoin definition using keyword arguments</label>
<pre class="src src-slime" id="code:rest-args"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> <span style="color: #ff1493;">(</span><span style="color: #b58900;">execute-operation</span> operation
<span style="color: #6c71c4;">:keys</span>
do-logging <span style="color: #6c71c4;">:defaults-to</span> <span style="color: #7fff00;">()</span>
<span style="color: #6c71c4;">:rest</span> values<span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">define</span> result <span style="color: #7fff00;">(</span>apply operation values<span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span>when do-logging
<span style="color: #7fff00;">(</span>printf <span style="color: #2aa198;">"Executing operation"</span>
operation
<span style="color: #2aa198;">"agains the values"</span>
values
<span style="color: #2aa198;">"yielded:"</span>
result<span style="color: #7fff00;">)</span><span style="color: #ff1493;">)</span>
result<span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>execute-operation '+ 1 2 3<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>printf <span style="color: #ff1493;">(</span>execute-operation '*
<span style="color: #6c71c4;">:do-logging</span> t
10 11<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<pre class="example">
evaluates to =&gt;
6
Executing operation * agains values (10 11) yielded: 110
110
</pre>
</div>
</div>
</div>
<div id="outline-container-sec-8" class="outline-2">
<h2 id="sec-8"><span class="section-number-2">8</span> Environments</h2>
</div>
<div id="outline-container-sec-9" class="outline-2">
<h2 id="sec-9"><span class="section-number-2">9</span> Macros</h2>
</div>
<div id="outline-container-sec-" class="outline-2">
<h2 id="sec-">Built-in functions</h2>
<div class="outline-text-2" id="text-">
<hr/>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>continuation?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a continuation.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>=</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
Takes 0 or more arguments and returns <code>t</code> if all arguments are equal and <code>()</code> otherwise.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>+</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>get-random-between</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>lambda</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>info</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>addr-of</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>type</code>?=</h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>obj</code>, <code>typ</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument <code>obj</code> is of type <code>typ</code>
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>symbol?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a symbol.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>macro?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a macro.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>procedure?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>rest</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>type</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>print</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>import</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>symbol-&gt;keyword</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>pe</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>expr</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>stream-null?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>s</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>construct-list</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><div class="org-src-container">
<pre class="src src-slime"><span style="color: #ff8c00;">(</span>construct-list
i &lt;- '<span style="color: #ff1493;">(</span>1 2 3 4 5<span style="color: #ff1493;">)</span>
yield <span style="color: #ff1493;">(</span><span style="color: #859900;">*</span> i i<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
<p>
(construct-list
i &lt;- '(1 2 3 4)
j &lt;- '(A B)
yield (pair i j))
</p>
<p>
(construct-list
i &lt;- '(1 2 3 4 5 6 7 8)
if (= 0 (% i 2))
yield i)
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>define</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>vector-length</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>/</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>quasiquote</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>or</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>list</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>zip</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>l1</code>, <code>l2</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>generic-extend</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>args</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>pair?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a pair.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>end</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Returns the last pair in the sqeuence.
</p>
<div class="org-src-container">
<pre class="src src-slime"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> a <span style="color: #ff1493;">(</span><span style="color: #859900;">list</span> 1 2 3 4<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span><span style="color: #859900;">print</span> <span style="color: #ff1493;">(</span>end a<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>decrement</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>val</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Subtracts one from the argument.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>range-while</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> keyword </dt><dd><code>from</code> <code>(0)</code>, <code>to</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Returns a sequence of numbers starting with the number defined
by the key 'from' and ends with the number defined in 'to'.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>mutate</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>&lt;</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>assert</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set-car!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>eval</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>vector</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>memstat</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>symbol-&gt;string</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>cond</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> rest </dt><dd><code>clauses</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>reduce</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>fun</code>, <code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Takes a function and a sequence as arguments and applies the
function to the argument sequence. This only works correctly if the
given function accepts a variable amount of parameters. If your
funciton is limited to two arguments, use <a href="#sec-"><code>reduce-binary</code></a>
instead.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>define-module</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>module-name</code>
</dd>
<dt> keyword </dt><dd><code>imports</code> <code>(())</code>, <code>exports</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>null?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is <code>nil</code>.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>built-in-function?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a built-in function.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>list-without-index</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>, <code>index</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>error</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hm/set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>case</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>var</code>
</dd>
<dt> rest </dt><dd><code>clauses</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>-</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>%</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>extend</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>, <code>elem</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Extends a list with the given element, by putting it in
the (rest) of the last element of the sequence.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>lambda?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a function.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>extend2</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>, <code>elem</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Extends a list with the given element, by putting it in
the (rest) of the last element of the sequence.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>length</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Returns the length of the given sequence.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>helper</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd></dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>&gt;</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>**</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>if</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>quote</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>not</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>apply</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>create-hash-map</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>first</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>delete-type!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>show</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>generate-docs</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>load</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hm/get-or-nil</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>hm</code>, <code>key</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>the-empty-stream</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:constructor</code>
</dd>
<dt> value </dt><dd><code>()</code>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>force</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>promise</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>when</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>condition</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Special form for when multiple actions should be done if a
condition is true.
</p>
<div class="org-src-container">
<pre class="src src-slime"><span style="color: #ff8c00;">(</span>when <span style="color: #ff1493;">(</span><span style="color: #859900;">not</span> <span style="color: #7fff00;">()</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"Hello "</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"from "</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"when!"</span><span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span>when <span style="color: #ff1493;">()</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"Goodbye "</span><span style="color: #ff1493;">)</span>
<span style="color: #ff1493;">(</span><span style="color: #859900;">print</span> <span style="color: #2aa198;">"World!"</span><span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>member?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>elem</code>, <code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>number?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a number.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>sublist-starting-at-index</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>, <code>index</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>increment</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>val</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Adds one to the argument.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>pair</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set-type!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>mem-reset</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>mytry</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>string-&gt;symbol</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>delay</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>expr</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>define-typed</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>args</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>vector-set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>&lt;=</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>bound?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hash-map-delete!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>filter</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>fun</code>, <code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Takes a function and a sequence as arguments and applies the
function to every value in the sequence. If the result of that
funciton application returns a truthy value, the original value is
added to a list, which in the end is returned.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>unzip</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>lists</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>types</code>?=</h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> rest </dt><dd><code>objs</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>special-lambda?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a special-lambda.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>last</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Returns the (first) of the last (pair) of the given sequence.
</p>
<div class="org-src-container">
<pre class="src src-slime"><span style="color: #ff8c00;">(</span><span style="color: #859900;">define</span> a <span style="color: #ff1493;">(</span><span style="color: #859900;">list</span> 1 2 3 4<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
<span style="color: #ff8c00;">(</span><span style="color: #859900;">print</span> <span style="color: #ff1493;">(</span>last a<span style="color: #ff1493;">)</span><span style="color: #ff8c00;">)</span>
</pre>
</div>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>append</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>, <code>elem</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Appends an element to a sequence, by extendeing the list
with (pair elem nil).
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>define-syntax</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>vector-ref</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>*</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>and</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>begin</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hash-map-set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>copy</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>concat-strings</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>let</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>bindings</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>enumerate</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>assert-types=</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> rest </dt><dd><code>objs</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>keyword?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a keyword.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>string?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Checks if the argument is a string.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>range</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> keyword </dt><dd><code>from</code> <code>(0)</code>, <code>to</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Returns a sequence of numbers starting with the number defined
by the key <code>from</code> and ends with the number defined in <code>to</code>.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>map</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>fun</code>, <code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Takes a function and a sequence as arguments and returns a new
sequence which contains the results of using the first sequences
elemens as argument to that function.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>read</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>exit</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>break</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hm/get</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>unless</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>condition</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Special form for when multiple actions should be done if a
condition is false.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>n-times</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>times</code>, <code>action</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Executes action times times.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>test</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd></dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>&gt;=</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set-cdr!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>hash-map-get</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:cfunction</code>
</dd>
<dt> docu </dt><dd><p>
TODO
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>reduce-binary</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>fun</code>, <code>seq</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Takes a function and a sequence as arguments and applies the
function to the argument sequence. reduce-binary applies the arguments
<b>pair-wise</b> which means it works with binary functions as compared to
<a href="#sec-"><code>reduce</code></a>.
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::make</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd>none.
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::print</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::get</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::find</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::key-exists?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::remove!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>, <code>value</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::alist::set-overwrite!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>alist</code>, <code>key</code>, <code>value</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::make</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd>none.
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::print</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::get</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::find</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::prop-exists?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::remove!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::set!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>, <code>value</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>ds::plist::set-overwrite!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>plist</code>, <code>prop</code>, <code>value</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>automata::make-dfa</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>Q</code>, <code>S</code>, <code>delta</code>, <code>q0</code>, <code>F</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::lerp</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>a</code>, <code>b</code>, <code>t</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::lerper</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>a</code>, <code>b</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::stepped-lerper</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>a</code>, <code>b</code>, <code>#steps</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::point-lerp</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>p1</code>, <code>p2</code>, <code>t</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::point-lerper</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>p1</code>, <code>p2</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::bezier2</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>p1</code>, <code>p2</code>, <code>p3</code>, <code>t</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>interpolation::bezierer2</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>p1</code>, <code>p2</code>, <code>p3</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>define-class</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>name-and-members</code>
</dd>
<dt> rest </dt><dd><code>body</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>-&gt;</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:macro</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>obj</code>, <code>meth</code>
</dd>
<dt> rest </dt><dd><code>args</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>math::pi</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:number</code>
</dd>
<dt> value </dt><dd><code>3.141593</code>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>math::abs</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Accepts one argument and returns the absoulte value of it
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>math::sqrt</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd><p>
Accepts one argument and returns the square root of it
</p>
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>math::make-vector3</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>x</code>, <code>y</code>, <code>z</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set::make</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> rest </dt><dd><code>vals</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set::find</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>set</code>, <code>val</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set::contains?</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>set</code>, <code>val</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
<hr/>
</div>
</div>
<div id="outline-container-sec-" class="outline-3">
<h3 id="sec-"><code>set::insert!</code></h3>
<div class="outline-text-3" id="text-">
<dl class="org-dl">
<dt> type </dt><dd><code>:lambda</code>
</dd>
<dt> arguments </dt><dd><dl class="org-dl">
<dt> postitional </dt><dd><code>set</code>, <code>value</code>
</dd>
</dl>
</dd>
<dt> docu </dt><dd>none
</dd>
</dl>
</div>
</div>
</div>
</div></div></div>
<footer id="postamble" class="">
<div><p class="author">Author: Felix Brendel</p>
<p class="date">Created: 2019-11-10 So 23:51</p>
<p class="creator"><a href="http://www.gnu.org/software/emacs/">Emacs</a> 26.3 (<a href="http://orgmode.org">Org-mode</a> 9.1.9)</p>
</div>
</footer>
</body>
</html>