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

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,

leihuang23

function toList(next, reversed) {
  const arr = [];
  let value = next();
  while (value !== undefined) {
    if (reversed) {
      arr.unshift(value);
      value = next();
    } else {
      arr.push(value);
      value = next();

leihuang23

// Utility function for detecting generators.
let isGenerator = x => {
  return Function.isGenerator &&
         Function.isGenerator.call(x)
}

// Data type represents channel into which values
// can be `put`, or `received` from. Channel is
// very much like queue where reads and writes are
// synchronized via continuation passing.

leihuang23

class TrieNode {
  constructor(char) {
    this.char = char;
    this.validWord = false;
    this.parent = null;
    this.children = [];
  }
}

class Trie {