{"id":18100265,"url":"https://github.com/davidam/davidam","last_synced_at":"2026-01-18T19:34:58.930Z","repository":{"id":320659754,"uuid":"46733302","full_name":"davidam/davidam","owner":"davidam","description":"Personal elisp functions","archived":false,"fork":false,"pushed_at":"2022-10-08T15:50:34.000Z","size":225,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-10-25T05:03:40.021Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Emacs Lisp","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/davidam.png","metadata":{"files":{"readme":"README.org","changelog":null,"contributing":null,"funding":null,"license":"COPYING","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2015-11-23T16:31:24.000Z","updated_at":"2025-10-24T16:50:22.000Z","dependencies_parsed_at":"2025-10-25T05:14:15.069Z","dependency_job_id":null,"html_url":"https://github.com/davidam/davidam","commit_stats":null,"previous_names":["davidam/davidam"],"tags_count":null,"template":false,"template_full_name":null,"purl":"pkg:github/davidam/davidam","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/davidam%2Fdavidam","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/davidam%2Fdavidam/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/davidam%2Fdavidam/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/davidam%2Fdavidam/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/davidam","download_url":"https://codeload.github.com/davidam/davidam/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/davidam%2Fdavidam/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28549447,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-18T19:22:41.102Z","status":"ssl_error","status_checked_at":"2026-01-18T19:22:26.310Z","response_time":98,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-10-31T21:13:33.117Z","updated_at":"2026-01-18T19:34:58.924Z","avatar_url":"https://github.com/davidam.png","language":"Emacs Lisp","funding_links":[],"categories":[],"sub_categories":[],"readme":"#+TITLE: Funciones Primitivas de Lisp \n#+LANGUAGE: es\n#+AUTHOR: David Arroyo Menéndez\n#+HTML_HEAD: \u003clink rel=\"stylesheet\" type=\"text/css\" href=\"../../css/org.css\" /\u003e\n#+BABEL: :results output :session\n\n* Ayuda on-line en lisp \n\nPara emacs lisp, basta con C-h f.\n\nEn common lisp hay unas cuantas primitivas de lisp, para ir a la ayuda\n\ndescribe: es útil si quieres saber qué argumentos tiene una función, ó a qué paquete corresponde\nEjemplo de uso: (describe 'first)\n\napropos: lista el conjunto de símbolos relativos al argumento del que queremos información.\nEjemplo de uso: (apropos 'first)\n\n* Debug \nC-u C-M x nombre-funcion\n* Moviéndonos con emacs \n   Esc-x lisp-mode: entramos en el modo lisp\n   Ctl+Alt+n: vas al siguiente parentesis\n   Ctl+Alt+p: vas al anterior parentesis\n   Ctl+Alt+d: te introduces en la siguiente funcion\n   Ctl+Alt+u: te sales de la funcion actual\n   Ctl+Alt+t: intercambia la funcion anterior a la posicion de la actual\n   Esc+Ctl+k: borra el argumento de la funcion\n\n* Asignación \n   setq: Asiga valores a una variable\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq nueve '9)\n\t\t   (setq l '(a b c))\n#+END_SRC\n\n   let y let*: Asigna valores a variables y genera listas de tal modo que en let las modificaciones en la muestra de datos en pantalla de los valores son locales y en let* son globales \n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq nueve '9)\n\t\t   (let ((nueve 'interior)\n\t\t\t  (y nueve))\n\t\t\t (list nueve y))\n#+END_SRC\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq nueve '9)\n\t\t   (let* ((nueve 'interior)\n\t\t\t  (y nueve))\n\t\t\t (list nueve y))\n#+END_SRC\n\n* Aritméticas \n   +, -, *, / : Son las operaciones para sumar, restar, multiplicar y dividir\n#+BEGIN_SRC lisp\n   Un ejemplo de uso es: (+ (* 2 3) 5)\n#+END_SRC\n\n   % : Esta no funciona en clisp, venía en el libro de emacs\n\n   1+, 1- : Incrementa/Decrementa en uno el valor. Es una operación unaria.\n#+BEGIN_SRC lisp\n   Un ejemplo de uso es: (1+ 9)\n#+END_SRC\n\n   max, min : Devuelve el valor máximo de una lista\n#+BEGIN_SRC lisp\n   Un ejemplo de uso es: (max 23 4 5 234 654)\n#+END_SRC\n\n   float: Devuelve el valor en coma flotante\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (float (/ 22 7)) \n#+END_SRC   \n\n   round: redondea un valor al entero más cercano\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (round (/ 22 7)) \n#+END_SRC\n\n   expt: calcula potencias elevando su primer argumento a su segundo\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (expt 2 3)\n#+END_SRC\n\n   sqrt: calcula raices cuadradas\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (sqrt 9)\n#+END_SRC\n\n   abs: calcula el valor absoluto\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (abs -3)\n#+END_SRC\n\n   random: calcular un número aleatorio de 0 a N-1\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (random '5)\n#+END_SRC\n\n* Comparación \n   \u003e, \u003c, \u003e=, \u003c= : Mayor que, Menor que, Mayor o igual que, Menor o igual que. Sólo números\n#+BEGIN_SRC lisp\n   Un ejemplo de uso: (\u003c (max 5 6) 6)\n#+END_SRC\n\n   /= : Distinto que. Sólo para números\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (/= 5 4)\n#+END_SRC\n\n   equal: Evalúa si el valor de los dos argumentos es la misma expresión\n#+BEGIN_SRC lisp  \n   Ejemplo de uso:  (equal (+ 2 2) 4)\n#+END_SRC\n\n   eql: Evalúa si el valor de los dos argumentos es el mismo símbolo o número.\n#+BEGIN_SRC lisp\n   Ejemplo: Fallará si intentamos (eql '(x y) '(x y))\n#+END_SRC\n\n   eq: Evalúa si el valor de los dos argumentos es el mismo símbolo.\n#+BEGIN_SRC lisp\n   Ejemplo: Fallará si intentamos (eq '(x y) '(x y))\n#+END_SRC\n\n   = : Evalúa si el valor de los dos argumentos es el mismo número.\n#+BEGIN_SRC lisp\n   Ejemplo: Falla si intentamos ver si (= 'x 'x)   \n#+END_SRC\n\n   zerop: Evalúa si un número es cero.\n\n   plusp: Evalúa si un número es positivo.\n\n   listp: Evalúa si el argumento es una lista.\n\n   evenp: Evalúa si un número es par.\n   \n   oddp: Evalúa si un número es impar.\n\n   numberp: Evalúa si es un número.\n\n   symbolp: Evalúa si es un símbolo.\n\n   if, when, unless y case: Sirven para ejecutar o no acciones si se\n   cumple una condición.  \n#+BEGIN_SRC lisp   Ejemplos de uso: \n   (setq dia-o-fecha 'lunes)\n   (if (symbolp dia-o-fecha) 'dia 'fecha) \n   (when (symbolp dia-o-fecha) 'dia) \n   (cond ((symbolp dia-o-fecha) 'dia) \n   ((numberp dia-o-fecha) 'fecha)) \n   (case figura (circulo (* pi r r)) \n   (esfera (* 4 pi r r)))\n#+END_SRC\n\n   sort: ordena una lista en el orden que se le dicta como argumento\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (sort '(3 1 4 1 5 9) #'\u003c)\n   Al igual que nconc y delete sort altera el contenido de la lista.\n#+END_SRC\n\n* Lógicas \n   and, or y not: Son las expresiones lógicas de toda la vida\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (and (\u003c 5 6) T)\n#+END_SRC\n\n* Manejo de Secuencias (son tanto listas como cadenas) \n\n   elt: devuelve el elemento que ocupa la posición x de la secuencia.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (elt '(a b c) 0)\n#+END_SRC\n   length: cuenta el número de elementos de nivel superior que hay en una lista.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (length '(platon socrates aristóteles))\n#+END_SRC\n   reverse: invierte el orden de los elementos de nivel superior de la secuencia.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (reverse '(platon socrates aristóteles))\n#+END_SRC\n   replace: reemplaza los elementos de la seq1 con los elementos de seq2. seq1 se modifica de manera destructiva\n#+BEGIN_SRC lisp\nEjemplo de uso:\n(defvar sent '(1 2 3 4 5 6 7 8 9 0))\n(replace sent '(\"Second\" \"Third\") :start1 1 :end1 9)\n#+END_SRC\n\n#+BEGIN_SRC lisp\nEjemplo de uso:\n(defvar from '(1 2 3))\n(defvar to '(a b c))\n(replace from to :start1 1 :end1 2)\n#+END_SRC\n\n* Manejo de cadenas \n\n   string=, string-equal: nos dice si dos cadenas son iguales, la diferencia entre uno y otro es que string= diferencia minúsculas y mayúsculas y string-equal, no.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (string= \"abc\" \"ABC\")\n#+END_SRC     \n   char=, char-equal: nos dice si dos caracteres son iguales, la diferencia entre uno y otro es que char= diferencia minúsculas y mayúsculas y char-equal, no.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (char= #\\a #\\a)\n#+END_SRC\n   search: nos sirve para determinar si una cadena está contenida en otra. Si lo está devolverá la posición donde empieza la correspondencia, en otro caso devuelve NIL.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (search \"Márquez\" \"García Márquez\")\n   Ejemplo de uso: (search \"MÁRQUEZ\" \"García Márquez\" :test #'char-equal) ;; así se evita que distinga entre mayúsculas y minúsculas.\n#+END_SRC   \n   concatenate: concatena cadenas\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (concatenate 'string \"hola\" \"adios\")\n#+END_SRC\n\n* Manejo de listas \n   setq: Asigna valores a una lista   \n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq amigos '(jesus gema gregorio))\n#+END_SRC\n   let: Asigna valores a una lista \n\n   atom: Nos dice si el elemento es un átomo o si es una lista.\n\n   endp: Comprueba si la lista está vacía\n\n   first: Devuelve el primer elemento de una lista. Es lo mismo que car\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (first amigos)\n#+END_SRC\n   rest: Devuelve la lista sin el primer elemento. Es lo mismo que cdr\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (rest amigos)\n#+END_SRC\n   cadr: Entre c y r puede haber una combinación a y d que denotan el encadenamiento de first y rest.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (caddr amigos) = (first (rest (rest amigos)))\n#+END_SRC\n   second, third, fourth,...: Devuelve el segundo, tercer, o cuarto elemento de una lista (hay hasta el tenth)\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (third amigos)\n#+END_SRC\n   cons: Inserta un nuevo elemento en la primera posición de una lista.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (cons 'lucas amigos) \n   ;;  Lo que realmente hace cons es hacer que el primer apuntador de la lista sea 'lucas.\n#+END_SRC\n   append: Combina dos listas en una\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq friends (append amigos '(b c)))\n   ;;\t   Lo que realmente hace append es copiar amigos en la nueva lista (en nuestro caso friends) y, luego anexa '(b c).\n#+END_SRC\n\n   nconc: fusiona dos listas en una. La diferencia con append es que nconc lo hace haciendo que el último apuntador de la primera lista apunte al primero de la segunda.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (nconc amigos '(b c))\n   ;;\t   Si ahora llamamos a amigos desde clisp el resultado no es el que tal vez esperábamos.\n#+END_SRC\n\n   list: Elabora una lista con sus argumentos\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (list '1 '2 '3)\n#+END_SRC\n\n   push y pop: meter y sacar un elemento a una lista. Fíjate que podemos usar cons y rest para esos menesteres, la diferencia es que aquí los cambios alteran el contenido de la variable.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (pop amigos)\n#+END_SRC\n\n   nthcdr: elimina los n primeros elementos de una lista\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (nthcdr 3 amigos)\n#+END_SRC\n\n   butlast: elimina los n últimos elementos de una lista\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (butlast amigos 2)\n#+END_SRC\n\n   last: devuelve una lista en la que se han eliminado todos los elementos menos el último.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (last amigos)\n#+END_SRC\n\n   assoc: Sirve para recuperar elementos de una lista de asociación. Una lista de asociación es una lista de sublistas, en la que el primer elemento de cada sublista se utiliza como una clave para recuperar la sublista completa. \n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq sara '((estatura 1.7) (peso 65)))\n\t\t   (assoc 'peso sara)\n(setq fechas '((startyear 2013) (startmonth 06) (endyear 2013) (endmonth 12)))\n(assoc 'startyear fechas)\n#+END_SRC \n\n   member: comprueba si un elemento pertenece a una lista y devuelve una lista con los elementos que hay desde el elemento coincidente\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (member 'c '(b c a))\n#+END_SRC   \n\n   delete: se deshace de las ocurrencias del primer argumento que aparezcan en el nivel superior del segundo.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (delete 'jorge amigos)\n\t   Nótese que delete ha borrado del todo a jorge de amigos.\n#+END_SRC   \n\n   remove: se deshace de las ocurrencias del primer argumento que aparezcan en el nivel superior del segundo. Aparentemente hace lo mismo que delete, pero en la práctica delete cambia el contenido de la lista y remove no.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (remove 'jorge amigos)\n   Ejemplo avanzado de uso: (remove '(cara cruz) '((alfa omega) (cara cruz) (zenit nadir)) :test #'equal)\n   Ejemplo avanzado de uso: (remove 'cruz '((alfa omega) (cara cruz) (zenit nadir)) :test #'member)\n#+END_SRC   \n\n\n* Funciones que tienen funciones como argumentos \n   mapcar: Simplifica las operaciones de transformación de listas. Se proporciona el procedimiento de transformación y la lista de elementos a transformar.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (mapcar #'oddp '(1 2 3))\n\t\t   (mapcar #'- '(1 2 3 4))\n#+END_SRC   \n\n   remove-if, remove-if-not: Simplifica las operaciones de filtración de listas. De esta manera, remove-if elimina todos elementos que satisfacen un predicado dado.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (remove-if #'evenp '(1 2 3 4))\n#+END_SRC   \n\n   reduce: Similar a mapcar, simplifica operaciones de filtrado de secuencias.\n#+BEGIN_SRC bash\n   Ejemplo de uso: \n      (reduce (lambda (best item) \n\t  (if (and (oddp item) (\u003e item best)) \n\t      item\n\t    best))\n\t'(1 4 6 5 8 2 7))\n#+END_SRC\n\n   count-if, find-if: Simplifican las operaciones de conteo y localización.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (count-if #'evenp '(1 2 3 4))\n\t\t   (find-if #'evenp '(1 2 3 4))\n#+END_SRC   \n\n   funcall: Permite definir procedimientos que tengan procedimientos como argumentos.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (funcall #'first '(1 2 3))\n#+END_SRC   \n\n   apply: usa el valor de su primer argumento sobre los elementos de su segundo argumento, el cual debe ser una lista.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (apply #'append '((e1 e2) (e3 e4)))\n\t\t   (apply #'+ 1 2 3 '(4 5 6))\n#+END_SRC   \n\n   lambda: define procedimientos anónimos, es un defun sin nombre del procedimiento, útil para dejar más claro lo que va a hacer el procedimiento. No debe usarse si el procedimiento puede usarse unas cuantas veces.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (mapcar #'(lambda (x) (eq x 2)) '(3 4 2 5)) \n   Ejemplo de uso: (defun igualdad (y list) (mapcar #'(lambda (x) (eq x y)) list)) -\u003e Ej. anterior llevado a función\n   Ejemplo de uso: ((lambda (x) (list x x)) '(lambda (x) (list x x))) -\u003e programa q se escribe a si mismo\n#+END_SRC   \n\n* Iteración sobre números y listas \n   DOTIMES:\n       (dotimes (\u003ccontador\u003e \u003clímite-superior\u003e \u003cresultado\u003e)\n\t\t \u003ccuerpo del bucle\u003e)\n#+BEGIN_SRC lisp\n   Ejemplo de uso:\n(dotimes (i (length '(2 3 4 5)))\n  (if (= 5 (elt '(2 3 4 5) i))\n      (print \"encontrado 5\")))\n#+END_SRC\n\n   DOLIST:\n       (dolist (\u003ccontador\u003e \u003clista\u003e \u003cresultado\u003e)\n\t\t\u003ccuerpo del bucle\u003e)\n#+BEGIN_SRC lisp\n   Ejemplo de uso:\n\t   (dolist (i '(2 3 5 6))\n\t\t   (if (equal 5 i) (format t \"encontrado ~a\" i)))\n#+END_SRC   \n\n   DO: es mas general que dolist y dotimes\n#+BEGIN_SRC lisp\n   Ejemplo de uso:\n\t   (defun nuevo-expt (m n)\n\t\t  (do ((resultado 1)\t\t    ;;se inicializa parámetros\n\t\t       (exponente n))\n\t\t        (when (zerop exponente)       ;;condición de terminación\n\t\t\t  (return resultado))\n\t\t       (setq resultado (* m resultado))  ;;cuerpo del bucle\n\t\t       (setq exponente (- exponente 1))))\n#+END_SRC   \n\n   LOOP: Sólo se detiene al encontrarse con un return\n\t (loop \u003ccuerpo\u003e)\n\n   PROG1 y PROGN: ambos interpretan secuencias, progn devuelve el resultado de la n-ésima función y prog1 de la primera.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (progn (setq a 'x) (setq b 'y) (setq c 'z))\n#+END_SRC   \n\n* Funciones de Lectura y Escritura \n   print, format: son operaciones de salida de texto.\n#+BEGIN_SRC lisp\n   Ejemplo de uso:  (format t \"~%¡Hola!~%Estoy listo para empezar.\")\n#+END_SRC   \n\n   read: es una operación de lectura de texto.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setq dato-usuario (read))\n#+END_SRC   \n\n   read-line: absorve caracteres hasta donde aparece un retorno de carro o un fin de archivo. Luego produce una cadena con los caracteres q preceden el retorno de carro o el final del archivo, seguido de NIL, al menos que read-line encuentre el final del archivos mientras está leyendo una línea, en ese caso es T.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (read-line)\n   Ejemplo de uso: \n\t   (with-open-file (flujo-de-pacientes \"pacientes.lsp\" :direction :input)\n\t   (dotimes (n 4) (print (read-line flujo-de-pacientes))))\n   Ejemplo de uso:\n\t   (setq a \"line 1 \nline2\")\n\t   (read-line (setq input-stream (make-string-input-stream a)))\n#+END_SRC   \n\n   read-char: lee un carácter\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (read-char)\n#+END_SRC   \n\n   with-open-file: permite leer y escribir en archivos\n   plantilla:\n\t(with-open-file (\u003cnombre del flujo\u003e\n\t\t\t\u003c\"ruta del archivo\"\u003e\n\t\t\t:direction \u003c:input o :output\u003e)\n\t   ...)\n#+BEGIN_SRC lisp\n   Ejemplo de uso:\n       (with-open-file (flujo-de-pacientes \"pacientes.lsp\" \n\t\t\t\t\t   **:direction :input) \n\t\t       (do ((paciente (read flujo-de-pacientes nil 'eof) \n\t\t\t\t      (read flujo-de-pacientes nil 'eof))) \n\t\t\t   ((eq paciente 'eof)) \n\t\t\t   (format t \"~%¡Hola!~%Estoy listo para empezar. ~a\" (first paciente))))\n#+END_SRC   \n\n   open: permite escribir en archivos\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (defvar *st-local* (open \"/tmp/local1\" :direction :output :if-exists :rename-and-delete))\n#+END_SRC   \n\n   eval: es una operación que lee y evalúa.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (eval (read))\n#+END_SRC      \n\n* Propiedades\n\n   get: establece (con setf) y recupera el valor de una propiedad de un símbolo.\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (setf (get 'luis 'padres) '(alfonso monica)) ;; establece\n\t\t   (get 'luis 'padres)\t\t\t\t;; recupera\n(setf (get 'fechas 'startyear) '2013)\n(setf (get 'fechas 'startmonth) '06)\n(setf (get 'fechas 'endyear) '2013)\n(setf (get 'fechas 'endmonth) '12)\n#+END_SRC      \n\n* Arreglos \n\n   make-array: crea un arreglo en common lisp con la ayuda de setq\n#+BEGIN_SRC lisp\n   Ejemplo de uso (common lisp): (setq matriz-cl (make-array '(4 4)))\n   Ejemplo de uso (emacs lisp): (setq matriz-el '[[1 1 0 1] [0 1 0 1] [0 0 0 0] [0 1 0 0]])\n#+END_SRC      \n\n   aref: sirve para recuperar un valor del arreglo\n#+BEGIN_SRC lisp\n   Ejemplo de uso (common lisp): (setq (aref matriz-cl 0 0) 3)\n   Ejemplo de uso (emacs lisp): (aref (aref matriz-el 0) 0)\n#+END_SRC\n\n* Estructuras \n\n  defstruct: define una estructura lisp\n#+BEGIN_SRC lisp\n  Ejemplo de uso: (defstruct q (key #'identity) (last nil) (elements nil))\n#+END_SRC\n\n* Funciones y Macros \n  defun: crea funciones\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (defun square (x) (* x x))\n#+END_SRC      \n\n   defmacro: crea macros\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (defmacro square (X) `(* ,X ,X))\n   Ejemplo de uso: (defmacro square2 (X) `(let ((Temp ,X)) (* Temp Temp)))\n#+END_SRC      \n\n   macroexpand-1: devuelve la forma lisp del macro con sus argumentos\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (macroexpand-1 '(square 9))\n#+END_SRC\n\n* Entorno \n\n   get-universal-time: nos devuelve la fecha actual en formato unix\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (get-universal-time)\n#+END_SRC\n\n   machine-type: nos devuelve la familia de maquina que usamos\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (machine-type)\n#+END_SRC\n\n   time: nos devuelve el coste computacional en common lisp\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (time (+ 2 3))\n#+END_SRC\n\n   benchmark: es la función en elisp que devuelve el coste computacional\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (benchmark 4 (+ 2 3))\n#+END_SRC\n\n* Port \n\n   getenv: nos devuelve el valor de una variable de entorno\n#+BEGIN_SRC lisp\n   Ejemplo de uso: (port:getenv \"HOME\")\t\n#+END_SRC\n\n* Licencia\nEste documento está bajo una [[http://creativecommons.org/licenses/by/3.0/deed][Licencia Creative Commons Reconocimiento Unported 3.0]]\n\n[[file:http://i.creativecommons.org/l/by/3.0/88x31.png]]\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdavidam%2Fdavidam","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdavidam%2Fdavidam","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdavidam%2Fdavidam/lists"}