(module lambda-w-docs mzscheme 
  (provide lam-w/args
           lam-w/expr
           lam-w/info
           docs-for
           list-docs)
  
  ; Intention: provide info for high level functions (e.g., for scripting)
  ;   use lam-w/args to add the arg expression to the table
  ;   use lam-w/expr to add the entire expression
  ;   use lam-w/info to add any expression (incl a function)
  ;   use docs-for to get docs (evaluate info if a function)
  ;   use list-docs to list names with docs
  
  ;(define  interest-a (lam-w/args (principal percent) 
  ;                                (* principal 0.01 percent)))
  ;(define  interest-e (lam-w/expr (principal percent) 
  ;                                (* principal percent)))
  ;(define  interest-i (lam-w/info "Supply principal and rate as a percent" 
  ;                                (principal percent) 
  ;                                (* principal percent)))
  ;(define  interest-f (lam-w/info (lambda  () 
  ;                                  (display "This could feed a gui")
  ;                                  (newline))
  ;                                (principal percent) 
  ;                                (* principal percent)))
  ;(docs-for interest-a)
  ;(docs-for interest-e)
  ;(docs-for interest-i)
  ;(docs-for interest-f)
  ;
  ;(list-docs interest-a interest-e interest-i interest-f)
  
  ; a very basic implementation; r5 scheme & syntax language;
  ; Scheme procedures (not assigned names) are used as keys,
  ; so multiple names (assigned to procedures) are all ok keys
  
  (define-syntax syntax-error
    (syntax-rules ()
      ((syntax-error) (syntax-error "From define-syntax-primer.txt"))))
  
  (define-syntax  lam-w/args
    (syntax-rules ()
      ((_ args . body)
       (let  ((f  (lambda  args . body)))
         (sort-table! f '(lambda args)) ; table only argument expression
         f))
      ((_ ...) 
       (syntax-error 
        "Use lambda form. Expression for args will be tabled."))))
  
  (define-syntax  lam-w/expr
    (syntax-rules ()
      ((_ args . body)
       (let  ((f  (lambda  args . body)))
         (sort-table! f '(lambda args . body)) ; table expression
         f))
      ((_ ...) 
       (syntax-error 
        "Use lambda form. Entire expression will be tabled."))))
  
  (define-syntax  lam-w/info
    (syntax-rules ()
      ((_ info args . body)
       (let  ((f  (lambda  args . body)))
         (sort-table! f info) ; table info expression
         f))
      ((_ ...) 
       (syntax-error 
        "Use lambda form, except first expression will be info."))))
  
  (define-syntax  list-docs
    (syntax-rules ()
      ((_ f ...)
       (list (list 'f (get-info f table)) ...))
      ((_ ...) 
       (syntax-error "Use (list-docs f [...])"))))
  
  
  (define  table (list))
  
  (define  sort-table! (lambda  f&info ; simplest 'sorter'
                         (set! table (cons f&info table))))
  
  (define  docs-for (lam-w/args  (f-as-key) 
                                 (do-info  (get-info f-as-key table))))
  
  (define  do-info (lambda  (info) ; info handlers go in here
                     (cond  (info  (cond  ((procedure? info) (info))
                                          (else info)))
                            (else 'not-in-table))))
  
  (define  (get-info f table) ; lookup for simplest 'sorter'
    (cond  ((null? table)
            #f)
           ((equal? f (caar table))
            (cadar table))
           (else
            (get-info f (cdr table)))))
  )