Función de esquema de desplazamiento como una lista

Question

¿No es posible tratar las funciones en Scheme como cualquier otra lista?

Básicamente, lo que quiero hacer para es algo como esto:

(define (foo) "hello") 

(cdr foo) ; or similar, should return the list ((foo) "hello") 

que he encontrado a similar discussion sobre esto, y me siento un poco decepcionado si esto no es posible con el Esquema. Si es así, ¿por qué es esto imposible? ¿Es posible en otros ceceos?

EDITAR: Cambió (cdr 'foo) a (cdr foo) - fue engañoso. Estoy preguntando, ¿por qué no puedo acceder a una función como una lista?

Answer 1

tengo a menudo quería poder hacer lo mismo csl. A continuación hay un ejemplo rápido de cómo hacer esto en mzscheme.

DrScheme 4,2

(module qdefine mzscheme 
    (provide ;(all-from-except mzscheme let) 
    (rename define olddefine) 
    (rename quote-define define) 
    (rename quote-cdr cdr) 
    (rename quote-car car)) 

    (define define-list '()) 
    (define define-list-add 
    (lambda (key value) 
     (set! define-list (cons `(,key ,value) define-list)))) 

    (define-syntax quote-define 
    (syntax-rules() 
     ((_ (pro-name args ...) body ...) 
     (begin 
     (define (pro-name args ...) body ...) 
     (define-list-add pro-name '((pro-name args ...) body ...)))) 
     ((_ pro-name pro) (begin 
          (define pro-name pro) 
          (define-list-add pro-name 'pro))) 

    )) 

    (define quote-cdr (lambda (lst) 
         (if (procedure? lst) 
          (cdr (cadr (assoc lst define-list))) 
          (cdr lst)))) 

    (define quote-car (lambda (lst) 
         (if (procedure? lst) 
          (car (cadr (assoc lst define-list))) 
          (car lst)))) 
) 
(require 'qdefine) 

(define testfunc (lambda (args) args)) 
(cdr testfunc) 
(car testfunc) 

(define (testfunc2 test) 'blah) 
(cdr testfunc2) 
(car testfunc2) 

(define testlist '(1 2 3 4 5 6 'a)) 
(cdr testlist) 
(car testlist) 

Salidas:

((args) args) 
lambda 
('blah) 
(testfunc2 test) 
(2 3 4 5 6 'a) 
1 
> 

Answer 2

'foo evalúa a un símbolo, no puede tomar el CDR de un símbolo.

Lo que puede querer hacer es (cdr foo), pero esto no funciona. El valor de un FOO es un procedimiento, no una lista.

Answer 3

Usted puede ser capaz de acceder a la función como una lista usando pp o pretty-print. Dicho esto, es posible que también deba ejecutar su código en modo de depuración. Sin embargo, esto depende de la implementación. Sé que puede funcionar en Gambit-C.

Answer 4

Su formulario define no es una función sino una definición de función. De hecho, es una forma abreviada de

(define foo 
    (lambda() 
    "hello")) 

Lambda puede ser pensado como una "invocación del compilador". En este caso, produce una función que devuelve esa cadena. Define luego vincula esta función al símbolo 'foo.

comparar esto con

(define foo "hello") 

que se une sólo la cadena en el símbolo 'foo. ¿Qué devolvería (cdr foo)?

Ahora, es imaginable que alguna implementación de esquema realmente guarde o tenga la opción de guardar el formulario lambda al vincular una función a un símbolo. Deberá verificar la documentación, pero el tipo de interpretación pura que esto implica seguramente tendría un impacto en el rendimiento.

Si logras esto, sin embargo, se le devolverá el formulario lambda, no la forma define.

Answer 5

(define (foo) ...) produce un objeto compilado, y es un valor - un procedimiento.
No puede iterar sobre él porque no es s-expresión.

Al igual que otros sugeridos, debe consultar su entorno de programación y ver
si tiene alguna función para tales tareas.

Answer 6

MIT Scheme tiene la capacidad de hacer esto. (Si realmente lo desea, coméntelo y le daré el código. Tenía que encontrar algunas funciones no documentadas para hacerlo realidad.)

Sin embargo, no está en la definición del lenguaje del esquema, por lo que las implementaciones no tienen que permitirlo. La razón de esto es que para hacer las funciones más rápidas, una buena implementación del Esquema modificará las funciones. Esto significa reescribirlos en un idioma diferente (ya sea un código de máquina o algo de un nivel bastante bajo) y eliminar los bits que no necesite; por ejemplo, la función + debe comprobar en general si sus argumentos son números, y si es así , qué tipo de números, pero si su función es un bucle que llama al +, puede verificar una vez al principio y hacer que la función sea mucho más rápida.

Por supuesto, todavía podría mantener las listas sin demasiados problemas, incluso con todas estas cosas. Pero si intentaste modificar las listas, ¿cómo funcionaría?

(Una vez más, se puede hacer que funcione. Sólo sería más trabajo para los ejecutores, y puesto que no se utiliza por lo general en los programas, la mayoría de la gente probablemente no quiero molestar.)

Answer 7

En astucia,

guile> (define (foo bar) 'baz)
guile> (Procedimiento-fuente foo)
(lambda (barra) (cotización baz))
guile> (CDR (foo procedimiento de código))
((bar) (Baz cita))
astucia>