Rust Tutorial : Ownership
from tutorialspoint.com

Stack
a stack follows a last in first out order
stack stores data values for which the size is known at compile time
a variable of fixed size i32 is a candidate for stack allocation as its size is known at compile time
all scalar types can be stored in stack as the size is fixed

a string can't be stored on the stack because a string which is assigned a value at runtime
the exact size of such a string cannot be determined at compile time

Heap
the heap memory stores data values the size of which is unknown at compile time
is used to store dynamic data
a heap memory is allocated to data values that may change throughout the life cycle of the program
the heap is an area in the memory which is less organized when compared to stack
What is Ownership?
each value in Rust has a variable that is called owner of the value
every data stored in Rust will have an owner associated with it
let age = 30, age is the owner of the value 30
Transferring Ownership
assigning value of one variable to another variable
the key selling point of Rust as a language is its memory safety
memory safety is achieved by tight control on who can use what and when restrictions 
fn main(){
   let v = vec![1,2,3]; 
   // vector v owns the object in heap

   //only a single variable owns the heap memory at any given time
   let v2 = v; 
   // here two variables owns heap value,
   //two pointers to the same content is not allowed in rust

   //Rust is very smart in terms of memory access, so it detects a race condition
   //as two variables point to same heap

   println!("{:?}",v);
}
the above example declares a vector v
the idea of ownership is that only one variable binds to a resource, either v binds to resource or v2 binds to the resource
the above example throws an error − use of moved value: 'v'
this is because the ownership of the resource is transferred to v2
it means the ownership is moved from v to v2 (v2=v) and v is invalidated after the move

passing value to a function
the ownership of a value also changes when passing an object in the heap to a closure or function 
fn main(){
   let v = vec![1,2,3];     // vector v owns the object in heap
   let v2 = v;              // moves ownership to v2
   display(v2);             // v2 is moved to display and v2 is invalidated
   println!("In main {:?}",v2);    //v2 is No longer usable here
}
fn display(v:Vec){
   println!("inside display {:?}",v);
}
returning value from a function
ownership passed to the function will be invalidated as function execution completes
one work around for this is let the function return the owned object back to the caller 
fn main(){
   let v = vec![1,2,3];       // vector v owns the object in heap
   let v2 = v;                // moves ownership to v2
   let v2_return = display(v2);    
   println!("In main {:?}",v2_return);
}
fn display(v:Vec)->Vec { 
   // returning same vector
   println!("inside display {:?}",v);
}
Ownership and Primitive Types
in case of primitive types, contents from one variable is copied to another
there is no ownership move happening
a primitive variable needs less resources than an object 
fn main(){
   let u1 = 10;
   let u2 = u1;  // u1 value copied(not moved) to u2

   println!("u1 = {}",u1);
}
index