DrRacket - TUTORIALES

September 8, 2017 | Author: Alejandro Debus | Category: Functional Programming, Notation, Computer Programming, Computer Engineering, Software Development
Share Embed Donate


Short Description

Download DrRacket - TUTORIALES...

Description

Departamento de Electrónica e Informática, Universidad Centroamericana José Simeón Cañas

Programando con Racket 5 por

Eduardo NAVAS versión 1.0 2010.07.21

Este libro fue desarrollado únicamente con software libre. Entre las herramientas usadas,

AT X, L X, GNU/Linux, GNOME, KDE, KmPlot, GIMP, Python, etc. se encuentran: L E Y

CC-BY-NC-SA Este es un libro libre con la licencia

Creative Commons Attribution-Noncommercial-Share Alike 3.0. Los detalles pueden ser consultados en: http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es La versión digital y el material adicional puede ser descargado de: www.aliamondano-eo.wikidot.com/racket-5 http://dei.uca.edu.sv/publicaciones/ ISBN: 978-99923-73-61-3 Editado y preparado desde el

Departamento de Electrónica e Infomática

de la

Universidad Centroamericana José Simeón Cañas, El Salvador, Centroamérica.

Dedico esta obra al egoísmo

Prólogo Este libro evolucionó a partir del material preparado para las clases de la materia Programación Funcional, impartida para la Carrera de Licenciatura en Ciencias de la Computación de la Universidad Centroamericana José Simeón Cañas. Después de un año de trabajo, este libro incluye un recorrido por las características básicas del lenguaje Racket, en su versión 5.

Racket 5

es la nueva versión de

PLT Scheme, un sistema de programación de larga tradición

en el aprendizaje de la programación de computadoras, a través del paradigma funcional, basándose en el lenguaje Scheme. Realmente no existe, formalmente hablando, un lenguaje llamado Scheme, sino que se le llama así a una familia de lenguajes de programación funcionales (véase el capítulo 1). En este libro, se discute especícamente el dialecto conocido como Racket (anteriormente PLT Scheme), uno de los más difundidos. Si se quiere un estudio más purista sobre Scheme, revise el estándar R5RS que también es soportado por el intérprete de Racket. Los temas abordados en la Parte I incluyen una introducción a la programación funcional, una sencilla guía de instalación de Racket y una introducción a la interacción con Racket y DrRacket. En la Parte II se introduce el lenguaje Racket en sí, a través de sus elementos básicos y los bloques lambda, característicos de la programación funcional. La Parte III describe los demás elementos del lenguaje y contiene múltiples ejercicios para que el lector practique sus nuevos conocimientos. Finalmente, la Parte IV muestra las capacidades de Racket para implementar programas con interfaces graácas de usuario. Y por último, la Parte V incluye un anexo describiendo las diferencias entre la versión 5 de Racket y la serie 4.x de PLT Scheme.

7

8

Índice general I. Introducción a la Programación Funcional con Racket

17

1. Programación Funcional

19

1.1.

Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

19

1.2.

Características

20

1.3.

Lenguajes de Programación Funcionales

. . . . . . . . . . . . . . . . . . . .

20

1.4.

Ejemplos de código de lenguajes funcionales . . . . . . . . . . . . . . . . . .

21

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2. Instalación de Racket

23

2.1.

Instalación con el instalador ocial

2.2.

Instalación desde repositorios

. . . . . . . . . . . . . . . . . . . . . . .

23

. . . . . . . . . . . . . . . . . . . . . . . . . .

24

2.2.1.

Debian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

24

2.2.2.

Fedora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

25

3. Expresiones Racket - Notación Preja

27

3.1.

Notación para la sintaxis de Racket . . . . . . . . . . . . . . . . . . . . . . .

27

3.2.

Notación preja de Racket . . . . . . . . . . . . . . . . . . . . . . . . . . . .

27

4. Interacción con Racket 4.1.

4.2.

29

Ejecución interactiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29

4.1.1.

Deniciones e interacciones con DrRacket

4.1.2.

Ejecución interactiva con Racket

Ejecución no interactiva 4.2.1.

. . . . . . . . . . . . . . .

30

. . . . . . . . . . . . . . . . . . . .

30

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

31

Parámetros de la línea de comandos

. . . . . . . . . . . . . . . . . .

5. Compilación de programas Racket

31

33

5.1.

Lo básico sobre compilación . . . . . . . . . . . . . . . . . . . . . . . . . . .

33

5.2.

Compilación con múltiples módulos . . . . . . . . . . . . . . . . . . . . . . .

33

II. Introducción al lenguaje Racket

35

6. Elementos básicos

37

6.1.

Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

37

9

Índice general 6.2.

Deniciones Globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

37

6.2.1.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

38

6.3.

Llamadas a funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

39

6.4.

Bloques condicionales

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

39

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

39

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

40

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

41

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

42

6.4.1. 6.4.2. 6.4.3. 6.4.4.

Identicadores

if . . . and y or cond . . case . .

6.5.

Bloques de código secuencial . . . . . . . . . . . . . . . . . . . . . . . . . . .

43

6.6.

Más sobre llamadas a funciones . . . . . . . . . . . . . . . . . . . . . . . . .

43

7. Funciones anónimas - Bloques lambda lambda

45

7.1.

Bloques

7.2.

Funciones/Expresiones que producen funciones

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8. Asignación local 8.1. 8.2. 8.3.

define let . . let* .

45 46

49

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

49

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

50

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

50

III. Elementos del lenguaje

51

9. Listas e Iteración

53

9.1.

9.2.

Listas

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53

9.1.1.

Lista vacía o nula . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

54

9.1.2.

Funciones básicas sobre listas

. . . . . . . . . . . . . . . . . . . . . .

54

Iteración automática . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

56

9.2.4.

map . . . . . . . andmap y ormap filter . . . . . for-each . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

58

9.2.5.

Versiones generales de las funciones de iteración . . . . . . . . . . . .

59

9.2.1. 9.2.2. 9.2.3.

9.3.

Iteración manual 9.3.1.

9.4.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

56

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

56

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

57

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

59

Aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

60

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

61

9.4.1.

Pares y listas

Convención de impresión . . . . . . . . . . . . . . . . . . . . . . . . .

62

9.4.2.

Notación inja

62

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10.Recursión

10

67

10.1. Recursión por Posposición de trabajo . . . . . . . . . . . . . . . . . . . . . .

67

10.2. Recursión de Cola

67

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Índice general

11.Tipos de dato integrados del lenguaje

69

11.1. Booleanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

69

11.2. Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

70

11.2.1. Clasicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

70

Clasicación por Exactitud

. . . . . . . . . . . . . . . . . . . . . . .

70

Clasicación por Conjuntos

. . . . . . . . . . . . . . . . . . . . . . .

72

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

72

11.2.2. Otras bases

11.2.3. Comparaciones

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

73

11.2.4. Constantes especiales . . . . . . . . . . . . . . . . . . . . . . . . . . .

73

11.3. Caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

74

11.4. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

76

11.4.1. Cadenas mutables

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

11.4.2. Comparación entre cadenas

77

. . . . . . . . . . . . . . . . . . . . . . .

78

11.4.3. Otras funciones de cadena . . . . . . . . . . . . . . . . . . . . . . . .

79

11.5. Bytes y Cadenas de Bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . .

80

11.6. Símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

81

11.7. Palabras clave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

83

11.8. Pares y listas

83

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11.9. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

84

11.10.Tablas Hash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

85

11.11.Void

86

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

12.Expresiones y Deniciones Avanzadas apply lambda .

89

12.1. La función

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

89

12.2. Bloques

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

89

12.2.1. Funciones con cualquier número de parámetros

. . . . . . . . . . . .

90

. . . . . . . . . . .

90

12.2.3. Funciones con parámetros opcionales . . . . . . . . . . . . . . . . . .

91

12.2.4. Funciones con parámetros con nombre

. . . . . . . . . . . . . . . . .

92

12.2.5. Funciones con aridad múltiple . . . . . . . . . . . . . . . . . . . . . .

93

12.2.2. Funciones con un mínimo número de parámetros

12.2.6. Consultando la aridad de las funciones . . . . . . . . . . . . . . . . .

arity-at-least . . . . . . . procedure-arity . . . . . . . procedure-arity-includes?

94

. . . . . . . . . . . . . . . . . . . . . .

94

. . . . . . . . . . . . . . . . . . . . . .

95

12.3. Resultados múltiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.1. 12.3.2. 12.3.3.

values . . . . . . . . . . . . define-values . . . . . . . let-values, y let*-values

12.4. Asignaciones

94

. . . . . . . . . . . . . . . . . . . . . .

96

. . . . . . . . . . . . . . . . . . . . . . .

97

. . . . . . . . . . . . . . . . . . . . . . .

97

. . . . . . . . . . . . . . . . . . . . . . .

97

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

98

13.Tipos de dato denidos por el programador 13.1. Estructuras simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

101 101

11

Índice general 13.2. Estructuras derivadas

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

102

13.3. Estructuras transparentes y opacas . . . . . . . . . . . . . . . . . . . . . . .

104

13.4. Estructuras mutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

104

14.Módulos Funcionales

109

14.1. Visibilizando deniciones de estructuras

. . . . . . . . . . . . . . . . . . . .

15.Entrada y Salida 15.1. Imprimir datos

111 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

111

15.2. Leer datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

113

15.2.1. Lectura "básica"

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

113

15.2.2. Lectura avanzada . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

114

15.3. Tipos de Puerto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

115

15.3.1. Archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

open-input-file . . . . . open-output-file . . . . open-input-output-file

116

. . . . . . . . . . . . . . . . . . . . . . . .

116

. . . . . . . . . . . . . . . . . . . . . . . .

116

. . . . . . . . . . . . . . . . . . . . . . . .

117

Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

117

Procesamiento automatizado

118

. . . . . . . . . . . . . . . . . . . . . .

15.3.2. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

119

15.3.3. Conexiones TCP

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

120

15.4. Puertos de Entrada/Salida por defecto . . . . . . . . . . . . . . . . . . . . .

122

16.Excepciones

127

16.1. Atrapar Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

127

16.2. Las funciones error y raise . . . . . . . . . . . . . . . . . . . . . . . . . . . .

128

17.Evaluación Dinámica de Código 17.1. La función

eval

131

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

17.2. Creación y ejecución dinámica de código fuente

. . . . . . . . . . . . . . . .

18.Programación Orientada a Objetos 18.1. Denición de Clases

12

110

131 132

133

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

133

18.2. Denición de Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

133

18.3. Creación de instancias

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

133

18.4. Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

134

18.4.1. Denición e Invocación de Métodos . . . . . . . . . . . . . . . . . . .

134

18.4.2. Sustitución de métodos

. . . . . . . . . . . . . . . . . . . . . . . . .

134

18.4.3. Métodos no sustituíbles

. . . . . . . . . . . . . . . . . . . . . . . . .

135

18.5. Parámetros de inicialización . . . . . . . . . . . . . . . . . . . . . . . . . . .

135

18.6. Funciones que operan sobre clases/interfaces/objetos . . . . . . . . . . . . .

136

18.7. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

137

Índice general

IV. Interfaces Grácas de Usuario

141

19.Introducción a las interfaces grácas de usuario con Racket

143

19.1. Hola Mundo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.2. Ejecución y compilación

143

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

144

19.3. Introducción a los eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . .

144

19.4. Ventanas de diálogo

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

147

19.5. Eventos de cuadros de texto . . . . . . . . . . . . . . . . . . . . . . . . . . .

148

19.6. Páneles

150

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

20.Uso de los diversos controles de Racket

153

21.Dibujo con Lienzos

163

21.1. Dibujo en un

canvas %

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

163

canvas %

. . . . . . . . . . . . . . . . . . . . . . .

22.1. Ejemplo de editor sencillo de texto

. . . . . . . . . . . . . . . . . . . . . . .

174

22.2. Menús contextuales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

177

21.2. Interacción avanzada con

22.Menús

165

171

23.Proyecto: Minipaint

183

V. Apéndices

197

A. Diferencias entre PLT Scheme y Racket

199

13

Índice general

14

Índice de guras 2.1.

6.1.

Sitio de descarga de Racket

. . . . . . . . . . . . . . . . . . . . . . . . . . .

Gráca de ecuación seccionada

  x < −1 x + 2 f (x) = 1 −1 ≤ x < 0   2 −x + 1 0 ≤ x

24

. . . . . . .

41

19.1. hola-mundo.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

143

19.2. eventos-1.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

144

19.3. eventos-2.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

145

19.4. eventos-3.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

146

19.5. dialogo.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

147

19.6. text-eld.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

148

19.7. páneles.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

150

20.1. controles.rkt, tab 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

153

20.2. controles.rkt, tab 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

153

20.3. controles.rkt, tab 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

154

20.4. controles.rkt, tab 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

155

20.5. controles.rkt, tab 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

156

20.6. controles.rkt, tab 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

157

20.7. controles.rkt, tab 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

158

21.1. canvas1.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

163

21.2. canvas2.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

165

21.3. canvas3.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

167

21.4. canvas4.rkt

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

169

22.1. Diagrama de clases de los menús en Racket

. . . . . . . . . . . . . . . . . .

22.2. Diagrama de objetos del ejemplo 1-menús.rkt

171

. . . . . . . . . . . . . . . . .

172

22.3. 1-menús.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

173

22.4. 2-menús.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

175

22.5. 5-selección-color.rkt - menú

. . . . . . . . . . . . . . . . . . . . . . . . . . .

179

22.6. 5-selección-color.rkt - Selector de color 1 . . . . . . . . . . . . . . . . . . . .

180

22.7. 5-selección-color.rkt- Selector de color 2

181

. . . . . . . . . . . . . . . . . . . .

15

Índice de guras 23.1. mini-paint.rkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

16

183

Parte I

Introducción a la Programación Funcional con Racket

17

1 Programación Funcional La programación funcional, iniciada a nales de la década de los 50's, es aquella cuyo paradigma se centra en el Cálculo Lambda. Este paradigma es más útil para el área de inteligencia articial (ya que satisface mejor las necesidades de los investigadores en esta área), y en sus campos secundarios: cálculo simbólico, pruebas de teoremas, sistemas basados en reglas y procesamiento del lenguaje natural. La característica esencial de la programación funcional es que los cálculos se ven como una función matemática que hace corresponder entradas y salidas.

1.1. Objetivo El objetivo es conseguir lenguajes expresivos y matemáticamente elegantes, en los que no sea necesario bajar al nivel de la máquina para describir el proceso llevado a cabo por el programa, y evitando el concepto de estado del cómputo. Los lenguajes funcionales tienen el propósito de acercar su notación a la notación normal de la matemática, cosa que no ocurre, por ejemplo, con los lenguajes imperativos (como

C

o

Java ).

El estado de cómputo o estado de cálculo o estado de programa, se entiende como un registro (con una o más variables) del estado en el que se encuentra el programa en un momento dado. En la práctica, este registro del estado de un programa, se implementa con variables globales, de las que depende el curso de ejecución de alguna parte del programa. Por ejemplo, considere el siguiente código en lenguaje

1 2 3 4 5 6 7 8 9 10 11 12 13

C:

// Archivo : no - funcional . c # include < stdio .h > int variable_contador = 0; int aumentar_contador ( int incremento ) { variable_contador += incremento ; return variable_contador ; } void mostrar_contador ( void ) { printf ( " El valor del contador es : %d \ n " , variable_contador ) ; }

14

19

1 Programación Funcional 15 16 17 18 19 20 21 22

int main ( void ) { mostrar_contador () ; aumentar_contador (5) ; mostrar_contador () ; aumentar_contador (10) ; mostrar_contador () ; return 0; } En este pequeño programa, se puede decir que

variable_contador representa el estado del

programa.

1.2. Características Los programas escritos en un lenguaje funcional están constituidos únicamente por deniciones de funciones, entendiendo éstas, no como subprogramas clásicos de un lenguaje imperativo, sino como funciones puramente matemáticas, en las que se verican ciertas

transparencia referencial. La transparencia referencial, signica que el signicado de una expresión depende únicamente del signicado de sus subexpresiones o parámetros, no depende de cálculos previos ni del orden de evaluación de sus parámetpropiedades como la

ros o subexpresiones, y por tanto, implica la carencia total de efectos colaterales. No hay algo como el estado de un programa, no hay variables globales. En el caso del programa

no-funcional.c,

presentado arriba, el resultado de la expresión

no sólo depende del número

10,

aumentar_contador(10)

sino de otra variable ajena a la función.

Otras características propias de estos lenguajes (consecuencia directa de la ausencia de estado de cómputo y de la transparencia referencial) son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (no hay

for, ni while, etc.). Esto obliga en la práctica, a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas.

1.3. Lenguajes de Programación Funcionales Existen dos grandes categorías de lenguajes funcionales: los funcionales puros y los funcionales híbridos. La diferencia entre ambos radica en que los lenguajes funcionales híbridos son menos dogmáticos que los puros, al incluir conceptos tomados de los lenguajes imperativos, como las secuencias de instrucciones o la asignación de variables. En contraste, los lenguajes funcionales puros tienen una mayor potencia expresiva, conservando a la vez su transparencia referencial, algo que no se cumple siempre con un lenguaje funcional híbrido. Sin embargo, es de mencionar que en un lenguaje de programación funcional puro, en la práctica, sería muy difícil programar sistemas; aunque son muy buenos para aplicaciones eminentemente matemáticas.

20

1.4 Ejemplos de código de lenguajes funcionales Entre los lenguajes funcionales puros, cabe destacar a Haskell y Miranda. Los lenguajes funcionales híbridos más conocidos son Lisp, los dialectos de Scheme y Ocaml. Erlang es un lenguaje funcional de programación concurrente. R es un lenguaje funcional dedicado a la estadística. Mathematica y Maxima son también lenguajes/entornos funcionales, orientados totalmente al álgebra simbólica. Entre otros lenguajes que se podrían utilizar para programación funcional, se podrían incluir a Perl, usando exclusivamente funciones denidas por el usuario. Así como Python, como lenguaje que incorpora el paradigma funcional.

1.4. Ejemplos de código de lenguajes funcionales En Haskell:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

-- Función recursiva para calcular el factorial de un número factorial :: Integer -> Integer factorial n = if n ==0 then 1 else n * factorial ( n - 1) -- Sumar elementos de una lista sumar :: [ Integer ] -> Integer sumar [] = 0 sumar ( x : xs ) = x + sumar ( xs ) -- Función para calcular el valor de e (2.71828182845905) euler :: Double -> Double euler 0.0 = 1.0 euler n = 1.0 / product [1.. n ] + euler ( n - 1.0) En Miranda:

1 2

|| Lista de cuadrados de n donde n es tomado de la lista de todos los enteros positivos : squares = [ n * n | n 0 | x :: xs -> 1 + long xs ;; En Erlang:

1 2

fac (0) -> 1; fac ( N ) when N > 0 -> N * fac (N -1) .

21

1 Programación Funcional En Python:

1 2 3 4 5 6 7 8 9 10 11 12

>>> vec = [2 , 4 , 6] >>> [3* x for x in vec ] [6 , 12 , 18] >>> [3* x for x in vec if x > 3] [12 , 18] >>> [[ x , x **2] for x in vec ] [[2 , 4] , [4 , 16] , [6 , 36]] >>> >>> >>> [8 ,

22

vec1 = [2 , 4 , 6] vec2 = [4 , 3 , -9] [ x * y for x in vec1 for y in vec2 ] 6 , -18 , 16 , 12 , -36 , 24 , 18 , -54]

2 Instalación de Racket 2.1. Instalación con el instalador ocial A continuación de describen los pasos básicos de instalación: 1. Vaya al sitio http://racket-lang.org/download/ y descargue el instalador correspondiente o más cercano a su distribución, tal como se muestra en la gura 2.1. 2. El archivo descargado es un

.sh, por lo que hay que asignarle los permisos de ejecución, 1

necesarios para poder ejecutarlo :

$ chmod u+x racket-xxxx.sh $ ./racket-xxxx.sh 3. A continuación, el instalador pregunta si se desea hacer una instalación tipo Unix o una instalación en una sóla carpeta. La opción por defecto es no hacer una instalación tipo Unix. 4. Luego se pregunta en cuál carpeta se desea realizar la instalación (en caso de haber respondido no en el paso anterior. La opción por defecto es

/usr/plt,

para la cual

se requiere tener permisos de superusuario. También se puede instalar en la carpeta del usuario o en cualquier otra. 5. A continuación se procede a realizar la instalación en la carpeta elegida y aquí termina la instalación. Automáticamente se instalan las páginas de la documentación ocial de Racket en la carpeta de instalación elegida. Si la carpeta de instalación elegida no fue en la carpeta del usuario, es muy probable que la carpeta de la documentación sea

/usr/share/doc/plt,

o

/usr/plt/doc/.

/usr/share/plt, index.html.

En esta carpeta habrá un archivo

En todo caso, con el comando

$ raco docs se lanza la página del índice de la documentación instalada con el navegador por defecto del Sistema Operativo.

1

o simplemente ejecutar: $ sh racket-xxxx.sh

23

2 Instalación de Racket

Figura 2.1: Sitio de descarga de Racket

2.2. Instalación desde repositorios 2

Por el momento , las distribuciones de GNU/Linux no incluyen la nueva versión (la 5.0) de

Racket.

En su lugar, todavía incluyen la serie 4.x de

3

PLT Scheme

(que es completamente

compatible con todo el contenido de este libro , en esta primera versión). Es sólo cuestión

PLT Scheme, Racket, se encuentre en los repositorios de las distribuciones más difundidas. de tiempo (unos 6 meses o un año) para que la nueva versión de

llamada

El proceso de instalación es en general muy sencillo. Especialmente cuando usamos una distribución de GNU/Linux que contiene a

PLT Scheme

en sus repositorios.

2.2.1. Debian En distribuciones basadas en

Debian, basta con instalar el paquete plt-scheme:

# apt-get install plt-scheme

También sería buena idea, instalar el paquete

plt-scheme-doc que instala la documentación

ocial de la versión instalada por el paquete anterior. Con este paquete, está disponible la página

2 3

/usr/share/plt/doc/index.html

Al momento de escribir este libro véase el apéndice A

24

que es el índice de la documentación.

2.2 Instalación desde repositorios Para instalar la documentación junto con el programa, ejecute el siguiente comando:

# apt-get install plt-scheme plt-scheme-doc

2.2.2. Fedora En distribuciones

Fedora, basta con instalar el paquete plt-scheme:

# yum install plt-scheme

En esta distribución no se encuentra la documentación como paquete, por lo que hay que consultarla en línea, o descargarla.

25

2 Instalación de Racket

26

3 Expresiones Racket - Notación Preja 3.1. Notación para la sintaxis de Racket Desde este momento en adelante, se utilizará la siguiente notación tipo BNF para explicar la sintaxis del lenguaje: Todas las secuencias de caracteres delimitadas por terminales. Por ejemplo:

.

<

y

>

representan símbolos no

Todas las secuencias de caracteres no delimitadas, representan símbolos terminales. Por ejemplo:

define, (, ), let.

El metaagrupamiento se hace con llaves:

{

y

}.

El metasímbolo

+,

indica al menos una ocurrencia del símbolo precedente.

El metasímbolo

*,

indica ninguna, una o varias ocurrencias del símbolo precedente.

3.2. Notación preja de Racket En Racket, todas las expresiones tienen la forma:

( *),

es decir,

que están siempre en notación preja con pareamiento completo:

(* (> (+ (+

2 5 2 4

3) -> equivale a (2 * 3) 6)-> equivale a (5 > 6) 3 10)-> equivale a (2 + 3 + 10) (* 3 2))-> equivale a (4 + 3 * 2)

Por ejemplo, la expresión inja

5a + 2bc2

es:

(+ (* 5 a) (* 2 b c c)).

27

3 Expresiones Racket - Notación Preja

28

4 Interacción con Racket Dependiendo de cómo se vea, Racket es: un lenguaje de programación, una familia de lenguajes de programación, variantes de Scheme, que a su vez, es un dialecto de Lisp; o un conjunto de herramientas de programación. Racket tiene básicamente dos herramientas principales:

racket,

el compilador, intérprete y sistema de ejecución interactiva; y

DrRacket, un IDE que corre sobre

racket

(es decir, que lo usa como motor de ejecu-

ción y compilación). En el caso de

DrRacket1 , debe especicarse el lenguaje en particular que se va a utilizar, ya

que este Entorno se acomoda a diversas variantes de Scheme soportadas por el intérprete

racket.

y compilador

En nuestro caso particular, usaremos la opción Usar el lenguaje

declarado en el código fuente. Cuando se selecciona esta opción, en el área de texto para escribir el programa, aparece la línea:

#lang racket Esta línea, al inicio de cualquier archivo de texto, indica que el código a continuación, es la variante más completa (en términos de bibliotecas disponibles y capacidad del lenguaje) de todas las variantes soportadas por Racket, conocido como

Lenguaje Racket.

Cuando se ejecuta el Racket en la línea de comandos (con el comando

racket),

el lenguaje

por omisión es esta variante.

4.1. Ejecución interactiva La parte de abajo de la interfaz de DrRacket (comando de comandos

racket,

drracket), y la herramienta de línea

funcionan como un área de interacciones, al estilo de una terminal

normal. En ella, se puede escribir una expresión (aquí no hay comandos, ni instrucciones), presionar Intro y el intérprete devuelve el resultado de la expresión.

1

Para mayor información sobre DrRacket, léase la documentación ocial de DrRacket.

29

4 Interacción con Racket Por ejemplo:

1 2 3 4 5 6 7 8

> 5 5 > (+ ( sqr 4) ( sqr 3) ) 25 > " ½Hola Mundo !" " ½Hola Mundo !" > ( substring " ½Hola Mundo !" 6 11) " Mundo " En la última expresión, se invocó a una función llamada

substring,

con tres parámetros:

una cadena, y dos números enteros.

4.1.1. Deniciones e interacciones con DrRacket Se pueden denir funciones propias, basándose en otras funciones como

substring.

Para

ello, en el área de deniciones (el área de texto superior) se escribe algo como:

1 2 3 4 5 6

# lang racket ; extraer . rkt ( define ( extraer str ) ( substring str 4 7) ) Presionar el botón Run y luego, en el área de interacciones (la terminal de abajo), ya se puede invocar esa función:

1 2 3 4

> ( extraer "1234567890") "567" > ( extraer " este es un texto con muchos caracteres ") " es "

4.1.2. Ejecución interactiva con Racket Para poder hacer esto mismo con

racket,

archivo (por convención, con extensión

primero hay que guardar las deniciones en un

.rkt), por ejemplo en un archivo llamado extraer.rkt.

Entonces, en la línea de comandos, hacemos:

1 2 3

> ( enter ! " extraer . rkt ") > ( extraer "1234567890") "567" La función

enter!

carga el archivo pasado como parámetro y cambia el contexto de evalu-

ación a las deniciones del archivo, igual que el botón Run de DrRacket.

30

4.2 Ejecución no interactiva

4.2. Ejecución no interactiva Si tiene el archivo:

1 2 3 4 5 6 7 8

# lang racket ; extraer2 . rkt ( define ( extraer str ) ( substring str 4 7) ) ( extraer "1234567890") Ese es un programa completo que imprime en pantalla

567

cuando se ejecute.

Para ejecutarlo, vaya la línea de comandos:

1 2 3

$ racket extraer2 . rkt " 567 " $ Se dice que es ejecución no interactiva porque uno no puede invocar a voluntad funciones denidas en el archivo. Sólo se ejecutan las deniciones y llamadas que se encuentran en el archivo. Sin embargo, los programas pueden ser interactivos en el sentido que el curso de la ejecución se puede cambiar en tiempo de ejecución.

4.2.1. Parámetros de la línea de comandos La ejecución de un programa, puede controlarse, por ejemplo, con parámetros de la línea de comandos. Esto se logra con la función

current-command-line-arguments que retorna un

vector inmutable de cadenas inmutables, una por cada parámetro. Por ejemplo, considere el siguiente programa:

1 2 3 4 5 6

# lang racket ; linea - de - comandos . rkt ( display " Los parámetros pasados al programa son : \ n ") ( write ( current - command - line - arguments ) ) ( newline ) Puede ejecutarlo así:

$ racket linea-de-comandos.rkt hola, "esta es" una prueba Y la salida sería:

Los parámetros pasados al programa son: #("hola," "esta es" "una" "prueba")

31

4 Interacción con Racket

32

5 Compilación de programas Racket 5.1. Lo básico sobre compilación Como parte de Racket, se incluye el programa

raco que es la herramienta de compilación de $ raco --help.

Racket. Puede obtener una breve descripción de todas sus posiblidades con

La compilación de un programa Racket es muy sencilla. Suponga que tiene el programa:

1 2 3

# lang racket ; hola . rkt ( display " ½Hola Mundo !\ n ") Se compila así:

$ raco exe -o ejecutable hola.rkt Para ejecutarlo, dependiendo de la conguración de la terminal:

1 2 3

$ ./ ejecutable ½Hola Mundo ! $

5.2. Compilación con múltiples módulos El hecho de tener un programa separado en módulos funcionales, no afecta el proceso de compilación. Simplemente hay que compilar el archivo que contiene la ejecución inicial de nuestra aplicación. Por ejemplo, considere los siguientes dos archivos:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# lang racket ; principal . rkt ( require " secundario . rkt ") ( define parámetros ( current - command - line - arguments ) ) ( función - pública " hola ") ( función - pública constante - de - módulo ) ( if (( vector - length parámetros ) . > . 0) ( for - each función - pública ( vector - > list parámetros ) ) ( display " No se pasaron parámetros \ n ") ) ( display " ½Adiós !\ n ")

33

5 Compilación de programas Racket 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# lang racket ; secundario . rkt ( provide función - pública constante - de - módulo ) ( define constante - de - módulo " Esta constante está en secundario . rkt ") ( define ( función - pública parámetro ) ( función - privada parámetro ) ) ( define ( función - privada parámetro ) ( display " Esta es una función declarada e implementada en secundario . rkt \ n ") ( display " El parámetro pasado es : ") ( write parámetro ) ( newline ) ) " Cuando se importa un módulo , se ejecuta como un script " Y para compilarlos, simplemente se hace:

$ raco exe -o ejecutable principal.rkt Y para ejecutar el programa:

$ ./ejecutable "otros parámetros" unidos "Cuando se importa un módulo, se ejecuta como un script" Esta es una función declarada e implementada en secundario.rkt El parámetro pasado es: "hola" Esta es una función declarada e implementada en secundario.rkt El parámetro pasado es: "Esta constante está en secundario.rkt" Esta es una función declarada e implementada en secundario.rkt El parámetro pasado es: "otros parámetros" Esta es una función declarada e implementada en secundario.rkt El parámetro pasado es: "unidos" ½Adiós! $

34

Parte II

Introducción al lenguaje Racket

35

6 Elementos básicos A continuación se presenta un recorrido por las principales y más básicas partes del lenguaje Racket.

6.1. Comentarios Los comentarios son elementos escenciales en todo lenguaje de programación, ya que permiten que el programador aclare la futura lectura del código fuente. En Racket, los comentarios de una línea comienzan con delimitados por

#|

y

|#.

;

y los comentarios de bloque son

Ejemplo:

1 2 3 4 5 6 7 8

# lang racket ; Todos los programas Racket deben comenzar con esta línea de arriba . #|

Este es un comentario en Racket , que tiene varias líneas .

|# ( display " Bueno , esto no es comentario , es código \ n ") ;; Esto sí ; -)

6.2. Deniciones Globales Una denición de la forma

(define ) le asigna a el resultado de

evaluar

.

Una denición de la forma

(define ( *) + ) le asigna al primer una función (o procedimiento) que toma tantos argumentos como es restantes haya dentro de los paréntesis. El cuerpo de la función es la serie + y cuando la función es llamada, devuelve el resultado de la última . Ejemplo:

37

6 Elementos básicos 1 2 3 4 5 6 7 8 9 10 11 12 13

( define máximo 3) ( define ( prefijo str ) argumento ( substring str 0 máximo ) )

; Define que máximo es 3 ; Define que prefijo es una función de un

> máximo 3 > ( prefijo " Hola , ¾cómo estás ?") " Hol " > prefijo # < procedure : prefijo > > substring # < procedure : substring > Una función puede tener múltiples expresiones, pero la función sólo devuelve el resultado de la última:

1 2 3 4 5 6 7 8 9

( define ( hornear sabor ) ( printf " Precalentando el horno para ...\ n ") " Esta cadena es completamente ignorada " ( string - append " pastel de " sabor ) ) > ( hornear " manzana ") Precalentando el horno para ... " pastel de manzana "

6.2.1. Identicadores Los identicadores en Racket son muy liberales. A diferencia de otros lenguajes de programación que restringen mucho los caracteres válidos para sus identicadores, en Racket, prácticamente no hay restricciones. Los únicos caracteres no válidos en los identicadores son:

\.

( ) [ ] { }  , ' ` ; # |

Tampoco se pueden utilizar identicadores que se correspondan con literales numéricos

y tampoco están permitidos los espacios dentro de los identicadores.

variable-con-guiones, variable+con+más-y-t 123abc, +-, ¾variable-interrogativa???,  23..4,  variable/dividida, etc. Por lo demás, se pueden utilizar identicadores como

Y, puesto que, el intérprete racket procesa archivos Unicode, los identicadores pueden contener y estar formados por cualesquiera caracteres válidos en esa codicación (se recomienda que los archivos de código fuente estén en codicación UTF-8). Por ejemplo, las siguientes declaraciones son válidas para el intérprete de Racket:

> (define áéíóúü-en-español 1) > (define üäöÿ-deutsch 2) > (define eho san go- ciu aude-en-Esperanto 3)

38

6.3 Llamadas a funciones

6.3. Llamadas a funciones Típicamente una llamada a función tiene la forma

( *) donde la secuencia de expresiones determina el número de parámetros reales pasados a la función referenciada por el identicador. Por ejemplo

piña).

(prefijo hola)

Racket dene muchas funciones integradas del lenguaje. Por ejemplo

string-length, string?, sqrt, +, -, =, number?, equal?,

o

(hornear

string-append, substring,

etc.

6.4. Bloques condicionales 6.4.1. if La forma de un bloque condicional en Racket es:

(if ) Cuando se evalúa un

if, se evalúa la primera expresión. Si esta resulta verdadera, se retorna

el resultado de la segunda expresión, y de lo contrario, el resultado de la tercera. Por ejemplo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

> ( if ( < 1 2) " menor " " mayor ") " menor " > ( if ( positive ? ( sqrt 4) ) " sí es positivo " " no es positivo ") " sí es positivo " > ( define ( responder - saludo s ) ( if ( equal ? " hola " ( substring s 0 4) ) " ½hola , gusto de verte !" " ¾perdón ?" ) ) > ( responder - saludo " hola programa ") " ½hola , gusto de verte !" > ( responder - saludo " El día está muy bonito , ¾verdad ?") " ¾perdón ?" Como en otros lenguajes de programación, las sentencias condicionales (así como muchas otras cosas) se pueden anidar dentro de otras:

39

6 Elementos básicos 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

> ( define ( responder - saludo s ) ( if ( string ? s ) ( if ( equal ? " hola " ( substring s 0 4) ) " ½hola , gusto de verte !" " ¾perdón ?" ) " perdón , ¾qué ?" ) ) > ( responder - saludo " hola programa ") " ½hola , gusto de verte !" > ( responder - saludo 3.1416) " perdón , ¾qué ?" > ( responder - saludo " El día está muy bonito , ¾verdad ?") " ¾perdón ?" Esto también se podría escribir como:

1 2 3 4 5 6 7 8

> ( define ( responder - saludo s ) ( if ( if ( string ? s ) ( equal ? " hola " ( substring s 0 4) ) #f) " ½hola , gusto de verte !" " perdón , ¾qué ?" ) )

6.4.2. and y or y

or

y retorna

#t

En Racket, las funciones lógicas de conjunción y disyunción, son respectivamente y su sintaxis es:

(and *)

La primera retorna

#f

#t

y retorna

#f

(or *).

si encuentra que uno de sus parámetros se evalúa a

en caso contrario. La segunda retorna a

y

#t

#f,

and

si encuentra que uno de sus parámetros se evalúa

en caso contrario. Funcionan como se espere que funcionen en otros

lenguajes de programación, y además funcionan en cortocircuito (como en otros lenguajes como

C

y

Java ).

Ejemplo:

1 2 3 4 5 6 7 8 9

> ( and ( < 3.1416 ( expt 10.1424 3.8) ) ( not ( negative ? pi ) ) ) #t > ( define ( responder - saludo s ) ( if ( and ( string ? s ) ( >= ( string - length s ) ( string - length " hola ") ) ( equal ? " hola " ( substring s 0 4) ) ) " ½hola , gusto de verte !"

40

6.4 Bloques condicionales

Figura 6.1: Gráca de ecuación seccionada

10 11 12

)

  x < −1 x + 2 f (x) = 1 −1 ≤ x < 0   2 −x + 1 0 ≤ x

" perdón , ¾qué ?" )

6.4.3. cond Una forma de bloques condicionales anidadas (if anidados) es:

(cond { [ * ] }* ) Este bloque condicional contiene una secuencia de cláusulas entre corchetes. En cada cláusula, la primera expresión es una expresión de prueba o evaluación. Si esta se evalúa a verdadero, entonces las restantes cláusulas del grupo son evaluadas, y la sentencia completa retorna el valor de la última expresión de esa cláusula; el resto de las cláusulas son ignoradas. Si la evaluación de la expresión de prueba se evalúa a falso, entonces el resto de las expresiones de la cláusula son ignoradas y la evaluación continúa con la próxima cláusula. La última cláusula puede usar la constante else que es un sinónimo para

#t.

41

6 Elementos básicos Por ejemplo (ver la gura 6.1):

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

> ( define ( seccionada x ) ( cond [( < x -1) (+ x 2) ] [( and ( >= x -1) ( < x 0) ) 1] [( >= x 0) (+ ( - ( sqr x ) ) 1) ]) )

>

19 20 21 22 23 24 25

28 29 30 31 32 33 34

; -1 ( seccionada 1) 0

17

26

;

> ( responder - más " No sé " > ( responder - más " ½hola , gusto de > ( responder - más " perdón , ¾qué ?" > ( responder - más " ½nos vemos , que

" ¾hoy ?") " hola pepe ") verte !" " la derivada de la función exponencial es ella misma ") " adiós programa ") te vaya bien !"

En Racket, el uso de paréntesis y corchetes es completamente intercambiable, mientras un

(

se cierre con un

)

y un

[

se cierre con un

]

no hay problema. Sin embargo, el uso de

corchetes junto a los paréntesis hace del código Racket ligeramente más legible.

6.4.4. case Los bloques

case

sirven para corresponder el resultado de una expresión con una serie de

valores y evaluar diferentes expresiones en función de eso. La sintaxis básica es:

(case { [ ( + ) + ] }* ) Por ejemplo:

1

> ( case (+ 7 5)

42

6.5 Bloques de código secuencial 2 3 4 5 6 7 8 9 10 11 12 13

[(1 2 3) " pequeño "] [(10 11 12) " grande "]) " grande " > ( case ( - 7 5) [(1 2 3) " pequeño "] [(10 11 12) " grande "]) " pequeño " > ( case (* 7 5) [(1 2 3) " pequeño "] [(10 11 12) " grande "] [ else " fuera de rango "]) " fuera de rango "

6.5. Bloques de código secuencial En la idea básica del paradigma funcional, no existe algo como la

secuencia de instrucciones,

pero como Racket es híbrido, sí disponde esta característica. La secuencia de instrucciones está presente de manera nativa en los bloques y

let,

dispone del bloque

1 2 3 4 5 6 7 8 9 10

lambda, define (para funciones), cond, case

por lo que esas alternativas suelen bastar. Pero para aquellos casos en los que no, se

begin:

> ( if ( < 5 6) ( begin ( display " Aquí podemos escribir muchas cosas \ n ") " Pero sólo el último elemento será el resultado " " cinco es menor que seis " ) " cinco no es menor que seis " ) Aquí podemos escribir muchas cosas " cinco es menor que seis "

6.6. Más sobre llamadas a funciones Racket es un lenguaje muy potente y muy expresivo. Las llamadas a funciones, no sólo pueden hacerse utilizando directamente los identicadores de las funciones. También pueden hacerse utilizando expresiones que devuelvan referencias a funciones. Así, la sintaxis de llamadas a funciones se puede ampliar

1 como:

( * ) La

,

debe ser una expresión cuyo resultado sea

una función.

Por ejemplo:

1

Esta aún no es la forma más general

43

6 Elementos básicos 1 2 3 4 5 6 7

> ( define ( duplicar valor ) (( if ( string ? valor ) string - append +) valor valor ) ) > ( duplicar " cadena ") " cadenacadena " > ( duplicar 3) 6 Aquí, el bloque Si la

if

retorna una función a través de su nombre (string-append o



+).

no devolviera una función, se generaría un error, ya que el

primer elemento dentro de los paréntesis debe ser una función. Por ejemplo, la siguiente expresión:

> (1 2 3) produce el error:

procedure application: expected procedure, given: 1; arguments were: 2 3 Note que, puesto que una función puede ser devuelta por una expresión, una función también puede se pasada como parámetro a otra función:

1 2 3 4 5 6

> ( define ( componer función valor ) ( función ( función valor ) ) ) > ( componer sqrt 256) 4 > ( componer sqr 2) 16

44

7 Funciones anónimas - Bloques

lambda

Considere la siguiente expresión:

(+ 5 4) Es equivalente a:

1 2 3 4

( define a 5) ( define b 4) ... (+ a b ) La segunda forma sería innecesariamente larga si los valores de a y b sólo se utilizarán una vez. De la misma manera, cuando una función sólo se llama una vez, tener que declararla es innecesariamente largo. Por ello, Racket incluye la posibilidad de escribir funciones anónimas. Por ejemplo:

1 2 3 4

> ( define ( poner - admiración s ) ( string - append " ½ " s "!") ) > ( componer poner - admiración " hola ") " ½½hola !!"

poner-admiración sólo llamará cuando se llame una vez a componer. Entonces puede escribir la función poner-admiración directamente en la llamada a componer desde donde será invocada. Entonces se usan los bloques lambda.

Pero suponga que la función

7.1. Bloques lambda En Racket así como en muchos otros lenguajes de programación, un

bloque lambda

produce una función directamente, sin tener que declararla. El bloque lambda tiene la siguiente sintaxis:

(lambda ( * ) + ) La serie de identicadores se corresponde, uno a uno, con los parámetros formales de la función a producir; y las expresiones son el cuerpo de la función. Como en la declaración

45

7 Funciones anónimas - Bloques lambda tradicional de funciones (con

define)1 ,

el resultado de la función (cuando se llame), es el

resultado de la última expresión del cuerpo del bloque La evaluación de un bloque

1 2

2 3 4

produce en sí misma una función:

> ( lambda ( s ) ( string - append " ½ " s "!") ) # < procedure > Entonces, usando

1

lambda,

lambda.

lambda,

la llamada a componer puede ser reescrita como:

> ( componer ( lambda ( s ) ( string - append " ½ " s "!") ) " hola ") " ½½hola !!" > ( componer ( lambda ( s ) ( string - append " ¾½ " s "!?") ) " hola ") " ¾½¾½hola !?!?"

7.2. Funciones/Expresiones que producen funciones Otro uso de

lambda

es como resultado para una función (o expresiones) que produce fun-

ciones:

1 2 3 4 5 6 7 8 9

> ( define ( hacer - Agregar - afijos prefijo sufijo ) ( lambda ( s ) ( string - append prefijo s sufijo ) ) ) > ( componer ( hacer - Agregar - afijos " ") " hola ") " < < hola > >" > ( componer ( hacer - Agregar - afijos " ½ " "!") " hola ") " ½½hola !!" > ( componer ( hacer - Agregar - afijos " < >") " hola ") " < < < < hola > > > >" También pueden asignarse el resultado de una función que retorna funciones a un identicador:

1 2 3 4 5 6

> ( define poner - admiración ( hacer - Agregar - afijos " ½ " "!") ) > ( define menos - seguro ( hacer - Agregar - afijos " ¾ " "?!") ) > ( componer menos - seguro " ah nombre ") " ¾¾ah nombre ?!?!" > ( componer poner - admiración " en serio ") " ½½en serio !!" También puede asignarse directamente un bloque

lambda a un identicador. Las siguientes

dos deniciones son equivalentes:

1 2 3 4

> ( define ( poner - admiración s ) ( string - append " ½ " s "!") ) > ( define poner - admiración 1

En realidad, lo tradicional, es usar lambda para denir funciones.

46

7.2 Funciones/Expresiones que producen funciones 5 6 7 8 9

( lambda ( s ) ( string - append " ½ " s "!") )) > poner - admiración # < procedure : poner - admiración >

47

7 Funciones anónimas - Bloques lambda

48

8 Asignación local Hay al menos tres formas de hacer asignación local en Racket: Con

let*.

define,

con

let

y con

8.1. define Hagamos otra ampliación de la sintaxis para los bloques de funciones:

(define ( * ) * + ) y

( lambda ( * ) * + ) La diferencia con respecto a la sintaxis anteriormente mostrada, es que hay un bloque opcional de deniciones antes del cuerpo de la función. Por ejemplo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

> ( define ( conversar s ) ( define ( ¾comienza - con ? prefijo ) ; local a conversar ( define longitud - prefijo ( string - length prefijo )) ; local a ¾comienza - con ? ( and ( >= ( string - length s ) longitud - prefijo ) ( equal ? prefijo ( substring s 0 longitud - prefijo ) ) ) ) ( cond [( ¾comienza - con ? " hola ") " hola , ¾qué ondas ?"] [( ¾comienza - con ? " adiós ") " adiós , nos vemos "] [ else " ¾ah ?"]) ) > ( conversar " hola programa ") " hola , ¾qué ondas ?" > ( conversar " hace frío en los talleres ") " ¾ah ?" > ( conversar " adiós programa ") " adiós , nos vemos " > ¾comienza - con ? reference to an identifier before its definition : ¾comienza - con ? Todas las deniciones dentro de la denición de una función, son locales a ella, y por tanto, invisibles desde fuera de ella. Como todo en Racket, las deniciones se pueden anidar indenidamente unas dentro de otras.

49

8 Asignación local

8.2. let Otra forma de hacer asignaciones locales, es con el bloque bre

define

let.

Una ventaja de

let

so-

es que puede ser colocada en cualquier lugar dentro de una expresión y no

sólo al principio de la función, como

define.

Además, con

asignaciones al mismo tiempo, en lugar de hacer un

define

let

se pueden hacer múltiples

para cada asignación.

let es: (let ( { [ ] }* ) + )

La sintaxis de

Cada cláusula de asignación es un



y una



rodeadas por

corchetes, y las expresiones que van después de las cláusulas, son el cuerpo del cada cláusula, al



se le asigna el resultado de la

usado dentro del cuerpo. Fuera del bloque

let,



let.

En

para ser

los identicadores no son visibles.

Por ejemplo:

1 2 3 4 5 6 7 8 9 10 11

> ( let ([ x 1] [ y 2]) ( display ( string - append " La suma de " ( number - > string x ) " más " ( number - > string y ) " es : " ( number - > string (+ x y ) ) ) ) ) La suma de 1 más 2 es : 3 > (+ x y ) reference to an identifier before its definition : x

8.3. let* Las asignaciones de

let están disponibles sólo en el cuerpo del let, así que las cláusulas de let*, por el contrario, permite que

asignación no se pueden referir unas a otras. El bloque cláusulas posteriores, referencien cláusulas anteriores:

1 2 3 4 5

> ( let * ([ x 1] [ y 2] [ z (+ x y ) ]) ( printf " La suma de ~ a y ~ a es : ~ a " x y z ) ) La suma de 1 y 2 es : 3

50

Parte III

Elementos del lenguaje

51

9 Listas e Iteración En este capítulo se describen los pares y sus casos particulares, las listas. Además, se describen los mecanismos propios de Racket para procesar y recorrer listas.

9.1. Listas Las listas son el tipo de dato más prominente de Racket, como dialecto de Scheme y a su vez de Lisp. No es de extrañar que haya funciones especialmente avanzadas y de alto nivel para procesar y manipular listas. Hay varias maneras diferentes de crear listas en Racket. La principal de ellas es utilizando la función

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

list:

> ( list " rojo " " verde " " azul ") (" rojo " " verde " " azul ") > ( list 1 2 3 4) (1 2 3 4) > ( list ( exp 1) ( sqrt 2) ) (2.718281828459045 1.4142135623730951) > ( list " cadena " 123 9.87654) (" cadena " 123 9.87654) > ( define mi - lista ( list " a " 2 3.1416) ) > mi - lista (" a " 2 3.1416) Otra forma, es utilizar la notación tradicional de Lisp, con apóstrofe:

1 2 3 4 5 6 7

> '(" otra lista " " con números " 3 4 5.322) (" otra lista " " con números " 3 4 5.322) > ( define mi - lista '(" otra lista " " con números " 3 4 5.322) ) > mi - lista (" otra lista " " con números " 3 4 5.322)

53

9 Listas e Iteración

9.1.1. Lista vacía o nula La lista vacía, se puede escribir de diversas maneras en Racket: Invocando a la función

list

sin parámetros:

Con la constante especial

empty

Con la constante especial

null

Con la forma tradicional de Lisp:

'()

(list)

, que es un caracter de apóstrofe seguido de

paréntesis vacíos. Para vericar si una expresión se evalúa a una lista vacía, se pueden utilizar también varias funciones: La función de evaluación lógica La función

empty?: (if (empty? L) vacía no vacía)

null?: (if (null? L) vacía no vacía)

Ejemplos:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

> '() () > empty () > null () > ( list ) () > (( lambda ( L ) ( if ( empty ? L ) " vacía " " no vacía ") ) null ) " vacía " > (( lambda ( L ) ( if ( empty ? L ) " vacía " " no vacía ") ) '() ) " vacía " > (( lambda ( L ) ( if ( null ? L ) " vacía " " no vacía ") ) empty ) " vacía " > (( lambda ( L ) ( if ( null ? L ) " vacía " " no vacía ") ) '(" a ") ) " no vacía "

9.1.2. Funciones básicas sobre listas length

para vericar la longitud de una lista

list-ref

para extraer el i-ésimo elemento de una lista (los índices comienzan desde

cero, como en la mayoría de lenguajes de programación).

54

9.1 Listas append

para unir listas

reverse member list?

para invertir el orden de una lista

para vericar si un elemento está en una lista

para vericar si un identicador se corresponde con una lista (que puede estar

vacía)

Ejemplos:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

> '(" cero " 1 " dos " 3 " cuatro " 5.322) (" cero " 1 " dos " 3 " cuatro " 5.322) > ( length '(" cero " 1 " dos " 3 " cuatro " 5.322) ) 6 > ( list - ref '(" cero " 1 " dos " 3 " cuatro " 5.322) 2) " dos " > ( list - ref '(" cero " 1 " dos " 3 " cuatro " 5.322) 5) 5.322 > ( list - ref '(" cero " 1 " dos " 3 " cuatro " 5.322) 6) list - ref : index 6 too large for list : (" cero " 1 " dos " 3 " cuatro " 5.322) > ( append '(" cero " 1 " dos " 3 " cuatro " 5.322) ( list " a " " b " " c ") ( list " un elemento ") ) (" cero " 1 " dos " 3 " cuatro " 5.322 " a " " b " " c " " un elemento ") > ( reverse '(" cero " 1 " dos " 3 " cuatro " 5.322) ) (5.322 " cuatro " 3 " dos " 1 " cero ") > ( member " seis " '(" cero " 1 " dos " 3 " cuatro " 5.322) ) #f > ( if ( member " cero " '(" cero " 1 " dos " 3 " cuatro " 5.322) ) " sí está " " no está ") " sí está " > ( list ? empty ) #t > ( list ? 4) #f > ( list ? '(" hola ") ) #t

55

9 Listas e Iteración

9.2. Iteración automática En Racket no hay ciclos

for o while1 , por lo que se utilizan ciertas funciones predenidas,

propias de los lenguajes funcionales, para recorrer y procesar secuencias (listas) de elementos.

9.2.1. map La primera de ellas, es la función

map que utiliza los resultados de aplicar una función sobre

los elementos de una lista, para generar otra lista. Por ejemplo:

1 2 3 4 5 6 7 8 9

> ( map sqrt ( list 1 2 4 9 16) ) (1 1.4142135623730951 2 3 4) > ( map ( lambda ( x ) (+ 1 ( sqr x ) ) ) ( list -5 -4 -3 -2 -1 0 1 2 3 4 5) ) (26 17 10 5 2 1 2 5 10 17 26) > ( map ( lambda ( i ) ( string - append " ½ " i "!") ) ( list " buenos días " " buenas noches ") ) (" ½buenos días !" " ½buenas noches !")

9.2.2. andmap y ormap Otras funciones útiles para hacer validaciones de listas son

andmap

y

ormap.

En sus formas

más simples, ambas toman como parámetros una función y una lista. En el caso de la

#t si el resultado de evaluar la función sobre cada elemento de la lista #f si el resultado de evaluar alguno de los elementos de la lista es #f.

primera, retorna

#t;

y devuelve

La función

ormap

es

se comporta como se espera, pero aplicando disyunción lógica en lugar

de conjunción, que es lo que aplica

andmap. ormap

devuelve

#t

si la función se evalúa a

verdadero para alguno de los elementos de la lista. Ejemplos:

1 2 3 4 5 6 7 8 9 10

> ( andmap string ? '(" una cadena " " otra cadena ") ) #t > ( andmap string ? '(" una cadena " " otra cadena " 123456) ) #f > ( andmap number ? ( list 1 3.35 1+8 i ) ) #t > ( andmap number ? ( list 1 3.35 1+8 i " el de la izquierda es un complejo ") ) 1

En realidad sí hay, puesto que es un lenguaje funcional híbrido. Pero su necesidad es ciertamente algo que está fuera del paradigma funcional.

56

9.2 Iteración automática 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#f > ( ormap ( lambda ( x ) ( and ( real ? x ) ( positive ? x ) ) ) ( list " Sólo complejos :" -1+1 i 0+8 i ( sqrt -4) -9 -5 i ) ) #f > ;;;;;;;; Ejemplo de validación de parámetros con andmap : ;;;;;;;;;;;;; > ( define ( suma - tres - enteros - positivos a b c ) ( if ( andmap ( lambda ( x ) ( and ( integer ? x ) ( positive ? x ) ) ) ( list a b c ) ) (+ a b c ) " Los parámetros no son enteros positivos ") ) > ( suma - tres - enteros - positivos 2 3 5) 10 > ( suma - tres - enteros - positivos 2 3 -5) " Los parámetros no son enteros positivos "

9.2.3. filter La función

filter

sirve para ltrar elementos de una lista, según el criterio especicado

por una función de validación. Ejemplo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

> ( filter string ? ( list 3 " a " " b" 4 5 6) ) (" a " " b ") > ( filter complex ? ( list " Sólo complejos :" -1+1 i 0+8 i ( sqrt -4) -9 -5 i ) ) ( -1+1 i 0+8 i 0+2 i -9 -5 i ) > ; Dejar sólo los elementos que sean impares y múltiplos de 3;;;;;;;;;;;;;;;;;;;; > ( filter ( lambda ( x ) ( and ( odd ? x ) ;; impar (= 0 ( remainder x 3) ) ) ) ;; residuo ( list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) ) (3 9 15) > ; Ahora como una función que recibe una lista como parámetro ;;;;;;;;;;;;;;;;;;;;; > ( define filtra - impares -y - múltiplos - de -3 ( lambda ( lista - números ) ( if ( and ( list ? lista - números ) ( andmap integer ? lista - números ) ) ( filter ( lambda ( x ) ( and ( odd ? x ) (= 0 ( remainder x 3) ) ) )

57

9 Listas e Iteración lista - números ) " Esta función espera una lista de números " )))

22 23 24 25 26 27 28 29 30 31 32 33

> ( filtra - impares -y - múltiplos - de -3 ( list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) ) (3 9 15) > ( filtra - impares -y - múltiplos - de -3 ( list " otra cosa ") ) " Esta función espera una lista de números " > ( filtra - impares -y - múltiplos - de -3 " otra cosa ") " Esta función espera una lista de números "

9.2.4. for-each Existe la necesidad, eventualmente, de recorrer una lista, pero sin considerar el posible resultado de las evaluaciones. Generalmente, este sucede cuando necesitamos mostrar en pantalla cierta información, resultado de procesar una lista. Entonces, puede utilizarse la función nativa

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

for-each:

> ( for - each ( lambda ( x ) ( display x) ) ( list 1 2 3 4 5) ) 12345 > ( for - each ( lambda ( x ) ( display x) ( newline ) ) ( list 1 2 3 4 5) ) 1 2 3 4 5 > ;; Compare los resultados entre map y for - each : ;;;;;;;;;;;;;;;; > ( for - each integer ? ( list 2 3.1 4 5 6.6) ) > ( map integer ? ( list 2 3.1 4 5 6.6) ) (# t # f # t # t #f )

La función

for-each,

a diferencia de

map,

función sobre los elementos de la lista. Con

ignora el resultado de las evaluaciones de la

for-each

sólo importan los efectos colaterales

de las invocaciones (como las escrituras en pantalla o en archivo), no su resultado.

58

9.3 Iteración manual

9.2.5. Versiones generales de las funciones de iteración Las funciones

map, for-each, andmap

y

ormap

pueden manipular múltiples listas, en lugar

de sólo una. Las listas deben tener la misma longitud, y la función dada debe aceptar un parámetro por cada lista:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

> ( map + ( list 1 2 3 4 5) ( list 10 100 1000 10000 100000) ) (11 102 1003 10004 100005) > ( map ( lambda ( s n ) ( substring s 0 n ) ) ( list " agua loca " " hoja de papel " " dulcera ") ( list 4 4 7) ) (" agua " " hoja " " dulcera ") > ;;;; Compare otra vez el comportamiento de map vs . for - each : ;;;;;;;;;;;;;; > ( map / ( list 1 2 3 4 5) ( list 5 4 3 2 1) ) (1/5 1/2 1 2 5) > ( for - each ( lambda ( a b ) ( printf "~ a \ n " (/ a b ) ) ) ( list 1 2 3 4 5) ( list 5 4 3 2 1) ) 1/5 1/2 1 2 5

9.3. Iteración manual Eventualmente es necesario procesar listas a más bajo nivel que el que proveen funciones como

map.

En esos casos, se requiere de mecanismos

first

más primitivos

como los siguientes:

devuelve el primer elemento de una lista no vacía

rest devuelve una lista con los elementos de una lista no vacía, sin su primer elemento (el resultado puede ser una lista vacía si la lista de entrada tenía sólo un elemento)

cons

concatena un elemento a una lista, produciendo una lista nueva

cons? verica si un elemento es una lista no vacía (lo contrario de empty? y de null?) Ejemplos:

1 2 3 4 5

> ( first ( list 1 2 3) ) 1 > ( rest ( list 1 2 3) ) (2 3)

6

59

9 Listas e Iteración 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

> ( cons " cabeza " empty ) (" cabeza ") > ( cons " nueva " ( cons " cabeza " empty ) ) (" nueva " " cabeza ") > ( empty ? empty ) #t > ( empty ? ( cons " cabeza " empty ) ) #f > ( cons ? empty ) #f > ( cons ? ( cons " cabeza " empty ) ) #t

9.3.1. Aplicación Teniendo a nuestra disposición estas funciones de

bajo nivel

para manipular funciones,

podríamos construir nuestras propias funciones de longitud de lista y de mapeo de lista:

1 2 3 4 5 6 7 8 9 10

( define ( longitud L ) ( cond [( empty ? L ) 0] [ else (+ 1 ( longitud ( rest L ) ) ) ]) ) ( define ( mapear f L ) ( cond [( empty ? L ) empty ] [ else ( cons ( f ( first L) ) ( mapear f ( rest L ) ) ) ]) ) También podemos hacer funciones que procesen listas de manera básica. Por ejemplo considere la siguiente función para generar listas de números enteros:

1 2 3 4 5 6 7 8 9 10 11 12 13

( define secuencia - de - enteros ( lambda ( num - elementos inicio paso ) ( define ( aux i contador lista ) ( if ( >= contador num - elementos ) ( reverse lista ) ( aux (+ i paso ) ( add1 contador ) ( cons i lista ) ) )) ( if ( and ( exact - nonnegative - integer ? num - elementos ) ( integer ? inicio ) ( integer ? paso ) ) ( aux inicio 0 empty ) ( error " Error en los parámetros ") )

60

9.4 Pares y listas 14

))

9.4. Pares y listas La función

cons acepta dos parámetros, y el segundo no necesariamente debe ser una lista.

En el caso que como segundo argumento se le pase algo que no sea una lista, la función cons devuelve un

Un Par

Par

o

Pareja.

en Racket no es otra cosa que dos elementos (de cualquier tipo), ligados entre sí.

Una lista no vacía, de hecho, es un par compuesto por un elemento (el primero) y una lista (que puede ser vacía). La notación que utiliza Racket para representar los pares es la de los elementos, encerrados entre paréntesis y separados por un espacio en blanco, un punto y otro espacio en blanco:

1 2 3 4 5

> ( cons 1 2) (1 . 2) > ( cons " una cadena " 4) (" una cadena " . 4)

cons? con más sentido para los pares: pair?. También hay first y rest para pares: car y cdr. Estas últimas funcionan

Hay una función equivalente a funciones correspondientes a

con cualquier tipo par (incluyendo las listas no vacías) y las primeras, sólo funcionan con listas no vacías, pero no con pares. Ejemplos:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

> ( define vacío '() ) > ( define par ( cons 1 2) ) > ( define lista ( cons 1 ( cons 2 '() ) ) ) > ( pair ? vacío ) #f > ( pair ? par ) #t > ( pair ? lista ) #t > ( car par ) 1 > ( car lista ) 1 > ( cdr par ) 2 > ( cdr lista ) (2) > ( list ? vacío ) #t

61

9 Listas e Iteración 21 22 23 24

> ( list ? par ) #f > ( list ? lista ) #t

9.4.1. Convención de impresión Racket tiene una convención para imprimir los pares, que puede llegar a ser muy confusa. Por ejemplo, considere el siguiente resultado:

1 2

> ( cons 0 ( cons 1 2) ) (0 1 . 2) Lo anterior es un par, cuyo segundo elemento es otro par que no es una lista. La regla para la impresión es la siguiente: Usar siempre la notación de punto, pero si el punto está inmediatamente seguido de una apertura de paréntesis, entonces, remover el punto, el paréntesis de apertura y el correspondiente paréntesis de cierre.

(0 . (1 . 2)) se convierte en (0 1 . 2). La utilidad de esta, aparentemente, extraña regla, es para volver legibles las listas, ya que, por ejemplo, (1 . (2 . (3 . ()))) que es una lista de tres elementos en su notación de punto se convierte en (1 2 3), lo cual es Así,

más fácil de leer.

9.4.2. Notación inja Existe una convención particular en Racket que, aunque no es tradicional en Lisp y otros dialectos de Scheme, puede mejorar la legibilidad de ciertas partes de nuestras funciones. Un par de

puntos

pueden aparecer alrededor de un solo elemento en una se-

cuencia parentizada, mientras el elemento no sea ni el primero ni el último. Esta convención de sintaxis ejecuta una conversión que mueve el elemento entre los

puntos

hacia el frente de la secuencia parentizada.

Esta convención posibilita una especie de notación inja, a la cual estamos más acostumbrados:

1 2 3 4 5 6 7 8

> (1 . + . 2 3 4 5) 15 > '(1 . + . 2 3 4 5) (+ 1 2 3 4 5) > (1 . < . 2) #t

62

9.4 Pares y listas 9 10 11 12 13 14 15 16 17

> '(1 . < . 2) ( < 1 2) > (1 2 3 . * . 4) 24 > '(1 2 3 . * . 4) (* 1 2 3 4)

63

9 Listas e Iteración

64

Ejercicios de Listas e iteración 1. Dada una lista desordenada de números enteros ordenar dicha lista de mayor numero a menor, tomar en cuenta que pueden existir números repetidos en dicha lista (No utilizar la función

sort).

2. Dada una lista compuesta por números enteros eliminar los elementos repetidos de dicha lista. Retornar una nueva lista. Nota: Se pide se pide usar

display,

retornar

un lista, es decir que no

por lo demás, se puede utilizar cualquier primitiva.

3. Dada una lista compuesta por cadenas, construir una nueva lista a partir de la anterior formada por los elementos que no estén repetidos. Ejemplo para mayor comprensión:

'(hola mundo mundo)

la nueva lista será

'(hola).

4. Dada una lista compuesta por cadenas, construir una cadena formada por cada cadena

'(hola mundo) retornará holamundo. (Note que de ser la segunda cadena  mundo se retornaría hola mundo. Puede usar las primitivas que desee. Se recomienda leer sobre string-append. que se encuentre en la lista. Ejemplo

5. Dada una lista compuesta por listas, retornar verdadero si todas las sublistas están vacías y falso si por lo menos una posee algún elemento. Puede usar cualquier primitiva. 6. Dada una lista compuesta por 5 números no repetidos, retornar el número mayor de dicha lista (ojo se pide retornar no usar

display).

7. Dada una lista compuesta por 5 cadenas no repetidas, retornar la cadena de mayor longitud. En caso de que existan 2 o más cadenas de igual longitud y estas resulten las de mayor longitud, retornar ambas cadenas (para facilitar el ejercicio puede retornar la cadena o las cadenas dentro de una lista). 8. Dada una lista compuesta por números enteros, desplegar la cantidad de números pares y la cantidad de números impares. 9. Dada una lista compuesta por números enteros, retornar la sumatoria de todos los números pares. 10. Dada una lista compuesta por números enteros y dado un número, retornar número se encuentra en la lista y

member).

#f

#t

si el

si dicho número no se encuentra (NO USAR

11. Dada una lista compuesta por números y dado un número, eliminar dicho número de la lista si este se encuentra en ella (puede usar cualquier primitiva).

65

9 Listas e Iteración 12. Dada una lista compuesta por tres puntos (un punto es una lista, ejemplo un punto y

#f

x → 1, y → 2)

retornar

#t

'(1 2)

es

si dichos puntos forman un triángulo equilátero,

en caso contrario (es equilátero si sus tres lados son iguales). NOTA : Fórmula

de distancia entre los puntos

(x1 , y1 )

y

(x2 , y2 ): d =

q (x2 − x1 )2 + (y2 − y1 )2

13. Dada una lista compuesta por listas, retornar una lista compuesta por los elementos de cada sublista. Ejemplo

'( (1 2) (2 3)) retornará (1 2 2 3). Como puede observar,

pueden existir elementos repetidos. 14. Dada una lista compuesta por cadenas, retornar la cantidad de vocales dentro de dicha lista. Ejemplo

'(hola mundo)

retornará 4.

15. Dada una lista compuesta por cadenas, retornar la lista compuesta por las cadenas sin sus vocales. Ejemplo:

'(hola mundo)

retornará

'(hl mnd)

note que se

eliminaron las vocales. El orden de las cadenas no debe cambiar. 16. Dada una cadena, pasar cada letra de la cadena a una lista, ejemplo vierte en

hola

se con-

'(h o l a). Note que no se piden los caracteres si no las letras en

forma de cadena. 17. Dada una lista compuesta por cadenas, ordenar dicha lista tomando como criterio la longitud de las cadenas (No usar

sort).

18. Elaborar una función que reciba como parámetro una lista de números enteros y positivos, la función evaluará la lista de números, si la lista está ordenada de mayor a menor, la función retornará dos listas (usando la función

values)

la primer lista

contendrá los números pares de la lista original, respetando el mismo orden de mayor a menor, y la segunda lista contendrá los números impares de la lista original respetando el orden de la lista original; en caso contrario, es decir si la lista pasada de parámetro está desordenada, se retornará la lista ordenada de mayor a menor.

66

10 Recursión 10.1. Recursión por Posposición de trabajo En el caso del siguiente código de la función

longitud,

el tipo de recursión usada es

posposición de trabajo: 1 2 3 4

( define ( longitud L ) ( cond [( empty ? L ) 0] [ else (+ 1 ( longitud ( rest L ) ) ) ]) ) Y al evaluar, por ejemplo,

1 2 3 4 5 6 7 8

-> = = = = = = =

(longitud (list a b c))

se da este proceso:

( longitud ( list " a " " b " " c ") ) (+ 1 ( longitud ( list " b " " c ") ) ) (+ 1 (+ 1 ( longitud ( list " c ") ) ) ) (+ 1 (+ 1 (+ 1 ( longitud ( list ) ) ) ) ) (+ 1 (+ 1 (+ 1 0) ) ) (+ 1 (+ 1 1) ) (+ 1 2) 3

Como puede verse, se tienen que apilar todos los cálculos y todas las sumas quedan

tas

pospues-

hasta que se alcanza el caso trivial de la recursión, que en este caso es cuando se en-

cuentra una lista vacía. Si la longitud de la lista es demasiado grande, provocará un gran consumo de memoria. Esto no es algo  extraño , sin embargo resulta ser ineciente en Racket, ya que este lenguaje provee una optimización importante para la recursión de cola, que se explica a continuación.

10.2. Recursión de Cola Considere la siguiente versión de

1 2 3 4 5

longitud

con recursión de cola:

( define ( longitud L ) ; función local longitud - aux : ( define ( longitud - aux L longitud - actual ) ( cond [( empty ? L ) longitud - actual ]

67

10 Recursión [ else ( longitud - aux ( rest L ) (+ longitud - actual 1) ) ]) ) ; este es el cuerpo de longitud , que llama a longitud - aux : ( longitud - aux L 0) )

6 7 8

(longitud (list a b c)):

Ahora veamos el cálculo de

1 2 3 4 5 6

-> = = = = =

( longitud ( list " a " ( longitud - aux ( list ( longitud - aux ( list ( longitud - aux ( list ( longitud - aux ( list 3

" b " " c ") ) " a " " b " " c ") 0) " b " " c ") 1) " c ") 2) ) 3)

Note que no hay retornos pendientes en ningún momento, tampoco hay cálculos (en este caso, sumas) que queden pendientes en cada paso de la recursión. En Racket, cuando una función se reduce a una expresión cuyos parámetros son totalmente conocidos, toda la memoria de la función es liberada y ya no queda rastro de su invocación. Esto no sólo sucede con la recursión de cola, sino con cualquier llamada para la cual no queden cálculos pendientes. Esta es una diferencia importante de Racket con respecto a otros lenguajes de programación no funcionales, ya que en otros lenguajes, aún haciendo recursión de cola, siempre queda memoria de las llamadas anteriores, apiladas esperando algún

return, end

o equivalente.

Esto provoca que la cantidad de memoria necesaria para ejecutar el procedimiento recursivo es aproximadamente lineal a la profundidad de la llamada. En Racket, la recursión de cola se ejecuta en una cantidad de memoria ja, para toda la ejecución de la función recursiva. Queda entonces, la atenta invitación a utilizar recursión de cola en los programas hechos con Racket, siempre que sea posible.

68

11 Tipos de dato integrados del lenguaje Aquí se describen los principales tipos integrados, nativos de Racket. El lenguaje incluye muchos otros tipos de datos complejos que no serán abordados aquí.

11.1. Booleanos El tipo más simple de Racket es el que son

booleano

o

lógico.

Sólo tiene dos valores constantes,

#t para verdadero y #f para falso (también se aceptan las formas #F y #T, pero las

versiones en minúsculas son preferidas). Existe la función o

1 2 3 4

#f:

boolean?

que verica si un valor es una de las dos constantes lógicas,

#t

> ( boolean ? 0) #f > ( boolean ? # f ) #t A pesar de que se espera un valor de verdad en las expresiones de prueba de las construcciones

if, cond, and, or y otras, todos los valores posibles en Racket, excepto #f se evalúan

como verdadero:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

> ( define ( mostrar - valor - de - verdad v ) ( if v # t # f )) > ( mostrar - valor - de - verdad "") #t > ( mostrar - valor - de - verdad " no ") #t > ( mostrar - valor - de - verdad empty ) #t > ( mostrar - valor - de - verdad '(1 2 3) ) #t > ( mostrar - valor - de - verdad #() ) #t > ( mostrar - valor - de - verdad #(1 2 3) )

69

11 Tipos de dato integrados del lenguaje 19 20 21 22

#t > ( mostrar - valor - de - verdad #\ a ) #t

11.2. Números A continuación se presenta el tratamiento de los

números

Un valor numérico se puede validar con la función

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

en Racket.

number?:

> ( number ? 3) #t > ( number ? 3.1416) #t > ( number ? "3") #f > ( number ? 5+8 i ) #t > ( number ? 5/8) #t > ( number ? 3.45 e -200) #t

11.2.1. Clasicación Hay dos formas de clasicar números en Racket: Por exactitud y por conjuntos.

Clasicación por Exactitud En Racket, un Los

número

números exactos

es

exacto

o

inexacto.

son:

1. Los enteros 2. Los racionales 3. Los complejos con parte real exacta y parte imaginaria exacta Los

70

números inexactos

son:

11.2 Números 1. Los reales de coma otante 2. Los complejos con parte real inexacta o parte imaginaria inexacta Existen las funciones

exact? e inexact? para determinar si un número pertenece a uno de

los dos tipos anteriores.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

> ( exact ? 7) #t > ( inexact ? 7) #f > ( inexact ? empty ) . . inexact ?: expects argument of type < number >; given () > ( inexact ? "") . . inexact ?: expects argument of type < number >; given "" > ( inexact ? 8.999993 -8.325421 i ) #t > ( inexact ? 7/8) #f Pueden también utilizarse las funciones

exact->inexact e inexact->exact para convertir

de un tipo a otro:

1 2 3 4 5 6 7 8

> ( exact - > inexact 1/3) 0.3333333333333333 > ( exact - > inexact (/ 7 8) ) 0.875 > ( inexact - > exact 0.3333333333333333333333333333) 6004799503160661/18014398509481984 Además, existe una forma de forzar la representación, como exacto o inexacto, de un número, independientemente de la forma en que se escriba. Con los prejos

1 2 3 4 5 6 7 8

#e

y

#i:

> # e0 .2 1/5 > # i1 /5 0.2 > # i4 +5 i 4.0+5.0 i

Propagación de la exactitud

Con los operadores aritméticos básicos, los números exactos

se mantienen exactos tras los cálculos y los inexactos se mantienen inexactos a través de los cálculos:

71

11 Tipos de dato integrados del lenguaje 1 2 3 4 5 6 7 8 9 10

> ( define ( sigma f a b ) ( if (= a b ) 0 (+ ( f a ) ( sigma f (+ a 1) b )) ) ) > ( sigma ( lambda ( x ) (/ 1 107/210

x ) ) 5 8)

> ( sigma ( lambda ( x ) (/ 1.0 x ) ) 5 8) 0.5095238095238095

Clasicación por Conjuntos Tal como en la matemática tradicional, los números se categorizan por la jerarquía del conjunto al que pertenecen:

Z⊂Q⊂R⊂C

(es decir, los enteros están incluídos en los

racionales, estos en los reales, y estos en los complejos):

1 2 3 4 5 6 7 8 9 10 11

> ( integer ? -5) #t > ( rational ? -5/9) #t > ( real ? -5/9) #t > ( complex ? -5/9) #t

11.2.2. Otras bases La base para todos los números (desde los enteros hasta los complejos) es forzarse a que sea base 2, base 8 o base 16 con los prejos

1 2 3 4 5 6 7 8 9 10 11 12 13 14

> # b11 3 > # o10 8 > # xff 255 > # b111 .01 7.25 > # xf /5 3

72

#b, #o, #x,

10,

pero puede

respectivamente:

11.2 Números

11.2.3. Comparaciones Los números exactos pueden ser comparados con la función

= o con equal?, pero los números

inexactos, debido a su propia naturaleza, deberían ser comparados de

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

por igualdad, ya que su representación no es exacta:

por proximidad

en lugar

> (= 3 6/2) #t > (= 4+8 i 8/2+24/3 i ) #t > ( equal ? 4+8 i 8/2+24/3 i ) #t > (= 4.0+8.0 i 8/2+24/3 i ) #t > (= 4.0 4) #t > (= 0.1 1/10) #f > ( inexact - > exact 0.1) 3602879701896397/36028797018963968 > ( let ([ a 0.1] [ b 1/10] [ tolerancia 0.00001]) ( < ( abs ( - a b ) ) tolerancia ) ) #t > ( define ( ¾son - reales - iguales ? a b tol ) ( < ( abs ( - a b ) ) tol ) )

11.2.4. Constantes especiales Existen cuatro constantes especiales, denidas por la IEEE:

+inf.0/-inf.0

que resultan de sobrepasar la capacidad de representación de los

números en coma otante, por arriba o por abajo, respectivamente.

+nan.0/-nan.0 que resultan de cálculos indeterminados como cero entre cero, innito entre innito, cero por innito, innito menos innito, etc.

1 2 3 4

> (/ 8.0 0.0) + inf .0 > -5.38 e700

73

11 Tipos de dato integrados del lenguaje 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

- inf .0 > 1.79 e -400 0.0 > 1.79 e308 1.79 e +308 > 1.79 e309 + inf .0 > ;; 'NaN ' significa : Not a Number . > (/ 0.0 0.0) + nan .0 > (/ + inf .0 - inf .0) + nan .0 > (* 0.0 - inf .0) + nan .0 > (+ + inf .0 - inf .0) + nan .0 Si estos valores especiales se pasan como parámetro a alguna función que espere números, su resultado será del mismo tipo (excepto para algunas funciones para las que tiene signicado):

1 2 3 4 5 6 7 8

> ( cos (* (+ (* 0.0 - inf .0) 1) 9) ) + nan .0 > ( atan + inf .0) 1.5707963267948966 > (* 2 ( atan + inf .0) ) ; pi 3.141592653589793

11.3. Caracteres Un

caracter

en Racket, es un valor escalar Unicode (igual que en otros lenguajes de pro-

gramación como

Java ).

Los caracteres literales, se expresan como una secuencia

#\

seguido del caracter correspon-

diente, si es que estos tienen una representación imprimible y escribible:

1 2 3 4

> #\0 #\0 > #\ a #\ a

74

11.3 Caracteres 5 6 7 8 9 10

> #\ newline #\ newline > #\ space #\ space > #\& #\&

A pesar que un caracter se corresponda con un entero en Racket, a diferencia de otros lenguajes (como

Java

o

C ),

no se pueden mezclar directamente con los números. Para

poder hacerlo, se utilizan las funciones

char->integer

e

integer->char:

Si algún caracter no tiene una representación imprimible, este siempre se puede mostrar con la notación Unicode tradicional de una letra

u

minúscula y un número hexadecimal de

dos bytes:

1 2 3 4

> ( integer - > char 17) #\ u0011 > ( char - > integer #\ u011D ) 285

Existen ciertas funciones útiles para manipular y procesar caracteres:

75

11 Tipos de dato integrados del lenguaje

11.4. Cadenas Una

cadena

es un arreglo de caracteres de longitud ja. Como en muchos otros lenguajes,

se escriben entre comillas dobles. Como en otros lenguajes, para poder escribir comillas dobles dentro de la cadena, hay que

\. Esto se conoce como secuencia de escape. De la misma manera, hay varias secuencias de escape, como \\ para escribir una pleca, \n para una nueva línea, \r para un retorno de carro. Y para escribir un caracter dado su código octal, \777 y \uFFFF utilizar la secuencia

para escribirlo en función de su código hexadecimal Unicode. La función

display

escribe los caracteres de la cadena, pero sin las comillas, a diferencia

de lo que sucede cuando el resultado de una expresión es una cadena.

76

11.4 Cadenas Ejemplos:

Hay tres funciones básicas para la creación y manipulación de cadenas:

string

forma una nueva cadena a partir de una serie de caracteres;

string-ref

devuelve un caracter de una cadena, dada su posición; y

string-length

devuelve su longitud medida en caracteres

Ejemplos:

1 2 3 4 5 6 7 8 9 10 11 12 13

> ( string #\ H #\ o #\ l #\ a ) " Hola " > ( string ) "" > ( string - ref " Hola " 0) #\ H > ( string - ref " Hola " 3) #\ a > ( string - length " Hola ") 4

11.4.1. Cadenas mutables Por defecto, los literales de cadena escritos en el código fuente, se convierten en cadenas

inmutables,

es decir, que no pueden ser cambiados durante el curso de su existencia como

objetos del programa. Pero si requerimos alterar una cadena durante la ejecución, debemos crear una

cadena mutable.

Veamos las funciones para crear una cadena mutable y alterar

su contenido:

make-string

recibe una longitud para la nueva cadena mutable y opcionalmente un

caracter de relleno, por defecto el caracter nulo (\u0000).

77

11 Tipos de dato integrados del lenguaje string-set!

modica un caracter de una cadena mutable, dada su posición.

string->immutable-string

convierte una cadena mutable en su versión inmutable

(si recibe una inmutable, la devuelve a ella misma).

immutable? verica si un objeto es inmutable no sólo las cadenas pueden ser mutables .

string-copy!

copia total o parcialmente el contenido de una cadena mutable o

inmutable a otra cadena mutable.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

> ( make - string 4 #\ c ) " cccc " > ( define cadena - mutable ( make - string 4 #\ c ) ) > ( string - length cadena - mutable ) 4 > ( string - ref cadena - mutable 2) #\ c > ( string - set ! cadena - mutable 2 #\ a ) > cadena - mutable " ccac " > ( define cadena - inmutable ( string - > immutable - string cadena - mutable ) ) > ( immutable ? cadena - inmutable ) #t > ( immutable ? cadena - mutable ) #f > ( define otra - cadena - mutable ( make - string 10) ) > otra - cadena - mutable "\ u0000 \ u0000 \ u0000 \ u0000 \ u0000 \ u0000 \ u0000 \ u0000 \ u0000 \ u0000 " > ( string - copy ! otra - cadena - mutable 0 " buen día ") > otra - cadena - mutable " buen día \ u0000 \ u0000 "

11.4.2. Comparación entre cadenas La comparación entre cadenas se realiza con las siguientes funciones:

string=?, string
View more...

Comments

Copyright © 2017 KUPDF Inc.
SUPPORT KUPDF