typescript dynamic memoization (rspec let)

memo.ts

type MemoProps<T> = { [P in keyof T]: (this: T) => T[P] }

export const MemoProto = {
  clone: function () {
    return this.define({});
  },

  define: function define<T>(this: T & {}, props: MemoProps<T>): MemoState<T> {
    // share the prototype, so we can nest but still destroy
    const update = Object.create(this);

    // define memoized versions of the incoming props
    for (let key in props) {
      let value: any;
      let executed = false;

      Object.defineProperty(update, key, {
        get: () => {
          if (!executed) {
            value    = props[key].call(this);
            executed = true;
          }

          return value;
        },
        enumerable: true,
      });
    }

    // return the new object with fallback in the prototype chain
    return update;
  }
};

export type MemoState<T> = T & {
  clone: (this: T) => MemoState<T>,
  define: <U>(this: T & {}, p: MemoProps<U>) => MemoState<T & U>
};

export const Memo: MemoState<{}> = Object.create(MemoProto);