function sum(arr: number[]) {
  let out = 0;

  for (const val of arr) {
    out += 1;
    out += val;
  }

  return out;
}

function hasPairWithSum(arr: number[], sum: number) {
  for (const a of arr) {
    for (const b of arr) {
        if (a + b === sum) {
            return true; 
        }
    }
  }

  return false;
}

function hasPairWithSum(arr: number[], sum: number) {
  for (const a of arr) {
    const need = sum - a;
    if (has(arr, need)) {
      return true;
    }
  }

  return false;
}

const has1 = (arr, n) => arr.indexOf(n) !== -1;
const has2 = (arr, n) => arr.find(x => n === x);

// assume arr is sorted
const has3 = (arr, n) => {
  let low = 0;
  let high = arr.length - 1;

  while (low < high) {
    const mid = Math.floor(low + high);
    if (arr[mid] === n) return true;
    if (arr[mid] > n) high = mid - 1;
    if (arr[mid] < n) low = mid + 1;
  }

  return false;
};

const cache = new WeakMap();

function has4(arr: number[], sum: number) {
    if (cache.has(arr)) return cache.get(arr).has(n);

    const lookup = new Set(arr);

    cache.set(arr, lookup);

    return lookup.has(n);
}

arr.reduce((out, val) => {
  return { ...out, [val]: true };
}, {});

// 1, 1, 2, 3, 5, 8, 13, ...

function fib(n) {
    if (n === 1) return 1;
    if (n === 2) return 1;

    return fib(n - 1) + fib(n - 2)
}

// 1, 1, 2, 3, 5, 8, 13, ...

function fibHelper(n) {
    if (n === 1) return 1;
    if (n === 2) return 1;

    return fib(n - 1) + fib(n - 2)
}

const fib = (() => {
    const cache = new Map();
    
    return (n) => {
        if (cache.has(n)) return cache.get(n);
        const a = fibHelper(n - 1);
        const b = fibHelper(n - 2);
        const result = a + b;

        cache.set(n, result);
        return result;  
    };
})();

/**
 * memoize function using weakmap
 */
export function weakMemoize<K extends object, V>(fn: (key: K) => V) {
  const cache = new WeakMap<K, V>();
  return (key: K) => {
    const cached = cache.get(key);
    if (cached) {
      return cached;
    }

    const value = fn(key);
    cache.set(key, value);
    return value;
  };
}



declare function expensive(arr: Task[]): number;

const faster = weakMemoize(expensive);

faster(arr); // -> number;

class Task extends React.Component {
  
  shouldComponentUpdate(newProps) {
      for (const key in newProps) {
          if (newProps[key] !== this.props[key]) {
              return true;
          }
      }
      return false;
  }

  render() {
    return (
        <div>
          ...huge amount of stuff
        </div>
    );
  }
}

class Task extends React.PureComponent {
  
  /*
  shouldComponentUpdate(newProps) {
      for (const key in newProps) {
          if (newProps[key] !== this.props[key]) {
              return true;
          }
      }
      return false;
  }
  */

  render() {
    return (
        <div>
          ...huge amount of stuff
        </div>
    );
  }
}

class Grid extends React.Component {
    render() {
        const { resource, children, ids, data, currentSort } = this.props;
        return (
            <table>
                <thead>
                    <tr>
                        {React.Children.map(children, (field, index) => (
                            <DatagridHeaderCell 
                                key={index} 
                                field={field} 
                                currentSort={currentSort} 
                                updateSort={this.updateSort}
                            />
                        ))}
                    </tr>
                </thead>
                <tbody>
                    {ids.map(id => (
                        <tr key={id}>
                            {React.Children.map(children, (field, index) => (
                                <DatagridCell 
                                    record={data[id]} 
                                    key={`${id}-${index}`} 
                                    field={field} 
                                    resource={resource} />
                            ))}
                        </tr>
                    ))}
                </tbody>
            </table>
        );
    }
}

class Grid extends React.Component {
    render() {
        const { resource, children, ids, data, currentSort } = this.props;
        return (
            <table>
                <DataGridHead
                  currentSort={currentSort}
                  updateSort={this.updateSort}>
                    {children}
                </DataGridHead>
                <DataGridBody 
                  ids={ids} 
                  resource={resource} 
                  data={data}>
                    {children}
                </DataGridBody>
            </table>
        );
    }
}

class DataGridBody extends React.PureComponent {
    render() {
        const { ids, resource, data, children } = this.props;
        return (
            <tbody>
                {ids.map(id => (
                    <tr key={id}>
                        {React.Children.map(children, (field, index) => (
                            <DatagridCell 
                                record={data[id]} 
                                key={`${id}-${index}`} 
                                field={field} 
                                resource={resource} />
                        ))}
                    </tr>
                ))}
            </tbody>
        );
    }
}

class DataGridHeader extends React.PureComponent {
    render() {
        const { currentSort, updateSort, children } = this.props;
        return (
            <thead>
                <tr>
                    {React.Children.map(children, (field, index) => (
                        <DatagridHeaderCell 
                            key={index} 
                            field={field} 
                            currentSort={currentSort} 
                            updateSort={updateSort}
                        />
                    ))}
                </tr>
            </thead>
        );
    }
}