why does this work? private new types.

why does this work? private new types.

[chris.danx]

Hi,

This example code will explain it better than I can.


with hash_tables;  -- generic
package blah is

   subtype word is string (some_range);

   type table is private;

   procedure add (a : in word;
                  t : in out table);

   ...

   private
      ... -- some functions in here

      package tables is new hash_tables
         (items => word,
          size => 100, -- for quickyness!
          hash_function => hash_function,
          equals => equals, to_string => to_string);

      type table is new tables.hash_table;

end blah;


package body blah is

   procedure add (a : in word;
                  t : in out table) is
   begin
      insert (a, t); -- *** here ***
   end add;

end blah;


insert is defined in hash_tables, so why can it be used in the body of blah
without "using" it?  Is it implicitly "used" when table is defined as a
'new' hash_table (i.e. it's allowed to be used .  That'd kindof make sense,
but is this the correct way to think of it, or is there a better way?

Seems like you learn new things about Ada every day!


Thanks,
Chris

Re: why does this work? private new types.

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 831 bytes --]


"chris.danx" <spamoff.danx@ntlworld.com> a �crit dans le message news: MmwB8.927$hg3.319129@news11-gui.server.ntli.net...
>
>       type table is new tables.hash_table;
>[...]
> insert is defined in hash_tables, so why can it be used in the body of blah
> without "using" it?  Is it implicitly "used" when table is defined as a
> 'new' hash_table (i.e. it's allowed to be used .  That'd kindof make sense,
> but is this the correct way to think of it, or is there a better way?
>
When you derive a type, all derived operations are declared *at the point of derivation*.
Therefore, the Insert for Table is declared immediately inside your package, and thus directly visible.

--
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: why does this work? private new types.

[chris.danx]

"Jean-Pierre Rosen" <rosen@adalog.fr> wrote in message
news:ab65j7$cfe$1@s1.read.news.oleane.net...

> When you derive a type, all derived operations are declared *at the point
of derivation*.
> Therefore, the Insert for Table is declared immediately inside your
package, and thus directly visible.

Thanks Jean-Pierre, I understand now!


Chris

Re: why does this work? private new types.

[Kai Schuelke]

Hello,

I am new to this newsgroup, and to ada, too. I read trough the latest
news to find something to learn and got the following:

> >       type table is new tables.hash_table;
[..]
> When you derive a type, all derived operations are declared *at the
point of derivation*.
> Therefore, the Insert for Table is declared immediately inside your
package, and thus directly visible.

Does that mean that INSERT is an Operation like "+" or "mod"? Or is
INSERT just a normal procedure? I can't imagine the last, but I never
heard/read about an INSERT Operator, either. It would be nice is
somebody could answer that question.

Thanks

Kai Schuelke

Re: why does this work? private new types.

[David C. Hoos]

----- Original Message ----- 
From: "Kai Schuelke" <kai.schuelke@gmx.net>
Newsgroups: comp.lang.ada
To: <comp.lang.ada@ada.eu.org>
Sent: Thursday, May 09, 2002 12:05 PM
Subject: Re: why does this work? private new types.
<snip>

> Does that mean that INSERT is an Operation like "+" or "mod"? Or is
> INSERT just a normal procedure? I can't imagine the last, but I never
> heard/read about an INSERT Operator, either. It would be nice is
> somebody could answer that question.
> 

Operations include both functions and procedures, whereas _operator_
is a special kind of function like abs, mod, +, -, *, **, and /, etc.

Re: why does this work? private new types.

[Stephen Leake]

"Kai Schuelke" <kai.schuelke@gmx.net> writes:

> > >       type table is new tables.hash_table;
> [..]
> > When you derive a type, all derived operations are declared *at the
> point of derivation*.
> > Therefore, the Insert for Table is declared immediately inside your
> package, and thus directly visible.
> 
> Does that mean that INSERT is an Operation like "+" or "mod"? Or is
> INSERT just a normal procedure? I can't imagine the last, but I never
> heard/read about an INSERT Operator, either. It would be nice is
> somebody could answer that question.

In Ada, the phrase "operation of a type" means any subprogram
that takes a parameter of the type or returns a result of the type.

The term "operator" refers to "+", "*" etc.

So INSERT is an "operation of type hash_table", but not an "operator".
And "+" is an operator, not an operation.

Every language has its own jargon :).

-- 
-- Stephe

Re: why does this work? private new types.

[Jeffrey Carter]

Stephen Leake wrote:
> 
> And "+" is an operator, not an operation.

"+" is both an operation and an operator. Not all operations are
operators, but all operators are operations.

-- 
Jeff Carter
"Nobody expects the Spanish Inquisition!"
Monty Python's Flying Circus