Deep-copying in JavaScript(dassur.ma)

    function foo(a) { a++; }
    function bar(ref a) { a++; }
    b = 1;
    foo(b); // Pass by value, implicit.
    assert(b == 1);
    bar(ref b); // Pass by reference.
    assert(b == 2);

    #include <stdlib.h>

    // assume some hash table library, exercise for the reader
    typedef struct{} *hashtable_t;
    extern hashtable_t hashtable_init(void);
    extern void hashtable_put(hashtable_t hashtable, const char* key, const char* value);
    extern void hashtable_dump(hashtable_t hashtable);

    typedef struct {
      hashtable_t table;
    } data_t;

    void foo(data_t* a)
    {
        hashtable_put(a->table, "otherKey", "b");
    }

    int main(void)
    {
        // let a = {key: 'a'};
        data_t* a = (data_t*) malloc(sizeof(data_t));
        a->table = hashtable_init();
        hashtable_put(a->table, "key", "a");

        foo(a);

        // console.log( a );
        hashtable_dump(a->table);
        return 0;
    }

  typedef struct {
      int bar;
  } Foo;
  
  void fun( Foo boo ) {
      boo.bar = 43;
  }
  
  int main() {
      Foo foo;
      foo.bar = 42;
  
      printf( "Before call: %d\n", foo.bar );
      fun( foo );
      printf( "After call: %d\n", foo.bar );
  
      return 0;
  }

  Before call: 42
  After call: 42

  function fun( boo ) {
      boo.bar = 43;
  }
  
  function main() {
      let foo = { bar: 42 }
  
      console.log( "Before call:", foo.bar );
      fun( foo );
      console.log( "After call:", foo.bar );
  }
  
  main();

  Before call: 42
  After call: 43