kraftdorian

type Fun<A, B> = (a: A) => B;

class Just<A> {
    constructor(private readonly _value: A) {}

    valueOf(): A {
        return this._value;
    }
}

kraftdorian

function PromiseFunctor<In, Out>(f: (input: In) => Out, value: Promise<In>): Promise<Out> {
    return value.then<Out>(
        a => f(a)
    );
}

// ==== TEST ====

const x = 1;
const p = Promise.resolve(x);

kraftdorian

function flip<A, B, C>(f: (a0: A, a1: B) => C): (b0: B, b1: A) => C {
    return (b0: B, b1: A) => {
        return f(b1, b0);
    }
}

// ==== TEST ====

const x: string = 'test';
const y: number = 1;

kraftdorian

//
// Created with help of the great contents from:
// http://learnyouahaskell.com/a-fistful-of-monads
//

// Just a helper type to define exact type of a basic function with one input and output.
type BasicFn<A, B> = (input: A) => B;

// Wrapper interface for Monad valueOf return value, to differentiate from other return types.
interface IMonadValueOf<A> {

kraftdorian

-- http://learnyouahaskell.com/modules#making-our-own-modules
module User (
  Account,
  AccountRole,
  accounts,
  isAccountRoleEqual,
  isAccountRoleSet,
  filterAccountsWithRoleSet,
  filterAccountsByRole,
  filterAccountsByAdminRole

kraftdorian

// Heavily based on this great article by Eric Elliott:
// https://medium.com/javascript-scene/javascript-monads-made-simple-7856be57bfe8

const main1 = () => {
  const compose = (f, g) => (x) => f(g(x));

  // g :: Integer -> [Integer]
  const g = (a) => Array.of(a);

  // f :: [Integer] -> Bool

kraftdorian

const PRIMITIVE_TYPES = {
  string: true,
  number: true,
  bigint: true,
  boolean: true,
  symbol: true,
  undefined: true
};

function isPrimitive(value) {

kraftdorian

const Nothing = Symbol('Nothing');
const Just = (value) => Symbol("Just " + JSON.stringify(value));

const isAssocList = (value) => {
  return Array.isArray(value) && value.length === 2;
};

const findAssocListValueByKey = (list, key) => {
  const [assocItem, ...items] = list;
  if (undefined === assocItem) {

kraftdorian

const tuple = (...atoms) => Object.freeze(
  atoms.reduce((partial, atom, index) => ({
    ...partial,
    ['_' + ++index]: atom
  }), {})
);

kraftdorian

import {case_spec, match_spec} from './lib.mjs';

const _case = (expression) => {
  return {
    of: (...predicates) => {
      return case_spec(expression, () => predicates.reduce((partial, expr) => {
        return {
          ...partial,
          [match_spec(expression, expr.matchSpec)]: expr.matchFn
        };