rjchatfield

#-- CONTENT
$ ->
  ___ ''

  ___ ' ███████╗██╗   ██╗███╗   ██╗ ██████╗████████╗██╗ ██████╗ ███╗   ██╗ █████╗ ██╗'
  ___ ' ██╔════╝██║   ██║████╗  ██║██╔════╝╚══██╔══╝██║██╔═══██╗████╗  ██║██╔══██╗██║'
  ___ ' █████╗  ██║   ██║██╔██╗ ██║██║        ██║   ██║██║   ██║██╔██╗ ██║███████║██║'
  ___ ' ██╔══╝  ██║   ██║██║╚██╗██║██║        ██║   ██║██║   ██║██║╚██╗██║██╔══██║██║'
  ___ ' ██║     ╚██████╔╝██║ ╚████║╚██████╗   ██║   ██║╚██████╔╝██║ ╚████║██║  ██║███████╗'
  ___ ' ╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝'

rjchatfield

#
# FP solve the Change Problem
#  eg. myChange = calcChange(cost, myPayment)
#

# Used in fold() to build change object
#  Should be nested in calcChange, but is lifted for cleanliness
coinAccStructure = (acc, coin) ->
  change         = acc["payment"]
  acc[coin]      = change % coin

rjchatfield

# functional waterfall method
waterfall = (scope) -> deploy(test(develop(design(analyse(scope)))))
# or
waterfall = (scope) -> compose(deploy, test, develop, design, analyse)(scope)
# or
waterfall = (scope) -> scope.analyse().design().develop().test().deploy()

rjchatfield

/*
==============================================================
Clean error handling network calls using high order functions.

ES6 version of:
  http://blog.carbonfive.com/2015/01/05/tidying-up-a-
  javascript-application-with-higher-order-functions/
==============================================================
*/

rjchatfield

let unwrapMe: [[Int]] = []

// IF LET
func unwrapWithIfLet (arrArr: [[Int]]) -> Int? {
    if let x = arrArr.first?.first {
        return x + 1
    }
    return nil
}

rjchatfield

typealias PlusMinusable = protocol<IntegerArithmeticType, ForwardIndexType>

infix operator ± {}

struct PlusMinus<T: PlusMinusable> {
    let value: T
    let variance: T
    var range: Range<T> {
        let lower = value - variance
        let upper = value + variance

rjchatfield

// Line 109 is where the magic is!

import Foundation
import XCPlayground

func setInterval(seconds interval: Int, f: ()->()) {
    let delta = Int64(1) * Int64(NSEC_PER_SEC)
    let time = dispatch_time(DISPATCH_TIME_NOW, delta)

    dispatch_after(time, dispatch_get_main_queue(), {

rjchatfield

typealias VoidFuncType = () -> Void
typealias BoolFuncType = () -> Bool

/**
 IF/ELSE STATEMENT
 */
typealias ElseIfType = (Bool, VoidFuncType) -> IfElse
typealias ElseType = (VoidFuncType) -> Void

struct IfElse {

rjchatfield

Types are coming

Last week I had a crash course in PureScript - a Haskell-like language that compiles to JavaScript. I’m not about to preach that you should write your web apps in Haskell (though I strongly recommend learning Haskell), however, I do wish to explore an important part of any Functional Programming language that has eluded Javascript...

Types.

There is a lot to be said about Javascript and its lack of static typing. We’ve built the whole web with it! But this post will explore the benefits of a compile-time strong static type system.

“But Javascript does have types!?”

rjchatfield

// LINKED LIST

/**
*  NODE
*/
private class Node<T:protocol<Printable, Comparable>>: Printable, Comparable {
    /**
    *  PROPERTIES
    */
    var info:T