Added spacing

docs/api/scheme/base.md

@@ -158,348 +158,694 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 
 
 #abs
+
     (abs num)
+
 #and
+
     (and {test1} ...)
+
 #any
+
     (any pred lst)
+
 #append
+
     (append list ...)
+
 #assoc
+
     (assoc obj alist)
+
     (assoc obj alist compare)
+
 #assq
+
     (assq obj alist)
+
 #assv
+
     (assv obj alist)
+
 #begin
+
     (begin {expression or definition} ...)
+
 #boolean=?
+
     (boolean=? b1 b2 ...)
+
 #bytevector-copy
+
     (bytevector-copy bytevector)
+
     (bytevector-copy bytevector start)
+
     (bytevector-copy bytevector start end)
+
 #bytevector-copy!
+
     (bytevector-copy! to at from)
+
     (bytevector-copy! to at from start)
+
     (bytevector-copy! to at from start end)
+
 #call-with-current-continuation
+
     (call-with-current-continuation proc)
+
 #call-with-port
+
     (call-with-port port proc)
+
 #call-with-values
+
     (call-with-values producer consumer)
+
 #call/cc
+
     (call/cc proc)
+
 #case
+
     (case {key} {clause1} {clause2} ...)
+
 #ceiling
+
     (ceiling z)
+
 #char<=?
+
     (char<=? c1 c2 c3 ...)
+
 #char<?
+
     (char<?  c1 c2 c3 ...)
+
 #char=?
+
     (char=?  c1 c2 c3 ...)
+
 #char>=?
+
     (char>=? c1 c2 c3 ...)
+
 #char>?
+
     (char>?  c1 c2 c3 ...)
+
 #complex?
+
     (complex? obj) 
+
 #cond
+
     (cond {clause1} {clause2} ...)
+
 #cond-expand
+
     (cond-expand {ce-clause2} {ce-clause2} ...)
+
 #current-error-port
+
     (current-error-port)
+
 #current-input-port
+
     (current-input-port)
+
 #current-output-port
+
     (current-output-port)
+
 #define-record-type
+
     (define-record-type {name}
+
       {constructor} {pred} {field} ...)
+
 #denominator
+
     (denominator n)
+
 #do
+
     (do (({variable1} {init1} {step1})
+
          ...)
+
     ({test} {expression} ...)
+
     {command} ...)
+
 #dynamic-wind
+
     (dynamic-wind before thunk after)
+
 #eof-object
+
     (eof-object)
+
 #error
+
     (error message obj ...)
+
 #even?
+
     (even? num)
+
 #every
+
     (every pred lst)
+
 #exact
+
     (exact? num)
+
 #exact-integer?
+
     (exact-integer? num)
+
 #exact?
+
     (exact? num)
+
 #expt
+
     (expt z1 z2)
+
 #features
+
     (features) 
+
 #floor
+
     (floor z)
+
 #floor-quotient 
+
     (floor-quotient n m)
+
 #floor-remainder
+
     (floor-remainder n m)
+
 #floor/ 
+
     (floor/ n m)
+
 #flush-output-port
+
     (flush-output-port)
+
     (flush-output-port port)
+
 #foldl
+
     (foldl func accum lst)
+
 #foldr
+
     (foldr func end lst)
+
 #for-each
+
     (for-each proc list1 list2 ...)
+
 #gcd
+
     (gcd n1 ...)
+
 #get-output-bytevector
+
     (get-output-bytevector port)
+
 #get-output-string
+
     (get-output-string port)
+
 #guard
+
     (guard ({variable}
+
             {cond clause1} {cond clause2} ...)
+
       {body})
+
 #inexact
+
     (inexact z)
+
 #inexact?
+
     (inexact? num)
+
 #input-port-open?
+
     (input-port-open? port)
+
 #input-port?
+
     (input-port? port)
+
 #lcm
+
     (lcm n1 ...)
+
 #let
+
     (let {bindings} {body})
+
 #let*
+
     (let* {bindings} {body})
+
 #let*-values
+
     (let*-values {mv binding spec} {body})
+
 #let-values
+
     (let-values {mv binding spec} {body})
+
 #letrec
+
     (letrec {bindings} {body})
+
 #letrec*
+
     (letrec* {bindings} {body})
+
 #list
+
     (list obj ...)
+
 #list-copy
+
     (list-copy lst)
+
 #list-ref
+
     (list-ref lst k)
+
 #list-set!
+
     (list-set! lst k obj)
+
 #list-tail
+
     (list-tail lst k) 
+
 #list?
+
     (list? o)
+
 #make-constructor
+
     (make-constructor make name)
+
 #make-getter
+
     (make-getter sym name idx)
+
 #make-list
+
     (make-list k )
+
     (make-list k fill)
+
 #make-parameter
+
     (make-parameter init)
+
     (make-parameter init converter)
+
 #make-setter
+
     (make-setter sym name idx)
+
 #make-string
+
     (make-string k)
+
     (make-string k fill)
+
 #make-type-predicate
+
     (make-type-predicate pred name)
+
 #map
+
     (map proc list1 list2 ...)
+
 #max
+
     (max x1 x2 ...)
+
 #member
+
     (member obj lst) 
+
     (member obj lst compare) 
+
 #memq
+
     (memq obj lst)
+
 #memv
+
     (memv obj lst)
+
 #min
+
     (min x1 x2 ...)
+
 #modulo
+
     (modulo a b)
+
 #negative?
+
     (negative? n)
+
 #newline
+
     (newline)
+
     (newline port) 
+
 #not
+
     (not x)
+
 #numerator
+
     (numerator n) n)
+
 #odd?
+
     (odd? num)
+
 #open-input-bytevector
+
     (open-input-bytevector bv)
+
 #open-input-string
+
     (open-input-string string)
+
 #open-output-bytevector
+
     (open-output-bytevector open-output-string)
+
 #open-output-string
+
     (open-output-string)
+
 #or
+
     (or {test1} ...)
+
 #output-port-open?
+
     (output-port-open? port)
+
 #output-port?
+
     (output-port? obj)
+
 #parameterize
+
     (parameterize (({param1} {value1}) ...)
+
       {body})
+
 #positive?
+
     (positive? n)
+
 #quasiquote
+
     (quasiquote {qq template})
+
 #quotient
+
     (quotient x y)
+
 #raise
+
     (raise obj)
+
 #raise-continuable
+
     (raise-continuable obj)
+
 #rational?
+
     (rational? obj)
+
 #read-line
+
     (read-line)
+
     (read-line port)
+
 #read-string
+
     (read-string k)
+
     (read-string k port)
+
 #receive
+
     (receive {formals} {expression} {body})
+
 #record?
+
     (record? obj)
+
 #remainder
+
     (remainder num1 num2)
+
 #reverse
+
     (reverse lst)
+
 #round
+
     (round z)
+
 #slot-set!
+
     (slot-set! name obj idx val)
+
 #square
+
     (square z)
+
 #string
+
     (string char ...)
+
 #string->list
+
     (string->list string)
+
     (string->list string start)
+
     (string->list string start end)
+
 #string->utf8
+
     (string->utf8 string)
+
     (string->utf8 string start)
+
     (string->utf8 string start end)
+
 #string->vector
+
     (string->vector string)
+
     (string->vector string start)
+
     (string->vector string start end)
+
 #string-copy
+
     (string-copy string)
+
     (string-copy string start)
+
     (string-copy string end)
+
 #string-copy!
+
     (string-copy! to at from)
+
     (string-copy! to at from start)
+
     (string-copy! to at from start end)
+
 #string-fill!
+
     (string-fill! str fill)
+
     (string-fill! str fill start)
+
     (string-fill! str fill start end)
+
 #string-for-each
+
     (string-for-each proc string1 string2 ...)
+
 #string-map
+
     (string-map proc string1 string2 ...)
+
 #string<=?
+
     (string<=? str1 str2)
+
 #string<?
+
     (string<? str1 str2)
+
 #string=?
+
     (string=? str1 str2)
+
 #string>=?
+
     (string>=? str1 str2)
+
 #string>?
+
     (string>? str1 str2)
+
 #symbol=?
+
     (symbol=? symbol1 symbol2 symbol3 ...)
+
 #syntax-error
+
     (syntax-error {message} {args} ...)
+
 #truncate
+
     (truncate z)
+
 #truncate-quotient 
+
     (truncate-quotient quotient)
+
 #truncate-remainder 
+
     (truncate-remainder remainder)
+
 #truncate/ 
+
     (truncate/ n m)
+
 #type-slot-offset
+
     (type-slot-offset name sym)
+
 #unless
+
     (unless {test} {expression1} {expression2} ...)
+
 #utf8->string
+
     (utf8->string bytevector)
+
     (utf8->string bytevector start)
+
     (utf8->string bytevector start end)
+
 #values
+
     (values obj ...)
+
 #vector
+
     (vector obj ...)
+
 #vector->list
+
     (vector->list vector)
+
     (vector->list vector start)
+
     (vector->list vector start end)
+
 #vector->string
+
     (vector->string vector)
+
     (vector->string vector start)
+
     (vector->string vector start end)
+
 #vector-append
+
     (vector-append vector ...)
+
 #vector-copy
+
     (vector-copy vector)
+
     (vector-copy vector start)
+
     (vector-copy vector start end)
+
 #vector-copy!
+
     (vector-copy! to at from)
+
     (vector-copy! to at from start)
+
     (vector-copy! to at from start end)
+
 #vector-fill!
+
     (vector-fill! vector fill)
+
     (vector-fill! vector fill start)
+
     (vector-fill! vector fill start end)
+
 #vector-for-each
+
     (vector-for-each proc vector1 vector2 ...)
+
 #vector-map
+
     (vector-map proc vector1 vector2 ...)
+
 #when
+
     (when {test} {expression1} {expression2} ...)
+
 #with-exception-handler
+
     (with-exception-handler handler thunk)
+
 #write-char
+
     (write-char char)
+
     (write-char char port)
+
 #write-string
+
     (write-string string)
+
     (write-string string port)
+
 #zero?
+
     (zero? n)
+

docs/api/scheme/char.md

@@ -28,47 +28,90 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 - [`string-upcase`](#string-upcase)
 
 #char-alphabetic?
+
     (char-alphabetic? c)
+
 #char-ci<=?
+
     (char-ci<=? c1 c2 . cs)
+
 #char-ci<? 
+
     (char-ci<? c1 c2 . cs)
+
 #char-ci=?
+
     (char-ci=? c1 c2 . cs)
+
 #char-ci>=? 
+
     (char-ci>=? c1 c2 . cs)
+
 #char-ci>?
+
     (char-ci>? c1 c2 . cs)
+
 #char-downcase
+
     (char-downcase c)
+
 #char-foldcase
+
     (char-foldcase c)
+
 #char-lower-case?
+
     (char-lower-case? c)
+
 #char-numeric?
+
     (char-numeric? c) 
+
 #char-upcase
+
     (char-upcase c)
+
 #char-upper-case?
+
     (char-upper-case? c)
+
 #char-whitespace?
+
     (char-whitespace? c)
+
 #digit-value
+
     (digit-value c)
+
 #string-ci<=? 
+
     (string-ci<=? s1 s2)
+
 #string-ci<?
+
     (string-ci<? s1 s2)
+
 #string-ci=? 
+
     (string-ci=? s1 s2)
+
 #string-ci>=?
+
     (string-ci>=? s1 s2)
+
 #string-ci>? 
+
     (string-ci>? s1 s2)
+
 #string-downcase
+
     (string-downcase str)
+
 #string-foldcase
+
     (string-foldcase str)
+
 #string-upcase
+
     (string-upcase str)
 

docs/api/scheme/complex.md

@@ -12,14 +12,26 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 - [`real-part`](#real-part)
 
 #angle
+
     (angle z)
+
 #imag-part
+
     (imag-part x)
+
 #magnitude
+
     (magnitude z)
+
 #make-polar
+
     (make-polar x y)
+
 #make-rectangular
+
     (make-rectangular x y)
+
 #real-part
+
     (real-part x)
+

docs/api/scheme/cxr.md

@@ -35,50 +35,98 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 - [`cddddr`](#cddddr)
 
 #caaar
+
     (caaar list)
+
 #caadr
+
     (caadr list)
+
 #cadar
+
     (cadar list)
+
 #caddr
+
     (caddr list)
+
 #cdaar
+
     (cdaar list)
+
 #cdadr
+
     (cdadr list)
+
 #cddar
+
     (cddar list)
+
 #cdddr
+
     (cdddr list)
+
 #caaaar
+
     (caaaar list)
+
 #caaadr
+
     (caaadr list)
+
 #caadar
+
     (caadar list)
+
 #caaddr
+
     (caaddr list)
+
 #cadaar
+
     (cadaar list)
+
 #cadadr
+
     (cadadr list)
+
 #caddar
+
     (caddar list)
+
 #cadddr
+
     (cadddr list)
+
 #cdaaar
+
     (cdaaar list)
+
 #cdaadr
+
     (cdaadr list)
+
 #cdadar
+
     (cdadar list)
+
 #cdaddr
+
     (cdaddr list)
+
 #cddaar
+
     (cddaar list)
+
 #cddadr
+
     (cddadr list)
+
 #cdddar
+
     (cdddar list)
+
 #cddddr
+
     (cddddr list)
+