leolanese

const pipe = (...functions) => args => functions.reduce((arg, fn) => fn(arg), args);

// const league = [
//   { heroe: "superman", power: 'fly' },
//   { heroe: "batman", power: 'millionare'},
//   { heroe: "flash", power: 'speed' },
// ]
// const filter = f => arr => arr.filter(f);
// const map = m => arr => arr.map(m);

leolanese

const compose = (...functions) => args => functions.reduceRight((arg, fn) => fn(arg), args);

// Example:
// const league = [
//  { heroe: "superman", power: 'fly' },
//  { heroe: "batman", power: 'millionare'},
//  { heroe: "flash", power: 'speed' },
//]
//const filter = f => arr => arr.filter(f);
//const map = m => arr => arr.map(m);

leolanese

/**
 * Debounce a method
 */
function debounce(ms) {
  return function(target: any, key: any, descriptor: any) {
    const oldFunc = descriptor.value
    const newFunc = _debounce(oldFunc,ms)
    descriptor.value = function() {
        return newFunc.apply(this,arguments)

leolanese

// declaring fetch + async-await + TypeScript
export async function get<T>(
  path: string,
  args: RequestInit = { method: "get" }
): Promise<HttpResponse<T>> {
  return await http<T>(new Request(path, args));
};

export async function post<T>(
  path: string,

leolanese

const debounce = (fn, time) => {
    let timerId;
    return function(...args) {
        const functionCall = () => fn.apply(this, args);
        clearTimeout(timerId);
        timerId = setTimeout(functionCall, time);
    };
};

leolanese

function startCountingForHideAndSeek() {
	// State for managing cleanup and cancelling
	let finished = false;
	let cancel = () => finished = true;

	const promise = new Promise((resolve, reject) => {
		//
		// Custom Promise Logic
		//
		// NOTE: This countdown not finish in exactly 10 seconds, don't build timers this way!

leolanese

'use strict';

function swap(arr, ind1, ind2) {
  let temp = arr[ind1];
  arr[ind1] = arr[ind2];
  arr[ind2] = temp;
}

function quickSortInPlace(arr, left, right) {
  left = left || 0;

leolanese

## DFS & BFS:
DFS =  storing the vertices "stacks", stacks are LIFO (push, pop).
BFS = storing the vertices "queue", queues are FIFO (shift, unshift or enqueue and dequeue).

## Why to use BFS and DFS?
#### DFS = memory requirements than BFS. It will take a lot of memory to traverse deeper trees while it works well with wider trees.
commonly used when you need to search the entire tree.
#### BFS = is better for deeper trees since it will take a lot more memory to operate on wider trees.

## When to use BFS and DFS?

leolanese

npx create-react-app my-app
cd my-app
yarn add node-sass -S
// Change .css files to .scss
// Change any imports to use .scss
yarn start

leolanese

function delayPromise(delay, value) {
    console.time();
    // using built-in Promise constructor-function/class.
    return new Promise(function(resolve) {
       setTimeout(function() {
            console.timeEnd();
            resolve(value);
        }, delay);
    });
}