~herlock_sholmes/PensamientoComputacional

PensamientoComputacional/Presentaciones/NadandoEnParentesis.org -rw-r--r-- 4.5 KiB
2cb13b94Herlock Sholmes 0020: modificaiones menores a IntroaGNUGuix.org 3 months ago
                                                                                
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#+TITLE: Nadando entre paréntesis
#+TITLE: Una introducción a Common Lisp
#+AUTHOR: Camilo Meza Gaete
#+EMAIL: camilo.meza.g@member.fsf.org

* Un poco de historia
** Orígenes
Se especifica la familia de lenguajes conocida como *lisp* en 1958, por John McCarthy.

[[./McCarthy.png]]

** Un estándar
En 1981 se comienza a trabajar en el desarrollo de un dialecto estándar de lisp.

[[./Steel.jpg]]

** ANSI
Este dialecto, llamado /common lisp/ sería definido por la publicación de 1994 del Instituto de Estándares Nacionales Americano (ANSI por sus siglas en inglés).

** Implementaciones
Existen varias implementaciones del lenguaje ANSI Common Lisp, las más conocidas son:
- Steel Bank Common Lisp (SBCL)
- CLISP
- Carnegie Mellon University Common Lisp (CMUCL)

* Sintaxis
** Expresiones S
La sintaxis de los lenguajes lisp es bastante concida: Utilizan paréntesis (()) y notación polaca (o prefija)

#+begin_src lisp
(+ 2 3 4)
#+end_src

** Expresiones S
En este caso, nuestra expresión sería graficada así:

  +
 / \
2   +
   / \
  3   4
       \
        ()

** Expresiones S
Como se puede observar, en /common lisp/ se utiliza una función seguida de sus argumentos.

#+begin_src lisp
(defun cuadrado (x)
  (* x x))
(cuadrado 5)
#+end_src

** Tipos de datos
- Símbolos:
  esto-es-un-simbolo, nil, t

- Palabras clave:
  :clave

- Cadenas de texto:
  "Ejemplo de cadena"

- Números:
  3    3,14     3/10

** Tipos de datos
- Listas:
  (esto es una lista)    (esto (también))   (esta (lista (incluye ("numeros" 5))))


** Tipos de datos
Ya que Lisp viene de LISt Processor, construiremos nuestras listas enlazadas como cadenas similares a las de un tren:

      .o                                _________
     . ______          ______________  |         |      _____
   _()_||__|| ________ |            |  |_________|   __||___||__
  (BNSF 1995| |      | |            | __Y______00_| |_         _|
 /-OO----OO""="OO--OO"="OO--------OO"="OO-------OO"="OO-------OO"=P
###################################################################
|---car-----| |-------------------cdr-----------------------------|

** Celdas Cons
Conseemos:

#+begin_src lisp
(setf lista '(A B C))
(car lista)
#+end_src


** Celdas Cons

#+begin_src lisp
(setf lista '(A B C))
(cdr lista)
#+end_src


** Celdas Cons

#+begin_src lisp
(setf lista '(A B C))
(car (cdr lista))
#+end_src

** Celdas Cons

#+begin_src lisp
(setf lista '(A B C))
(cdr (cdr (cdr lista)))
#+end_src

** Evaluación
En cualquier implementación de *common lisp* las listas escritas serán evaluadas (en el sentido matemático de la expresión).

** Evaluación
Es por esto que se dice "los datos son tratados como código" en clisp. A menos que se explicite, la implementación intentará evaluar los símbolos, para ello se usa el *modo dato* que comienza con un apóstrofe.


** Evaluación
Las listas evaluadas son conjuntos de celdas cons, y el único valor *falso* en clisp es una lista vacía

#+begin_src lisp
(if '()
    'la-lista-tiene-cosas
    'la-lista-está-vacía)
#+end_src

* ¿Cómo iniciar?
** Elegir una implementación
Como se dijo anteriormente, existen varias implementaciones que permiten interactuar con el REPL. Puedes visitar sus páginas y utilizar la que más se acomode a tus necesidades

** Trabajar con un editor de texto
Cualquier editor de texto servirá para escribir programas en clisp; aunque personalmente recomiendo GNU Emacs.

** Ejemplo de entorno para Emacs
GNU Emacs tiene dos modos que permiten trabajar con lisp: SLIME y SLY.

Ambos pueden utilizar la implementación elegida para entregar una REPL a través de Emacs, por lo que la decisión sólo se basa en experiencia personal.

** Mi entorno de trabajo
- Emacs
- SLY
- SBCL

** Fuentes útiles
[[https://common-lisp.net/][Repositorio de proyectos]]

[[http://quickdocs.org/][Fuente de documentación de bibliotecas en clisp]]

[[https://borretti.me/article/common-lisp-sotu-2015][Estado del ecosistema clisp (2015)]]

[[https://video.hardlimit.com/video-channels/lispeandolacasa/videos][Vídeos del proyecto "lispeando la casa" para la documentación y el aprendizaje]]

* Ejemplos y programas conocidos
** Ciencias
Grammarly es un motor de análisis gramático escrito en /common lisp/.

Maxima es un CAS programado con clisp.
[[http://maxima.sourceforge.net/es/index.html][Página oficial del proyecto]]

** Gráficos
El videojuego "Jak and Daxter" utiliza un DSL en clisp mediante la implementación AllegroCL
[[https://franz.com/success/customer_apps/animation_graphics/naughtydog.lhtml][Enlace de la entrevista, con vídeo incrustado]]