kunigami

function makeIterator(n) {
    return {
      cnt: n,
    
      next: function() {
        this.cnt--;
        return {value: this.cnt, done: this.cnt < 0};
      },
    
      [Symbol.iterator]: function() { return this }

kunigami

try {
  a = await fetchSomeStuff();
  b = await fetchSomeStuffDependingOnA(a);
  c = await fetchSomeStuffDependingOnB(b);
} catch (ex) {
  handleException(ex);
}

kunigami

function fetchSomeStuff() {
  return new Promise((resolve, reject) => {
      someAsyncRequest()
        .onSuccess(
          payload => resolve(payload.value) 
        )
        .onFailure(
          payload => reject(payload.error)
        )
        .execute();

kunigami

fetchSomeStuff().then(
    function (a) {
        return fetchSomeStuffDependingOnA(a);
    }
).then(
    function (b) {
        return fetchSomeStuffDependingOnB(b);
    }
).then(
    function (c) {

kunigami

fetchSomeStuff(
    /* onSuccess*/ function (a) {
        fetchSomeStuffDependingOnA(
            a,
            /* onSuccess */ function (b) {
                fetchSomeStuffDependingOnB(
                    b,
                    /* onSuccess */ function (c) {
                        /* Code goes on here */
                    },

kunigami

fn find_node_with_visitor<F>(
  ...
  k: &K,
  mut visitor: F
) -> where F: FnMut(&K) {
    ...
    visitor(&key);
    ...
}

kunigami

struct NodePtr<K: Ord, V>(*mut RBTreeNode<K, V>);
...
pub struct RBTree<K: Ord, V> {
    root: NodePtr<K, V>,
    ...
}
...
// in find_node_with_visitor()
let mut temp = &self.root;
let key = &(*temp.0).key;

kunigami

let mut num = 5;

let r1 = &num as *const i32;

unsafe {
    println!("r1 is: {}", *r1);
}

kunigami

// Every container key is smaller than the target_key. In this case we 'wrap around' the
// table and select the first element.
if (closest_key == std::u32::MAX) {
    let result = self.containers.get_first();
    match result {
        None => {
            return Err("Did not find first entry.");
        }
        Some((_, entry)) => {
            let container_id = &entry.id;

kunigami

fn find_node_with_visitor<F>(
    &self,
    k: &K,
    mut visitor: F
) -> NodePtr<K, V> where F: FnMut(&K) {
    if self.root.is_null() {
        return NodePtr::null();
    }
    let mut temp = &self.root;
    unsafe {