Lisp - Fatos Básicos

Enquanto o usuário ocasional do Maxima não precisa conhecer o Lisp, um bom entendimento de Lisp é necessário para aqueles que querem analisar o código do Maxima e adicionar seu próprio código.

Esse documento descreve as propriedades fundamentais do Lisp, não descreve as peculiaridades das implementações atualmente disponíveis.

(LENGTH <arg>)

Essa função responde o comprimento de seu argumento, uma lista.

Definição

(LAMBDA (arg)
  (COND ((NULL arg) 0)
        (T (ADD1 (LENGTH (CDR arg))))
) )

Regras

(INTEGERP (LENGTH <arg>))
       TRUE

(LENGTH (LIST))
       0

(LENGTH (APPEND <a>  <b>))  
       (PLUS (LENGTH <a>) (LENGTH <b>))

(APPEND <a> <b>)

Essa função responde uma nova lista contendo os elementos de nível mais alto de <a> e <b>.

Definição:

(DEFFUN APPEND
   (LAMBDA (A B)
      (COND ((NULL A) B)
            (T (CONS (CAR A)
                     (APPEND (CDR A) B)
)  )  )     )  )

Regras:

(APPEND (APPEND <a>  <b>) <c>)
       (APPEND <a> (APPEND <b>  <b>))

(REVERSE <arg>)

Essa função responde uma lista que contém os elementos de nível mais alto dos argumentos na ordem reversa.

Definição

(DEFFUN REVERSE
   (LAMBDA (A)
      (COND ((NULL A) NIL)
            (T (APPEND (REVERSE (CDR A))
                       (LIST (CAR A))
)  )  )     )  )

Uma definição recursiva final usa uma função auxiliar que pega dois parâmetros: uma lista de resto e a lista reversa  que é construida então:

(DEFFUN REVERSE
   (LAMBDA (A)
      ((LABEL RV
          (LAMBDA (rest result)
             (COND ((NULL rest) result)
                   (T (RV (CDR rest)
                          (CONS (CAR rest)
                                result
       )  )  )     )  )   )
       A
       NIL
)  )  )

Regras

(REVERSE (REVERSE <arg>))
       <arg>

(LENGTH (REVERSE <arg>))
       (LENGTH <arg>)

(REVERSE (APPEND <a>  <b>))  
       (APPEND (REVERSE <b>) (REVERSE <a>))

(MEMBER <arg> <list>)

Essa função verifica se <arg> é um elemento de nível mais alto da lista <list>.

Definição

(DEFFUN MEMBER
   (LAMBDA (A L)
      (COND ((NULL L) NIL)
            ((EQUAL A (CAR L)) B)
            (T (MEMBER A (CDR A)))
)  )  )

(PAIR <a> <a>)

Essa função verifica se <arg> é um elemento de nível mais alto da lista <list>.

Definição

(DEFFUN MEMBER
   (LAMBDA (A B)
      (COND ((OR (NULL A) (NULL B)) NIL)
            (T (CONS (CONS (CAR A) (CAR B))
                     (PAIR (CDR A) (CDR B))
            )  )
)  )  )

Uma Definição recursiva de final

(DEFFUN MEMBER
   (LAMBDA (A B)
      (COND ((OR (NULL A) (NULL B)) NIL)
            (T (CONS (CONS (CAR A) (CAR B))
                     (PAIR (CDR A) (CDR B))
            )  )
)  )  )