dewey92

// filter :: (a → Bool) → [a] → [a]
const filter = fn => arr => arr.filter(fn)

// isEven :: Int → Bool
const isEven = num => num % 2 === 0
// oneToSix :: [Int]
const oneToSix = [1, 2, 3, 4, 5, 6]
// filterEvenNumbers :: [Int]
const filterEvenNumbers = filter(isEven)(oneToSix)
# [2, 4, 6]

dewey92

// pure :: Applicative f => a → f a
const pure = a => Functor.of(a)

// ap :: Applicative f => f (a → b) → f a → f b
const ap = (functor1, functor2) => functor1.ap(functor2)

// liftA :: Applicative f => (a → b) → f a → f b
const liftA = (fn, functor1) => functor1.map(fn)

// liftA2 :: Applicative f => (a → b → c) → f a → f b → f c

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)

dewey92

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

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

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

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

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

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

dewey92

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

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

// 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: