dewey92

interface IReader<D, A> {
  map<B>(f: (value: A) => B): IReader<D, B>,
  flatMap<B>(f: (value: A) => IReader<D, B>): IReader<D, B>,
  run(deps: D): A
}

const Reader = <D, A>(fn: (deps: D) => A): IReader<D, A> => {
  const run = (deps: D) => fn(deps);
  return {
    map: f => Reader((deps: D) => f(run(deps))),

dewey92

interface Reader<D, A> {
  (deps: D): A
}

const fmap = <D, A, B>(f: (v: A) => B, readerA: Reader<D, A>): Reader<D, B> =>
  deps => f(readerA(deps))

const bind = <D, A, B>(f: (v: A) => Reader<D, B>, readerA: Reader<D, A>): Reader<D, B> =>
  deps => f(readerA(deps))(deps)

dewey92

// reducerHelper.js
export const createAsyncReducer = (initialState, asyncAction) =>
  (state = initialState, action) => {
    switch (action.type) {
      case asyncAction.request.type:
        return {
          ...state,
          asyncState: AsyncState.loading
        }
      case asyncAction.success.type: 

dewey92

const createAction = actionName => Object.assign(
  payload => ({
    type: actionName,
    payload
  }),
  { type: actionName } // <- Inject `type` attribute to the action func
)

const createAsyncAction = actionName => ({
  request: createAction(actionName + '_REQUEST'),

dewey92

export default (state = initialState, action) => {
  switch (action.type) {
    case 'GET_USER_REQUEST':
      return {
        ...state,
        user: {
          ...state.user,
          asyncState: AsyncState.loading
        }
      }

dewey92

const AsyncState = {
  idle: 'idle',
  loading: 'loading',
  loaded: 'loaded',
  error: 'error' 
}

const initialState = {
  user: {
    data: {},

dewey92

Write some application with messy code and file structures. This messy app

is:

1. Inconsistent in naming convention
2. Baking business logic into one big function
3. Using quite a number of Imperative Programming styles
4. ...

handle:

1. Side effects (hitting API, sending email after registering, etc)

dewey92

// composeK :: Monad m => ((y → m z), (x → m y), …, (a → m b)) → (a → m z)
const composeK = (...fns) => init => {
  if (!fns.length) throw new Error('Need at least 1 argument')

  const lastArg = fns.pop();

  return fns.reduceRight((acc, x) => acc.bind(x), lastArg(init))
}

dewey92

const getHalfOfChildsAge = compose(
  safeDivisionBy(2),
  getAge,
  getChild
)

// getChild :: Person → Maybe Person
// getAge ::            Person → Maybe Number
// safeDivisionBy ::             Number → Number → Maybe Number

dewey92

// getChild :: Person → Maybe Person
const getChild = p => Maybe.of(p.child)

// getAge :: Person → Maybe Number
const getAge = p => Maybe.of(p.age)

// safeDivisionBy :: Number → Number → Maybe Number
const safeDivisionBy = bawah => atas =>
  (bawah === 0) ? Nothing() : Maybe.of(atas / bawah)