;;;;;;;;;;;;;;;;;;;;;;;;;;;; PRACTICA-9.TXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Abstracci\'on de procedimientos. Procedimientos como argumentos y
valores (II).


Para facilitar el trabajo divide la pantalla en dos ventanas mediante
CTRL-X 2 y, en una de ellas,  crea un buffer para trabajar con el
int\'erprete, mediante ESC-X run-scheme ENTER. Utiliza CTRL-X O para
saltar de una a otra ventana, mientras haces los ejercicios.


|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda que no es necesario teclear en el int\'erprete              |
| expresiones que ya aparezcan en este fichero. Para ello primero debes      |
| pasar a modo scheme, tecleando (con el cursor en este buffer)              |
| ESC-X scheme-mode ENTER. Luego, cada vez que quieras evaluar una expresi\'on |
| que ya est\'a escrita en este fichero, no tendr\'as que teclearla de nuevo |
| en el buffer del int\'erprete. Bastar\'a que coloques el cursor al         |
| principio de la expresi\'on y teclees CTRL-C CTRL-E.                       |
| Observar\'as que en la ventana de scheme aparece el valor de la            |
| expresi\'on.                                                               |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda tambi\'en que no es necesario escribir las expresiones      |
| pedidas  en el int\'erprete. Puedes escribirlas en este buffer debajo      |
| de cada apartado y evaluar lo que escribes con CTRL-C CTRL-E, viendo la    |
| respuesta en el buffer de Scheme. As\'i, podr\'as corregir fallos          |
| f\'acilmente y adem\'as al final de la clase, si grabas este fichero,      |
| tendr\'as los ejercicios resueltos, sin necesidad de anotar en papel       |
| las soluciones. Al usar CTRL-C CTRL-E recuerda que la expresi\'on que      |
| deseas evaluar debe comenzar con par\'entesis y el primero de ellos debe   |
| ocupar la PRIMERA COLUMNA DE LA IZQUIERDA.                                 |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|

***************************************************************************
* EJERCICIO 1                                                             *
***************************************************************************

Define una funci\'on sustituye que reciba como entrada dos elementos x e
y, y una lista l y devuelve la lista obtenida sustituyendo cada
ocurrencia (de primer nivel) de x en l por y.

Definir una funci\'on sustituye-p con un argumento x tal que
(sustituye-p x) es una funci\'on con un argumento y tal que
((sustituye-p x) y) es una funci\'on que recibe como entrada una lista l
y devuelve la lista obtenida a partir de l sustituyendo cualquier
ocurrencia (de primer nivel) de x en l por y.

Usa las funciones sustituye y sustituye-p para sustituir las apariciones 
del n\'umero 1 por el 2 en la lista (1 2 3 1 2 3 1 2 3 1).




***************************************************************************
* EJERCICIO 2                                                             *
***************************************************************************

a) Eval\'ua las siguientes expresiones y justifica su comportamiento.

(define prueba
      (lambda args
	(if (or (null? args) (null? (cdr args)))
	    args
	    (prueba args))))

(prueba '(1 2 3 4))
(prueba 1 2 3 4)




b) Define un procedimiento compone-m que recibe como argumentos un
n\'umero arbitrario de funciones (cada una de un argumento) y devuelve
la funci\'on que resulta de componerlas ( () en caso de que no reciba
ning\'un argumento). Escribe una versi\'on usando letrec y otra usando
apply.

Ejemplos:

((compone-m (lambda (x) (* x x)) (lambda(x) (+ x 1)) (lambda (x) (* 3 x))) 3)
==> 100
((compone-m car cdr cdr cdr) '(1 2 3 4 5 6)) ==> 4
(compone-m) ==> ()


***********************************************************************
* EJERCICIO 3                                                         *
***********************************************************************

Definir un procedimiento iterativo  prod-arb, que tome 
un n\'umero arbitrario de argumentos y devuelva como valor el producto
de los elementos de entrada que sean n\'umeros. Si no hay ning\'un
n\'umero entre los argumentos recibidos devuelve como valor 1. Por ejemplo:

(prod-arb 'a 'hola 7 'adios 2) ==> 14
(prod-arb 'hola 'adios) ==> 1
(prod-arb '(3 4) 'adios  '()) ==> 1
(prod-arb '(100 a) 'hola 2 'adios 3 5) ==> 30 



***********************************************************************
* EJERCICIO 4                                                         *
***********************************************************************
Define un procedimiento parametrizado disyuncion de manera que recibe
como entrada un predicado p y devuelve una funci\'on que recibe como
entrada una lista l y devuelve #t si alg\'un elemento de l verifica p,
#f en caso contrario.
Por ejemplo:

((disyuncion symbol?) '( 1 2 3 iacs 4)) ==> #t
((disyuncion even?) '(1 3 5 7 9)) ==> #f
((disyuncion even?) ()) ==> #f



***********************************************************************
* EJERCICIO 5                                                         *
***********************************************************************

Definir un procedimiento parametrizado suma-suc tal que recibe como 
entrada una funci\'on f (que genera los t\'erminos de una sucesi\'on) y 
devuelve una funci\'on ITERATIVA que recibe como entrada un n\'umero 
natural n y devuelve la suma de los n primeros t\'erminos de la sucesi\'on 
que genera f.
Por ejemplo:

((suma-suc (lambda (x) x)) 4) ==> 10 
((suma-suc (lambda (x) (* x x))) 6) ==> 91