Add function signatures

docs/api/scheme/base.md

@@ -29,7 +29,6 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 - [`complex?`](#complex)
 - [`cond`](#cond)
 - [`cond-expand`](#cond-expand)
-- [`cons-source`](#cons-source)
 - [`current-error-port`](#current-error-port)
 - [`current-input-port`](#current-input-port)
 - [`current-output-port`](#current-output-port)
@@ -113,7 +112,6 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 - [`read-string`](#read-string)
 - [`receive`](#receive)
 - [`record?`](#record)
-- [`register-simple-type`](#register-simple-type)
 - [`remainder`](#remainder)
 - [`reverse`](#reverse)
 - [`round`](#round)
@@ -161,66 +159,120 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 
 
 #abs
+    (abs num)
 #and
 #any
+    (any pred lst)
 #append
+    (append list ...)
 #assoc
+    (assoc obj alist)
+    (assoc obj alist compare)
 #assq
+    (assq obj alist)
 #assv
+    (assv obj alist)
 #begin
 #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
 #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-expand
-#cons-source
 #current-error-port
+    (current-error-port)
 #current-input-port
+    (current-input-port)
 #current-output-port
+    (current-output-port)
 #define-record-type
 #denominator
+    (denominator n)
 #do
 #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 
+    (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-aux
 #inexact
+    (inexact z)
 #inexact?
+    (inexact? num)
 #input-port-open?
+    (input-port-open? port)
 #input-port?
+    (input-port? port)
 #lcm
+    (lcm n1 ...)
 #let
 #let*
 #let*-values
@@ -228,89 +280,225 @@ For more information see the [R<sup>7</sup>RS Scheme Specification](../../r7rs.p
 #letrec
 #letrec*
 #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
 #output-port-open?
+    (output-port-open? port)
 #output-port?
+    (output-port? obj)
 #positive?
+    (positive? n)
 #quasiquote
 #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
 #record?
-#register-simple-type
+    (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-rules
 #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
 #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
 #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)
+
+
+(define-syntax and
+(define-syntax begin 
+(define-syntax case
+(define-syntax cond
+(define-syntax cond-expand
+(define-syntax define-record-type
+(define-syntax do
+(define-syntax guard
+(define-syntax guard-aux
+(define-syntax let
+(define-syntax let*
+(define-syntax let*-values
+(define-syntax let-values
+(define-syntax letrec 
+(define-syntax letrec*
+(define-syntax or
+(define-syntax parameterize
+(define-syntax quasiquote
+(define-syntax receive
+(define-syntax syntax-error
+(define-syntax syntax-rules
+(define-syntax unless
+(define-syntax when