Listar operações em Lisp

Question

Tenho procurado em todos os lugares a seguinte funcionalidade no Lisp e não cheguei a lugar nenhum:

1. encontre o índice de algo em uma lista.exemplo:

   (index-of item InThisList)
   

2. substitua algo em um local específico de uma lista.exemplo:

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

3. retornar um item em um índice específico.exemplo:

   (return InThisList ItemAtThisIndex)
   

Até agora, estive fingindo com minhas próprias funções.Estou me perguntando se estou apenas criando mais trabalho para mim.

É assim que estou fingindo o 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

Você pode usar setf e nth para substituir e recuperar valores por índice.

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

(1 2 3 4 101 6)

Para encontrar por índice você pode usar o position função.

(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)

Eu encontrei tudo isso neste índice de funções.

Answer 2

1. encontre o índice de algo em uma lista.

No Emacs Lisp e Common Lisp, você tem o position função:

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

No Scheme, aqui está uma implementação recursiva final de DrSchemedocumento:

(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
> 

Mas se você estiver usando uma lista como uma coleção de slots para armazenar dados estruturados, talvez você deva dar uma olhada em defstruct ou até mesmo algum tipo de sistema de objetos Lisp como CLOS.

Se você está aprendendo Lisp, dê uma olhada em Lisp comum prático e/ou O Pequeno Conspirador.

Saúde!

Answer 3

Respostas:

1. (posicionar sequência de itens e chave de fim (início 0) teste de chave final teste-não)
   http://lispdoc.com/?q=position&search=Basic+search

2. (valor setf (índice de sequência elt))

3. (índice de sequência elt)
   http://lispdoc.com/?q=elt&search=Basic+search
   OBSERVAÇÃO:elt é preferível ao enésimo porque elt funciona em qualquer sequência, não apenas em listas

Answer 4

As respostas de Jeremy deveriam funcionar;mas dito isso, se você estiver escrevendo código como

(setf (nth i minha-lista) new-elt)

você provavelmente está usando a estrutura de dados errada.As listas são simplesmente listas vinculadas, portanto, podem ser acessadas por índice.Talvez seja melhor usar matrizes.

Ou talvez você esteja usando listas como tuplas.Nesse caso, eles deveriam ficar bem.Mas você provavelmente deseja nomear os acessadores para que alguém que leia seu código não precise se lembrar do que "enésimo 4" significa.Algo como

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

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

Answer 5

+2 para "Lisp Comum Prático".É uma mistura de um livro de receitas Common Lisp e um livro Teach Yourself Lisp de qualidade.

Há também "Lisp comum bem-sucedido" (http://www.psg.com/~dlamkins/sl/cover.html e http://www.psg.com/~dlamkins/sl/contents.html) que parecia preencher algumas lacunas/ampliar as coisas em "Practical Common Lisp".

Eu também li o "ANSI Common Lisp" de Paul Graham, que é mais sobre o básico da linguagem, mas um pouco mais como um manual de referência.

Answer 6

Tenho que concordar com Tomás.Se você usar listas como arrays, isso será lento (e possivelmente estranho).Portanto, você deve usar arrays ou seguir as funções que escreveu, mas movê-las "para cima" de forma que possa substituir facilmente as listas lentas por arrays posteriormente.