function memo<T>(cb: () => any) {
  /*
    The goal of this memo is to minimize recalculations, 
    yet still supply a syncronized value on demand.
    - The only way to minimize recalculation on demand in this scenario 
      is to track whether dependancies go dirty (recalc required).
    - Avoiding recalc on reactive updates means the
      subscriptions will be cleared and the effect disposed.
      This actually eliminates unnecesary side-effects entirely,
      but requires the effect be re-initialized each recalculation. 
  */
  let [last_val, set_last] = createSignal<T>();
  let is_dirty = true;

  let owner = getOwner();
  let effect = () => {
    runWithOwner(owner, () => {
      createComputed(() => {
        if (is_dirty) {
          console.log("recalc");
          // run, memo, and mark clean
          set_last(cb());
          is_dirty = false;
        } else {
          console.log("made dirty");
          // Dispose effect:
          // no need to listen to subsequent updates once known to be dirty
          is_dirty = true;
        }
      });
    });
  };
  effect();

  return () => {
    // if dirty, recalc on demand
    // init new comp. to listen for dirty toggle
    if (is_dirty) effect(); 
    return last_val();  // return clean memo
  };
}

function memo<T>(cb: () => any) {
  /*
    The goal of this memo is to minimize recalculations, 
    yet still supply a syncronized value on demand.
    - The only way to minimize recalculation on demand in this scenario 
      is to track whether dependancies go dirty (recalc required).
    - Avoiding recalc on reactive updates means the
      subscriptions will be cleared and the effect disposed.
      This actually eliminates unnecesary side-effects entirely,
      but requires the effect be re-initialized each recalculation. 
  */
  let [last_val, set_last] = createSignal<T>();
  let is_dirty = true;

  let owner = getOwner();
  let effect = () => {
    runWithOwner(owner, () => {
      createComputed(() => {
        if (is_dirty) {
          console.log("recalc");
          // run, memo, and mark clean
          set_last(cb());
          is_dirty = false;
        } else {
          console.log("made dirty");
          // Dispose effect:
          // no need to listen to subsequent updates once known to be dirty
          is_dirty = true;
        }
      });
    });
  };
  effect();

  return () => {
    // if dirty, recalc on demand
    // init new comp. to listen for dirty toggle
    if (is_dirty) effect(); 
    return last_val();  // return clean memo
  };
}

function memo<T>(watch: ()=>any, cb: () => any) {
  const [track, trigger] = createSignal(void 0, { equals: false })
  const value = createMemo(on(track, cb, {defer:true}))
  return () => {
    trigger()
    return value();
  };
}

function memo<T>(watch: ()=>any, cb: () => any) {
  const [track, trigger] = createSignal(void 0, { equals: false })
  const value = createMemo(on(track, cb, {defer:true}))
  return () => {
    trigger()
    return value();
  };
}

function memo<T>(watch: () => any, cb: () => T) {
  let last_val: T;

  let is_dirty = true;
  createComputed(() => {
    watch();
    console.log("made dirty");
    is_dirty = true;
  });

  return () => {
    if (is_dirty) {
      last_val = cb();
      is_dirty = false;
    }
    return last_val;
  };
}

function memo<T>(watch: () => any, cb: () => T) {
  let last_val: T;

  let is_dirty = true;
  createComputed(() => {
    watch();
    console.log("made dirty");
    is_dirty = true;
  });

  return () => {
    if (is_dirty) {
      last_val = cb();
      is_dirty = false;
    }
    return last_val;
  };
}

{
  a: {parent: ''}  // no parent is the root
  b: {parent: 'a'}
  c: {parent: 'b'}
  d: {parent: 'a'}
}

{
  a: {parent: ''}  // no parent is the root
  b: {parent: 'a'}
  c: {parent: 'b'}
  d: {parent: 'a'}
}