jrsonline

extension Array : Constructible {
    typealias TypeParameter = Element
}


extension LinkedList : Constructible {
    typealias TypeParameter = T
}

jrsonline

// unapplied function
// think of an 'unapplied type constructor' like this
let incrementFunction = { a in a + 1 }

jrsonline

protocol HKTTag { /* a type to represent a Higher Kinded Type tag */ }

/// `ConstructorTag` represents a type constructor.
/// `TypeParameter` represents an argument to the type constructor.
struct Construct<ConstructorTag : HKTTag, TypeParameter>  {
    let tag: ConstructorTag   
}

// The below is like Array<Int>
let intArrayConstructor = Construct<ArrayTag, Int>

jrsonline

protocol FunctorTag : HKTTag {
    typealias F = Self
    static func fmap<A,B>(_ transform: (A) -> B ) -> (Construct<F,A>) -> Construct<F,B>
//        fmap will take a "transform A's to B's"  ->  and an "F<A>"  -> and return an "F<B>"
}

jrsonline

protocol Functor : Sequence<Element> {
  func fmap<S>(_ transform:(Element) -> S) -> Self<S>
}

jrsonline

protocol Functor : Sequence {
  func fmap<S>(_ transform:(Element) -> S) -> ???
}

jrsonline

    /// lmap works fine for linked list.  Why can't Sequence define a generic one?
    func lmap<S>(_ transform:(T) -> S) -> LinkedList<S> {
        let l = LinkedList<S>()
        for a in self {
            l.addToEnd(transform(a))
        }
        return l
    }

jrsonline

print(   linkedList^.fmap { $0 % 2 == 0 }.fmap { $0 ? "yes" : "no" }.toLinkedList )
print( regularArray^.fmap { $0 % 2 == 0 }.fmap { $0 ? "yes" : "no" }.toArray )
print(         tree^.fmap { $0 % 2 == 0 }.fmap { $0 ? "yes" : "no" }.toTree )

jrsonline

var neurons = LinkedList.start(1).addToEnd(2).addToEnd(3)
var exciteNeurons = neurons.map{ $0 * 10 }.addToStart(5)   ///// :-(