Re: S-expression I/O in Ada

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Natasha Kerensikova <lithiumcat@gmail.com> writes:

> Well, let's relatively well hidden compared to its C counterpart, where
> I'm only "man gcc" away from the exhaustive list of command-line
> switches, or "man whatever_function" away from a standard library
> function documentation.

I hate man pages, because they tend to require that I already
know what I'm looking for.  Interestingly, usually when I
do "man <something>" these days, I often get a man page that tells
me to go look at the "info" docs.

Anyway, man pages wouldn't make a lot of sense for windows users.

> But then it might be more FreeBSD's fault than GNAT's, considering
> provided GNAT man pages don't cover Ada stuff, and provided GNAT info
> pages are not in info search path. But then calling the user manual info
> file "gnat_ugn.info" is quite unintuitive, and the organization of the
> info file looks pretty messy (but then again I'm not used to info
> pages, and man pages tend to be shorter and more specialized).

OK, but now you know where to find the GNAT docs.  I suggest you
print out the .pdf files and read them.  Or look at the .txt
files in your favorite text editor (and search for things).
Or look at the .html files in your browser.  Or use info.
Whatever you're most comfortable with.

>>> function Root(From : in Container) return Cursor is
>>> begin
>>>    return Cursor'(Parent => null, Node => From.Root);
>>> end Root;
>>
>> Nothing wrong with that.  I would probably write
>> "return (Parent => null, Node => From.Root);"
>
> I wasn't aware of that even-shorter form.

"(Parent => null, Node => From.Root)" is an aggregate.
It's type is determined from context (in this
case, the expected type of the expression is Cursor,
because that's what the function returns).

"T'(X)" is a qualified expression -- it tells you that the
type of X is T.  This is necessary when the type is ambiguous.
You can also use it for clarity when it's not necessary.

Combining the two, you have "Cursor'((Parent => null, Node =>
From.Root))", but there's a special syntax rule that allows you to leave
out one set of parentheses, whenever an aggregate is used as the
argument of a qualified expression.

>...I should really take the time
> to read the reference manual (hoping now I've reached the level needed
> to understand it).

Well, the RM is pretty tough going.  I suggest a text book
instead.  The Barnes book, for example -- it's fun to read
because of John's wry sense of humour.  There are also some
on-line tutorials you can find via google.

> Thanks for your remarks,

You're welcome.

- Bob