sobre NIL

[Patricia Ferreira]

E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)

[Daniel Cerqueira]

Patricia Ferreira <pfer...@example.com> writes:

> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)

Gostei das respostas do Madhu, Kaz, e Raymond (acho que é assim o nome
dele). Gostei especialmente da simplicidade da resposta do Madhu. E
também pelo fato de ser uma aborgadem mais pragmática. Foi um ponto de
vista que eu ainda não tinha pensado. (já lhe agradeci.)

Estás atenta!

Nunca tinha postado em um grupo tão conhecido, mas foi um bom
testa-águas. Achei melhor fazê-lo lá, em vez de em pt, por ser um
publico mais abrangente.

Se bem que os teus conhecimentos são muito bons, e nota-se que tens um
bom método de estudo e um bom método de assimilar conhecimento :-)

[Patricia Ferreira]

Daniel Cerqueira <dan....@brilhante.top> writes:

> Patricia Ferreira <pfer...@example.com> writes:
>
>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>
> Gostei das respostas do Madhu, Kaz, e Raymond (acho que é assim o nome
> dele). Gostei especialmente da simplicidade da resposta do Madhu. E
> também pelo fato de ser uma aborgadem mais pragmática. Foi um ponto de
> vista que eu ainda não tinha pensado. (já lhe agradeci.)

Você escreve C? Já implementou listas encadeadas? Você vai ver o NIL
por lá. É essencialmente a mesma coisa. Pode ser implementado de outra
forma? Com certeza, mas o mais óbvio é usar o NULL de C mesmo.

> Estás atenta!
>
> Nunca tinha postado em um grupo tão conhecido, mas foi um bom
> testa-águas. Achei melhor fazê-lo lá, em vez de em pt, por ser um
> publico mais abrangente.

É isso aí.

> Se bem que os teus conhecimentos são muito bons, e nota-se que tens um
> bom método de estudo e um bom método de assimilar conhecimento :-)

Lol.

[Patricia Ferreira]

Daniel Cerqueira <dan....@brilhante.top> writes:

> Patricia Ferreira <pfer...@example.com> writes:
>
>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>
> Gostei das respostas do Madhu,

Tem um erro de digitação lá no Madhu.

``(consp nil) has to be true. NIL cannot be of type CONS.''

Ele quer dizer (consp nil) tem que ser *falso*. Tem que ser falso pra
que a gente possa distingui-lo de uma célula cons verdadeira. O tipo
Lista é matematicamente definido:

--8<---------------cut here---------------start------------->8---
Definição. Uma Lista é
- NIL ou...
- (cons <ANY-TYPE> Lista)
--8<---------------cut here---------------end--------------->8---

Assim, qualquer procedimento que consome uma lista tem a forma

(defun p (ls)
(cond ((null ls) 'something)
((consp ls) (car ls) (p (cdr ls)))))

Se NIL for um /cons/, não conseguimos distinguir o fim do não-fim.

A linguagem Common Lisp não determina como NIL realmente é por baixo dos
panos porque seria muita intromissão na implementação. E tanto faz,
desde que NIL não seja um CONS pra não estragar isso tudo aí.

Observe que Kaz Kylheku não está errado, não. Você pode, sim,
implementar NIL como se fosse uma célula CONS desde que (consp NIL) não
seja verdadeiro, o que pode ser feito olhando o conteúdo da célula e
vendo se ela satisfaz a definição de NIL. (Tem nada de muito importante
aqui, não.)

[Daniel Cerqueira]

Patricia Ferreira <pfer...@example.com> writes:

> Daniel Cerqueira <dan....@brilhante.top> writes:
>
>> Patricia Ferreira <pfer...@example.com> writes:
>>
>>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>>
>> Gostei das respostas do Madhu, Kaz, e Raymond (acho que é assim o nome
>> dele). Gostei especialmente da simplicidade da resposta do Madhu. E
>> também pelo fato de ser uma aborgadem mais pragmática. Foi um ponto de
>> vista que eu ainda não tinha pensado. (já lhe agradeci.)
>
> Você escreve C? Já implementou listas encadeadas? Você vai ver o NIL
> por lá. É essencialmente a mesma coisa. Pode ser implementado de outra
> forma? Com certeza, mas o mais óbvio é usar o NULL de C mesmo.

Sim, entendo. O NIL de CL é parecido ao NULL de C.

No entanto, há que realçar que Common Lisp e C são duas línguas muito
distintas. São paradigmas diferentes.

;-)

[Daniel Cerqueira]

Patricia Ferreira <pfer...@example.com> writes:

> Tem um erro de digitação lá no Madhu.
>
> ``(consp nil) has to be true. NIL cannot be of type CONS.''
>
> Ele quer dizer (consp nil) tem que ser *falso*. Tem que ser falso pra
> que a gente possa distingui-lo de uma célula cons verdadeira. O tipo
> Lista é matematicamente definido:

Sim, apesar do erro de escrita, consegui entender pois já conhecia
CONSP.

> Assim, qualquer procedimento que consome uma lista tem a forma
>
> (defun p (ls)
> (cond ((null ls) 'something)
> ((consp ls) (car ls) (p (cdr ls)))))
>
> Se NIL for um /cons/, não conseguimos distinguir o fim do não-fim.

Se NIL fosse um /cons/, o código que escreveste acima continuaria a
funcionar corretamente. Porque o COND está à espera que uma preposição
seja verdadeira para executar o código correspondente. Chegando ao NIL,
esse código executaria o 'something, tal como é esperado. E depois
saíria do COND (não procuraria por mais preposições).

Esse código correria bem, quer (consp nil) => T , quer (consp nil) =>
NIL .

Tudo o resto, entendi ;-)

[Patricia Ferreira]

Ah, que isso---são idênticas. Qualquer um que sabe escrever um
hello-world percebe.

#include <stdio.h>
int main(void) {
printf("Hello, world.\n");
return 0;
}

%./hello
Hello, world.

#+include <stdio.h>
(defun main (int void)
(format t "Hello, world.~%");
(return-from main 0);
)

(main 'int 'void)

%sbcl --script c.lisp
Hello, world.

:-)

[Patricia Ferreira]

Bem observado. Mas só por causa da ordem do cond. Se trocarmos a
ordem, ele não correria bem, não. Referi-me à forma do procedimento
também; não a um procedimento propriamente. Deveria ter sido mais claro
e escrever algo assim:

(defun p (ls)
(cond ((consp ls) (... (car ls) ... (p (cdr ls)) ...))
((null ls) 'something)))

Agora pelo menos aquele (car ls) não está solto por lá.

[Daniel Cerqueira]

Patricia Ferreira <pfer...@example.com> writes:

> Daniel Cerqueira <dan....@brilhante.top> writes:
>
>> Patricia Ferreira <pfer...@example.com> writes:
>>
>>> Daniel Cerqueira <dan....@brilhante.top> writes:
>>>
>>>> Patricia Ferreira <pfer...@example.com> writes:
>>>>
>>>>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>>>>
>>>> Gostei das respostas do Madhu, Kaz, e Raymond (acho que é assim o nome
>>>> dele). Gostei especialmente da simplicidade da resposta do Madhu. E
>>>> também pelo fato de ser uma aborgadem mais pragmática. Foi um ponto de
>>>> vista que eu ainda não tinha pensado. (já lhe agradeci.)
>>>
>>> Você escreve C? Já implementou listas encadeadas? Você vai ver o NIL
>>> por lá. É essencialmente a mesma coisa. Pode ser implementado de outra
>>> forma? Com certeza, mas o mais óbvio é usar o NULL de C mesmo.
>>
>> Sim, entendo. O NIL de CL é parecido ao NULL de C.
>>
>> No entanto, há que realçar que Common Lisp e C são duas línguas muito
>> distintas. São paradigmas diferentes.
>>
>> ;-)
>
> Ah, que isso---são idênticas. Qualquer um que sabe escrever um
> hello-world percebe.

Para mim, são duas linguagens bastante diferentes. Já por isso é que não
gosto muito de uma, e adoro a outra.

Por exemplo, macros em Lisp é totalmente diferente de macros em C.
Outro exemplo, funções de alto nível, em Lisp é trivial e dá muito
jeito, em C nem sei se existe tal funcionalidade. Em C não dá para
receber funções como argumentos, nem fazer funções que retornem funções.
Totalmente diferente.

[Patricia Ferreira]

Daniel Cerqueira <dan....@brilhante.top> writes:

> Patricia Ferreira <pfer...@example.com> writes:
>
>> Daniel Cerqueira <dan....@brilhante.top> writes:
>>
>>> Patricia Ferreira <pfer...@example.com> writes:
>>>
>>>> Daniel Cerqueira <dan....@brilhante.top> writes:
>>>>
>>>>> Patricia Ferreira <pfer...@example.com> writes:
>>>>>
>>>>>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>>>>>
>>>>> Gostei das respostas do Madhu, Kaz, e Raymond (acho que é assim o nome
>>>>> dele). Gostei especialmente da simplicidade da resposta do Madhu. E
>>>>> também pelo fato de ser uma aborgadem mais pragmática. Foi um ponto de
>>>>> vista que eu ainda não tinha pensado. (já lhe agradeci.)
>>>>
>>>> Você escreve C? Já implementou listas encadeadas? Você vai ver o NIL
>>>> por lá. É essencialmente a mesma coisa. Pode ser implementado de outra
>>>> forma? Com certeza, mas o mais óbvio é usar o NULL de C mesmo.
>>>
>>> Sim, entendo. O NIL de CL é parecido ao NULL de C.
>>>
>>> No entanto, há que realçar que Common Lisp e C são duas línguas muito
>>> distintas. São paradigmas diferentes.
>>>
>>> ;-)
>>
>> Ah, que isso---são idênticas. Qualquer um que sabe escrever um
>> hello-world percebe.
>
> Para mim, são duas linguagens bastante diferentes. Já por isso é que não
> gosto muito de uma, e adoro a outra.

Lol. Era uma piada. :-)

[Patricia Ferreira]

Patricia Ferreira <pfer...@example.com> writes:

> Daniel Cerqueira <dan....@brilhante.top> writes:
>
>> Patricia Ferreira <pfer...@example.com> writes:
>>
>>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>>
>> Gostei das respostas do Madhu,
>
> Tem um erro de digitação lá no Madhu.
>
> ``(consp nil) has to be true. NIL cannot be of type CONS.''
>
> Ele quer dizer (consp nil) tem que ser *falso*.

[...]

> Observe que Kaz Kylheku não está errado, não. Você pode, sim,
> implementar NIL como se fosse uma célula CONS desde que (consp NIL) não
> seja verdadeiro, o que pode ser feito olhando o conteúdo da célula e
> vendo se ela satisfaz a definição de NIL. (Tem nada de muito importante
> aqui, não.)

Parece que meu porta-voz entregou a mensagem lá em comp.lang.lisp. :-)

[Daniel Cerqueira]

Patricia Ferreira <pfer...@example.com> writes:

> Patricia Ferreira <pfer...@example.com> writes:
>
>> Daniel Cerqueira <dan....@brilhante.top> writes:
>>
>>> Patricia Ferreira <pfer...@example.com> writes:
>>>
>>>> E aí, Daniel? Qual seu relato da opinião-comp.lang.lisp sobre NIL? :-)
>>>
>>> Gostei das respostas do Madhu,
>>
>> Tem um erro de digitação lá no Madhu.
>>
>> ``(consp nil) has to be true. NIL cannot be of type CONS.''
>>
>> Ele quer dizer (consp nil) tem que ser *falso*.
>
> [...]
>
>> Observe que Kaz Kylheku não está errado, não. Você pode, sim,
>> implementar NIL como se fosse uma célula CONS desde que (consp NIL) não
>> seja verdadeiro, o que pode ser feito olhando o conteúdo da célula e
>> vendo se ela satisfaz a definição de NIL. (Tem nada de muito importante
>> aqui, não.)
>
> Parece que meu porta-voz entregou a mensagem lá em comp.lang.lisp. :-)

Sim! Já levou resposta, lá. ;-)

[Daniel Cerqueira]

Faltou os smileys para eu entender.

[Patricia Ferreira]

Tinha um no fim. Mas uma boa piada vai sem smiley. :-) Donald Knuth diz
que um autor deve inserir umas piadas pra quem tenha o conhecimento pra
entender. Funciona como uma recompensa. Se o smiley avisa que é uma
piada, é como se duvidássemos do leitor.

--8<---------------cut here---------------start------------->8---
[Humor is best used in technical writing when readers can understand the
joke only when they also understand a technical point that is being
made. Here is another example from Linderholm:

``... empty D = empty and N empty = N, which we may express by saying
that empty is absorbing on the left and neutral on the right, like
British toilet paper.''

Donald Knuth, ``Mathematical Writing'', 1987.
--8<---------------cut here---------------end--------------->8---

Se alguém diz que Common Lisp e C são idênticas, é óbvio que é uma
piada, mas o leitor precisa conhecer bem as duas, é claro. Além disso,
um hello world é obviamente similar em quase todas as linguagens---e
fizemos um tremendo esforço pra casar com C ao máximo possível.