functional programming - programming - ¿Puedo hacer esto en Lisp?

functional programming languages

Question

He estado buscando en todas partes la siguiente funcionalidad en Lisp, y no he llegado a ninguna parte:

1. encuentre el índice de algo en una lista. ejemplo:

   (index-of item InThisList)

2. reemplaza algo en un lugar específico en una lista. ejemplo:

   (replace item InThisList AtThisIndex) ;i think this can be done with ''setf''?

3. devolver un artículo en un índice específico. ejemplo:

   (return InThisList ItemAtThisIndex)

Hasta este punto, he estado fingiendo con mis propias funciones. Me pregunto si solo estoy creando más trabajo para mí.

Así es como he estado simulando el número 1:

(defun my-index (findMe mylist)
(let ((counter 0) (found 1))
(dolist (item mylist)
(cond
((eq item findMe) ;this works because ''eq'' checks place in memory,
;and as long as ''findMe'' was from the original list, this will work.
(setq found nil)
(found (incf counter))))
counter))

Answer 1

Las respuestas de Jeremy deberían funcionar; pero dicho eso, si te encuentras escribiendo código como

(setf (nth i my-list) nuevo-elt)

probablemente estés utilizando la estructura de datos incorrecta. Las listas son simplemente listas vinculadas, por lo que son O (N) para acceder por índice. Es posible que sea mejor usar matrices.

O tal vez estés usando listas como tuplas. En ese caso, deberían estar bien. Pero es probable que desee nombrar accesadores para que alguien que lea su código no tenga que recordar lo que se supone que significa "enésimo 4". Algo como

(defun my-attr (list)
(nth 4 list))
(defun (setf my-attr) (new list)
(setf (nth 4 list) new))

Answer 2

Soy novato, pero puedes usar setf y nth para hacer el número 2 y 3.

(let ((myList ''(1 2 3 4 5 6)))
(setf (nth 4 myList) 101); <----
myList)
(1 2 3 4 101 6)

Ninguna pista sobre el número uno.

EDIT: para el número uno, puede usar la función de position . Decir ah.

(let ((myList ''(1 2 3 4 5 6)))
(setf (nth 4 myList) 101)
(list myList (position 101 myList)))
((1 2 3 4 101 6) 4)

Encontré todo esto en este índice .

Answer 3

Tengo que estar de acuerdo con Thomas. Si usa listas como matrices, entonces eso será lento (y posiblemente incómodo). Por lo tanto, debe usar matrices o apegarse a las funciones que ha escrito, pero muévalas "hacia arriba" de forma que pueda reemplazar fácilmente las listas lentas con matrices más adelante.

Answer 4

Respuestas

1. (posición secuencia de elemento y clave desde el final (inicio 0) prueba de prueba de tecla final-no)
   http://lispdoc.com/?q=position&search=Basic+search

2. (valor setf (índice de secuencia elt)

3. (índice de secuencia elt)
   http://lispdoc.com/?q=elt&search=Basic+search
   NOTA: elt es preferible a nth porque elt funciona en cualquier secuencia, no solo en listas

Answer 5

+2 para "Practical Common Lisp". Es una mezcla de un libro de recetas de Common Lisp y un libro Teach Yourself Lisp de calidad.

También hay "Common Common Lisp" ( http://www.psg.com/~dlamkins/sl/cover.html y http://www.psg.com/~dlamkins/sl/contents.html ) que parecía llenar algunas lagunas / ampliar cosas en "Practical Common Lisp".

También leí el "ANSI Common Lisp" de Paul Graham, que trata más sobre los conceptos básicos del lenguaje, pero un poco más de un manual de referencia.

Answer 6

1. encuentre el índice de algo en una lista.

En Emacs Lisp y Common Lisp, tiene la función de position :

> (setq numbers (list 1 2 3 4))
(1 2 3 4)
> (position 3 numbers)
2

En Scheme, aquí hay una implementación recursiva de cola del documento de DrScheme :

(define list-position
(lambda (o l)
(let loop ((i 0) (l l))
(if (null? l) #f
(if (eqv? (car l) o) i
(loop (+ i 1) (cdr l)))))))
----------------------------------------------------
> (define numbers (list 1 2 3 4))
> (list-position 3 numbers)
2
> 

Pero si está utilizando una lista como una colección de espacios para almacenar datos estructurados, tal vez debería echarle un vistazo a defstruct o incluso algún tipo de sistema de objetos Lisp como CLOS.

Si estás aprendiendo Lisp, asegúrate de echar un vistazo a Practical Common Lisp y / o The Little Schemer .

¡Aclamaciones!