Re: S-expression I/O in Ada

[Natasha Kerensikova <lithiumcat@gmail.com>]

On 2010-08-14, Ludovic Brenta <ludovic@ludovic-brenta.org> wrote:
> OK, but these two are equivalent if you remember the axiom that (y
> . nil) is really just y.

Ok, that's the part I have trouble with. When thinking in list terms,
that cons feels like it's the operation of prepending an item to an
existing list, right?

Here is my understanding, please correct me where I'm wrong. Oh, I'm
going to have to type that.

Let's assume we have a Node type, which can be either a List or an Atom
(little Ada question as an aside, Node would then be a parametrized
type, and the two cases would be called Node(List) and Node(Atom),
right? or have I misunderstood something?).

The cons operation would then take a Node as its first parameter (before
the dot) and a List as its second, and return a List which is
semantically the input list prepended by the first parameter taken as a
list item. Right?

So nil is of type List and represents the empty list. Then (y . nil) is
a List containing a single node, which is the Atom y. So I feel that y
is of type Atom while (y . nil) is of type List.

(Then (x . (y .nil)) is the previous list with x prepended, therefore
the two-item list containing x then y.
And then (z . (x . (y . nil))) would be a three-item list.
But then what of ((x . (y. nil)) . (z . nil))? It looks to me like
a two-item list whose first item is a list, followed by the atom z. But
then how would reverse list be written?
Maybe (z . ((x . (y . nil)) . nil))? But that doesn't fit with your
derivation pattern on tcp-connect, so I'm lost.)

Now I can understand that in an untyped environment, an Atom can be
automagically cast into a single-item list. In such a case, (x . y) is
first translated into (x . LY) where LY is the List containing the Atom
y a its only item (i.e. (y . nil)). And now that cons is correctly typed
like (Node . List), it ends up with the two-item List containing the
Atom x followed by the Atom y.

But then how would you make a list ending with LY? My guess would be
(x . (LY . nil)), but then it is not equivalent to (x . LY), so I'm lost
again.

Or are single-item lists prohibited in lisp?


Thanks for your patience,
Natacha