Added spacing

docs/api/srfi/1.md

@@ -107,104 +107,204 @@ See the [SRFI document](http://srfi.schemers.org/srfi-1/srfi-1.html) for more in
 - [`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!
 

docs/api/srfi/106.md

@@ -44,40 +44,78 @@ See the [SRFI document](http://srfi.schemers.org/srfi-106/srfi-106.html) for mor
 - [`*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\*
+

docs/api/srfi/111.md

@@ -10,15 +10,26 @@ See the [SRFI document](http://srfi.schemers.org/srfi-111/srfi-111.html) for mor
 - [`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.
 

docs/api/srfi/117.md

@@ -32,28 +32,54 @@ See the [SRFI document](http://srfi.schemers.org/srfi-117/srfi-117.html) for mor
 - [`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
+

docs/api/srfi/132.md

@@ -24,20 +24,38 @@ See the [SRFI document](http://srfi.schemers.org/srfi-132/srfi-132.html) for mor
 - [`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!
+

docs/api/srfi/133.md

@@ -33,29 +33,56 @@ See the [SRFI document](http://srfi.schemers.org/srfi-133/srfi-133.html) for mor
 - [`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
+

docs/api/srfi/18.md

@@ -26,69 +26,127 @@ See the [Multithreading support SRFI documentation](http://srfi.schemers.org/srf
 - [`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.

docs/api/srfi/2.md

@@ -9,6 +9,7 @@ See the [SRFI document](http://srfi.schemers.org/srfi-2/srfi-2.html) for more in
 - [`and-let*`](#and-let)
 
 # and-let*
+
     (and-let* (claws) body
 
     claws ::= '() | (cons claw claws)

docs/api/srfi/27.md

@@ -17,28 +17,54 @@ more information.
 - [`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)
+

docs/api/srfi/69.md

@@ -37,84 +37,164 @@ See the [SRFI document](http://srfi.schemers.org/srfi-69/srfi-69.html) for more
 - [`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?`.