leihuang23

const SHA256 = require("crypto-js/sha256");

class Block {
  constructor(index, timestamp, data, previousHash = '') {
    this.index = index;
    this.previousHash = previousHash;
    this.timestamp = timestamp;
    this.data = data;
    this.hash = this.calculateHash();
    this.nonce = 0;

leihuang23

Keybase proof

I hereby claim:

• I am leihuang69 on github.
• I am leihuang (https://keybase.io/leihuang) on keybase.
• I have a public key ASB49qM0zVuaF9wYzIldvoD5s8gYJQItrYY1fJrTNeKpOwo

To claim this, I am signing this object:

leihuang23

Setting up Babel and nodemon

Inital set-up

Set up project:

mkdir project
cd project
npm init -y

leihuang23

#Oh My Zsh - Git Cheat Sheet

g – git

gst – git status

gl – git pull

gup – git pull --rebase

leihuang23

function IO(effectFn) {
  const __val = effectFn;
  const map = fn => IO(() => fn(__val()));
  const performUnsafeIO = () => __val();
  const chain = fn => IO(() => fn(__val()).performUnsafeIO());
  return Object.freeze({
    map,
    chain,
    performUnsafeIO
  });

leihuang23

/**
 * This short program will encrypt the user password
 * and insert a new record into a mock database.
 */
const Reader = require('fantasy-readers');
const Future = require('fluture');
const R = require('ramda');
const crypto = require('crypto');

// our mock database

leihuang23

import is from './is-util';

/**
 * Either Monad class (from Functional Programming in JavaScript)
 */
class Either {
  constructor(value) {
    this._value = value;
  }
  get value () {

leihuang23

const composeK = (...fns) =>
  fns.reduce((f, g) => (...args) => g(...args).chain(f));

const liftA2 = (f, m1, m2) => m1.map(f).ap(m2);

const K = a => b => a;

const State = computation => {
  const map = f =>
    State(state => {

leihuang23

/*
 * Easing Functions - inspired from http://gizma.com/easing/
 * only considering the t value for the range [0, 1] => [0, 1]
 */
EasingFunctions = {
  // no easing, no acceleration
  linear: function (t) { return t },
  // accelerating from zero velocity
  easeInQuad: function (t) { return t*t },
  // decelerating to zero velocity

leihuang23

const curry = fn => (...args) =>
  args.length >= fn.length ? fn(...args) : curry(fn.bind(undefined, ...args))

const always = a => b => a

const compose = (...fns) => args => fns.reduceRight((x, f) => f(x), args)

const getFunctor = x =>
  Object.freeze({
    value: x,