「智能」比較球拍中的功能

Question

我有點異國情調。我需要比較功能，而不是「起源」而不是「實例」。在這裏我實際上意味着：

(define-values (a b c d) (values #f #f #f #f)) 

(define (f x) 
    (let ([g (λ (y) (printf "Please tell ~a this is ~a\n" x y))] 
     [h (curry printf "Don't tell ~a this is ~a\n" x)]) 
    (if a 
     (set! b g) 
     (set! a g)) 
    (if c 
     (set! d h) 
     (set! c h)))) 

(f "me") 
(f " me") 

(a "possible") 
(d "impossible") 

(equal? a b) ; <==== Is it possible to compare these guys 
(equal? c d) ; <==== to get #t in both cases? 

在這兩種情況下，我們獲得的功能，兩個不同的「實例」（即使有捕獲不同的值），但在源代碼中的相同位置這兩個聲明。當然，獲得這些功能主體的實際文本將解決這個問題，但這裏的其他答案告訴我們，在Racket中這是不可能的。有一些技巧可以幫助我嗎？

編輯： 這不是關於函數的理論等價性的問題。這完全是技術問題，而非編譯代碼中Racket的函數表示。因此可以用以下方式重新表達：我可以從「用戶」代碼中得到一些例程的行號嗎？我想這應該是可行的，因爲Racket調試器以某種方式獲得它。

Answer 1

即使沒有來自球拍內部的支持，如果您控制製作功能的代碼，也可以完成。如果你保留一個表示特定lambda的計數器（或者一些標識符），它可以將不同的閉包封裝在一個可以與宏擴展具有相同身份的結構中。這裏是一個演示：

#lang racket 

;; makes a procedure object that can have other data connected to it 
(struct proc (id obj) 
    #:property prop:procedure 
    (struct-field-index obj) 
    #:methods gen:custom-write 
    [(define (write-proc x port mode) 
    (display (format "#<procedure-id-~a>" (proc-id x)) port))]) 

;; compares the ids of two proc objects if they are proc objects 
(define (proc-equal? a b) 
    (and (proc? a) 
     (proc? b) 
     (= (proc-id a) (proc-id b)))) 

;; extends equal?, candidate to provide 
(define (equal*? a b) 
    (or (proc-equal? a b) 
     (equal? a b))) 

;; the state we keep 
(begin-for-syntax 
    (define unique-proc-id-per-code 0)) 

;; a macro that changes (lambda* ...) to 
;; (proc expansion-id (lambda ...)) 
(define-syntax (lambda* stx) 
    (let ((proc-id unique-proc-id-per-code)) 
    (set! unique-proc-id-per-code (add1 unique-proc-id-per-code)) 
    #`(proC#,(datum->syntax stx proc-id) (lambda #,@(datum->syntax stx (cdr (syntax-e stx))))))) 


;; test with making a counter 
(define counter-from 
    (lambda* (from) 
    (lambda*() 
     (begin0 
     from 
     (set! from (add1 from)))))) 

;; evaluatin the outer shows it has id 0 
counter-from ; ==> #<procedure-id-0> 

;; make two counters that both use the inner lambda 
(define from10 (counter-from 10)) 
(define from20 (counter-from 20)) 

;; both have the same expansion id 
from10 ; ==> #<procedure-id-1> 
from20 ; ==> #<procedure-id-1> 

;; they are not equal? 
(equal? from10 from20)  ; ==> #f (different object instances of proc) 
;; but they are procedure-equal? 
(proc-equal? from10 from20) ; ==> #t (same id, thus came from same macroexpansion) 

免責聲明：我是一個多敲詐勒索所以這或許已經完成更優雅奸人，我不知道的性能損失，這將給予。