[plt-scheme] How can I print the procedure?

(define-syntax kappa
 (syntax-rules ()
  ((_ . rest) (make-proc (lambda . rest) '(lambda . rest)))))

(define-values (proc-descr make-proc proc? ignore0 ignore2)
 (make-struct-type 'proc #f 2 0 'na () (make-inspector) 0))

(kappa (x) x) --> #(struct:proc #<procedure> (lambda (x) x))

Jos

((((lambda(x)((((((x x)x)x)x)x)x))
   (lambda(x)(lambda(y)(x(x y)))))
  (lambda(x)(write x)x))
 'greeting)
----- Original Message ----- 
From: "Richard Cleis" <rcleis at mac.com>
To: "Majorinc, Kazimir" <kazimir at chem.pmf.hr>
Cc: "PLT Scheme Mailing List" <plt-scheme at list.cs.brown.edu>
Sent: Monday, December 03, 2007 9:34 PM
Subject: Re: [plt-scheme] How can I print the procedure?


> It's not clear what you are doing, but associating expressions with  
> functions can be done without significant complication.  One way is  
> to make a module and define your functions with your own syntax.  The  
> example below keeps functions and their expressions in a hash table.   
> The functions must be defined with a name so that the corresponding  
> expression can be referenced.
> 
> Copy this to a DrScheme window and run it using at least the MzScheme  
> language.  There are many more possibilities that depend on what you  
> are trying to achieve.
> 
> rac
> 
> ; beginning of example
> 
> (module expr-table mzscheme
>   (define  table (make-hash-table))
> 
>   (define-syntax  def-express
>     (syntax-rules ()
>       ((def-express name (lambda args body))
>        (begin
>          (define name (lambda args name body))
>          (hash-table-put! table name '(lambda args body))))
>       ))
> 
>   (define  (get-express f)
>     (hash-table-get table f))
> 
>   (provide def-express
>            get-express)
>   )
> 
> (require expr-table)
> 
> (def-express  sinx (lambda (x) (sin x)))
> (def-express  cosx (lambda (x) (cos x)))
> (def-express  sinx+cosx (lambda (x) (+ (sin x)(cos x))))
> (def-express  sinx*cosx (lambda (x) (* (sin x)(cos x))))
> 
> (define my-list-of-functions (list sinx
>                                    cosx
>                                    sinx+cosx
>                                    sinx*cosx))
> (define  (do-funcs-of-x funcs x)
>   (map (lambda (func)
>          (format "For ~a, ~a = ~a~n"
>                  x
>                  (get-express func)
>                  (func x)))
>        funcs))
> 
> (for-each display (do-funcs-of-x my-list-of-functions 1.0))
> (newline)
> (for-each display (do-funcs-of-x my-list-of-functions 2.0))
> 
> ; end of example
> 
> 
> 
> 
> 
> 
> On Dec 2, 2007, at 10:53 PM, Majorinc, Kazimir wrote:
> 
>> I said:
>>
>> (define (min-f measure L)
>>  (cond ((empty? (rest L)) (first L))
>>        ((< (measure (first L))
>>            (measure (min-f measure (rest L))))
>>         (first L))
>>        (else (min-f measure (rest L)))))
>>
>> (define (my-measure f)(+ (f 1) (f 10) (f 100)))
>> (define my-list-of-functions (list (lambda(x)(sin x))
>>                                   (lambda(x)(cos x))
>>                                   (lambda(x)(+ (sin x)(cos x)))
>>                                   (lambda(x)(* (sin x)(cos x)))))
>>
>> (min-f my-measure my-list-of-functions)
>>
>> And PLT said:
>>
>> #<procedure>
>>
>> Is there any way to actually print that #<procedure>? Except  
>> rewriting such programs so they do not only calculate procedures,  
>> but also prepare human-readable output? It can be significant  
>> complication ...
>> _________________________________________________
>>  For list-related administrative tasks:
>>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
> 
> _________________________________________________
>  For list-related administrative tasks:
>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
>