4 ms·

I cannot answer your questions in detail but here you find some useful information about Ada: http://www.ada2012.org http://www.ada2012.org http://www.adacore

by progman 12y ago

I cannot answer your questions in detail but here you find some useful information about Ada: http://www.ada2012.org http://www.ada2012.org http://www.adacore.com/knowledge http://www.adacore.com/knowledge http://www.adaic.org/ada-resources/standards/ http://www.adaic.org/ada-resources/standards/

dbaupp 12y ago
Sorry, those links are far far too broad to be useful for answering my specific questions for someone unfamiliar with Ada (like me). I took the time to Google a little, and as far as I can tell, Ada just doesn't allow you to take a reference (aka 'access') into a vector: http://wiki.ada-dk.org/ada.containers.vectors#vectorselement http://wiki.ada-dk.org/ada.containers.vectors#vectorselement I don't know if this means that it copies elements for every access or there is some black magic happening on the inside. Similarly, it seems that the only shared memory is so-called 'protected' types, which compulsorily have a mutex around every interaction, even if the shared memory is entirely immutable, or if they are some other sort of atomic type. As such, it seems that Ada doesn't necessarily have the same claim to those adjectives as Rust does. (Of course, I know next to nothing about Ada, so could easily be wrong.)
- pjmlp 12y ago
  Do you mean something like this? with Ada.Text_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedure example is data : array (1 .. 10) of aliased integer; dataPtr : access integer; begin for i in 1..10 loop data (i) := i; end loop; dataPtr := data(4)'access; Put("The array 4 is "); Put(dataPtr.all); New_Line; end example;
  - dbaupp 12y ago
    No. I'm interested in a dynamically allocated vector, where you take a pointer/reference/access to one of the elements and then try to add some more, which may cause the vector to reallocate and move in memory. Naively, this will leave the access dangling, pointing at invalid memory (which is not safe). The three solutions I mentioned: GC protects against this by not deallocating the original array. Disallowing taking references makes the whole situation impossible. Rust protects against it by disallowing mutation of the vector while the reference exists.

by progman 12y ago

dbaupp 12y ago

Sorry, those links are far far too broad to be useful for answering my specific questions for someone unfamiliar with Ada (like me). I took the time to Google a little, and as far as I can tell, Ada just doesn't allow you to take a reference (aka 'access') into a vector: http://wiki.ada-dk.org/ada.containers.vectors#vectorselement http://wiki.ada-dk.org/ada.containers.vectors#vectorselement I don't know if this means that it copies elements for every access or there is some black magic happening on the inside. Similarly, it seems that the only shared memory is so-called 'protected' types, which compulsorily have a mutex around every interaction, even if the shared memory is entirely immutable, or if they are some other sort of atomic type. As such, it seems that Ada doesn't necessarily have the same claim to those adjectives as Rust does. (Of course, I know next to nothing about Ada, so could easily be wrong.)

pjmlp 12y ago
Do you mean something like this? with Ada.Text_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedure example is data : array (1 .. 10) of aliased integer; dataPtr : access integer; begin for i in 1..10 loop data (i) := i; end loop; dataPtr := data(4)'access; Put("The array 4 is "); Put(dataPtr.all); New_Line; end example;
- dbaupp 12y ago
  No. I'm interested in a dynamically allocated vector, where you take a pointer/reference/access to one of the elements and then try to add some more, which may cause the vector to reallocate and move in memory. Naively, this will leave the access dangling, pointing at invalid memory (which is not safe). The three solutions I mentioned: GC protects against this by not deallocating the original array. Disallowing taking references makes the whole situation impossible. Rust protects against it by disallowing mutation of the vector while the reference exists.