Re: How to get Ada to “cross the chasm”?

[Jere <jhb.chat@gmail.com>]

On Friday, May 4, 2018 at 12:13:09 PM UTC-4, guyclaud wrote:
> Since this topic has somewhat turn into a Ada vs Rust/Haskell/whatever, could some experts show a piece of Ada code where the "borrower-checker" would more check/security ? Or are the paradigms too different to show a snippet close enough to (or IN ) Ada so that I can understand ?

They are very different languages.  I am going to try and show a couple of
situations caught by Rust at compile time.  They won't be perfect comparisons
though.  Keep in mind that Ada can pass objects by reference internally 
while in Rust it has to be explicitly requested.  

1.  Dangling references:  Keeping a reference to an object past its lifetime

Ada:
***********************************************
with Ada.Text_IO; use Ada.Text_IO;

procedure jdoodle is
    type Integer_Access is access all Integer;
    
    function Inner(Value : aliased in out Integer) return Integer_Access is
    begin
        return Value'Access;
    end Inner;
    
    function Outer return Integer_Access is
        Value : aliased Integer := 0;
    begin
        return Inner(Value);
    end Outer;
    
    Ptr : Integer_Access := Outer;  -- !!! Dangling reference
begin
    Put_Line("Hello World");
end jdoodle;
***********************************************
Hello World

gcc -c jdoodle.adb
gnatbind -x jdoodle.ali
gnatlink jdoodle.ali -o jdoodle



A attempt to the equivalent in Rust:
***********************************************
pub fn Inner(value : & mut i32) -> & mut i32 {
    return value;
}

pub fn Outer() -> &mut i32 {
    let mut x = 0 as i32;
    return Inner(&x);
}

pub fn main() {
    let ptr : &mut i32 = Outer;
    println!("Hello World")
}
***********************************************
Compiling playground v0.0.1 (file:///playground)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:19
  |
5 | pub fn Outer() -> &mut i32 {
  |                   ^ expected lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
  = help: consider giving it a 'static lifetime

You have to make it use a static lifetime to work (which removes the
dangling reference) while Ada does accept it as is.


2.  Concurrent Erroneous Access
Ada:
******************************************
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Vectors;

procedure jdoodle is

    package Vectors is new Ada.Containers.Vectors(Positive,Integer);

    type Some_Type is limited record
        Data : Vectors.Vector;
    end record;
    
    Some_Object : aliased Some_Type;
    
    task Some_Task is
        entry Start;
    end Some_Task;
    
    task body Some_Task is
    begin
        accept Start;
        for Index in 1 .. 100 loop
            Some_Object.Data.Append(Index);
        end loop;
    end Some_Task;
    
begin
    Put_Line("Hello World");
    Some_Task.Start;
    for Index in 1 .. 100 loop
        Some_Object.Data.Append(Index);  -- !!! Possible Erroneous Memory Access
    end loop;
end jdoodle;
******************************************
Hello World

gcc -c jdoodle.adb
gnatbind -x jdoodle.ali
gnatlink jdoodle.ali -o jdoodle



Attempt at a similar setup in Rust:
******************************************
use std::vec;
use std::thread;

pub struct SomeType {
    pub data : vec::Vec<i32>
}

pub fn main() {
    let mut some_object = SomeType{
        data : vec::Vec::new()
    };
    
    println!("Hello World");
    
    let handler = thread::spawn(move || {
        for index in 1 .. 11 {
            some_object.data.push(index as i32);
        }
    });
    
    for index in 1 .. 11 {
        some_object.data.push(index as i32);
    }
    handler.join().unwrap();
}
******************************************
Compiling playground v0.0.1 (file:///playground)
error[E0382]: use of moved value: `some_object.data`
  --> src/main.rs:22:9
   |
15 |     let handler = thread::spawn(move || {
   |                                 ------- value moved (into closure) here
...
22 |         some_object.data.push(index as i32);
   |         ^^^^^^^^^^^^^^^^ value used here after move
   |
   = note: move occurs because `some_object` has type `SomeType`, which does not implement the `Copy` trait

If you try and remove the move specifier it then gives the error
that you need to put the move specifier to pass data into the thread.
Basically, in Rust it forces you to use synchronization primitives
on any variable being used in a thread (task equiv), which would be
similar to if Ada required all variables in a thread to be protected
types or fulfilled some other task safe context.

Again, the languages are quite different so it is really hard to 
put together an actual comparison.  Ada has many strengths over
Rust though.  It is always easy to find some area where language
x is better than langauge y in a particular area.  What matters
most is the whole package vs the whole package and how they affect
software development and design.