Why stack can hold indefinite objects but records cannot?

Why stack can hold indefinite objects but records cannot?

[Victor Porton]

Why is it OK to create an indefinite object as a local variable ("on stack") 
but not OK to put an indefinite object into a record?

How records are less powerful than the stack?

By the way, how indefinite local variables can be implemented? (just 
curious)

Moreover, wouldn't it to be a good idea to allow indefinite objects in 
records (thus making the record itself indefinite, even if it has no 
discriminants)? I realize that then it would be difficult to track which 
records are definite and which indefinite. But what's about the idea?

-- 
Victor Porton - http://portonvictor.org

Re: Why stack can hold indefinite objects but records cannot?

[Dmitry A. Kazakov]

On 2017-11-28 21:31, Victor Porton wrote:
> Why is it OK to create an indefinite object as a local variable ("on stack")
> but not OK to put an indefinite object into a record?

It is OK in both cases. You must provide the constraint that is.

> By the way, how indefinite local variables can be implemented? (just
> curious)

They cannot, there is no such thing.

A variable can hold a value which constraints vary. Each value is 
constrained. These either deploy a maximum allocation length like 
bounded strings or hidden referential semantics like unbounded strings.

> Moreover, wouldn't it to be a good idea to allow indefinite objects in
> records (thus making the record itself indefinite, even if it has no
> discriminants)?

It is a bad idea because there is no straightforward implementation of.

The proper solution is to have an abstract record interface which would 
allow anything appear a record member whereas the implementation would 
be left to the user. The compiler should provide simple implementation 
of that out of the box, maybe even less than it does already.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Why stack can hold indefinite objects but records cannot?

[Victor Porton]

Dmitry A. Kazakov wrote:

> On 2017-11-28 21:31, Victor Porton wrote:
>> Why is it OK to create an indefinite object as a local variable ("on
>> stack") but not OK to put an indefinite object into a record?
> 
> It is OK in both cases. You must provide the constraint that is.
> 
>> By the way, how indefinite local variables can be implemented? (just
>> curious)
> 
> They cannot, there is no such thing.
> 
> A variable can hold a value which constraints vary. Each value is
> constrained. These either deploy a maximum allocation length like
> bounded strings or hidden referential semantics like unbounded strings.
> 
>> Moreover, wouldn't it to be a good idea to allow indefinite objects in
>> records (thus making the record itself indefinite, even if it has no
>> discriminants)?
> 
> It is a bad idea because there is no straightforward implementation of.
> 
> The proper solution is to have an abstract record interface which would
> allow anything appear a record member whereas the implementation would
> be left to the user. The compiler should provide simple implementation
> of that out of the box, maybe even less than it does already.

But for the stack this is implemented. I don't understand why the same 
cannot be done for records.

-- 
Victor Porton - http://portonvictor.org

Re: Why stack can hold indefinite objects but records cannot?

[Dmitry A. Kazakov]

On 2017-11-28 22:31, Victor Porton wrote:

> But for the stack this is implemented.

No it is not. You must provide constraint. E.g.:

    X : String (1..80);

or

    X : String := "1234";


> I don't understand why the same cannot be done for records.
Records are just same:

    type Foo is record
       X : String (1..80);
    end record;

You cannot have unconstrained variables, members, objects. As I said, 
there is no such thing, and there cannot be. It is incomputable.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Why stack can hold indefinite objects but records cannot?

[Randy Brukardt]

"Victor Porton" <porton@narod.ru> wrote in message 
news:ovkh24$1bh5$1@gioia.aioe.org...
> Why is it OK to create an indefinite object as a local variable ("on 
> stack")
> but not OK to put an indefinite object into a record?
>
> How records are less powerful than the stack?

Because records can be composed into other data structures, while a local 
variable cannot be composed into something else.

> By the way, how indefinite local variables can be implemented? (just
> curious)

Depends on the compiler. Janus/Ada allocates them from a special storage 
pool (which really just wraps the normal heap), then frees them when the 
scope is left. Some other compilers change the size of the stack frame 
instead.

> Moreover, wouldn't it to be a good idea to allow indefinite objects in
> records (thus making the record itself indefinite, even if it has no
> discriminants)? I realize that then it would be difficult to track which
> records are definite and which indefinite. But what's about the idea?

It would be very hard to implement in composite objects: imagine an 
multi-dimensional array of such records. That would be especially true for 
implementations that try to avoid using storage pools at all costs (which is 
necessary for some safety-critical customers).

                                               Randy.