The struggle with Rust(ayende.com)

    let mut owned = vec![1, 2];
    let x = &mut owned[i];
    let y = &mut owned[j];

   alias lock unsigned int;
   lock() make_lock (
      return 0;
   )

   void(ref<lock> l) take_lock (
      while (l != 0); // Assume this is atomic for brevity
      l += 1; 
   )

   void(ref<lock> l) give_lock ( 
      l -= 1;
   )

   void(ref<lock> l) where (l != 0) give_lock (
      l -= 1;
   )

   int() thread_safe_fac(ref<lock> l, int some_important_data) (
      int f;
      take_lock(l);
      if (some_importand_data) {
         f = some_important_data * thread_safe_fac(l, some_important_data - 1);
      } else {
         f = 1;
         give_lock(l);
      }
      give_lock(l);
      return f;
   )

   void() main (
      lock l = make_lock();
      int some_important_data = 10;

      some_important_data = thread_safe_fac(&l, 10);

      print(some_important_data);
   )

   * Call thread safe fac
   * grab a lock
   * we theoretically touch some thread safe data
   * We hit a case where we do an if
      * Then run the then case
      * else set a default and free our lock
   * Free our lock

   void test(int *num) { *num *= 10; }
   int some_complex_function(int *num) {... free(num) ... }

   int main() {
     int *some_cool_data = (int*) malloc(sizeof(int);
     *some_cool_data = 5;

     while (true) {
       ...
       test(some_cool_data);
       ...
       some_complex_function(some_cool_data);
       ...
     }
   }

   // We now make sure the compiler knows that we only want to accept real references to initialize ptr
   int some_complex_function(int **num) where (num && *num) {... free(*num); *num = NULL; ... }

   // We've removed the path through the program that allows the data to be used after free.
   while (some_cool_data) {
      ...
      some_complex_function(&some_cool_data);
      ...
   }