Fly my pretties

Aviary.swift

// Playground - noun: a place where people can play
// I wouldn't want a pair of birds that were... too demonstrative.


func idiot<A>(a : A) -> A {
	return a
}

func kestrel<A, B>(a : A) -> B -> A {
	return { _ in a }
}

func starling<A, B, C>(f : (A -> B -> C)) -> (A -> B) -> A -> C {
	return { g in { x in f(x)(g(x)) } }
}

func bluebird<A, B, C>(f : (B -> C)) -> (A -> B) -> A -> C {
	return { g in { x in f(g(x)) } }
}

func cardinal<A, B, C>(f : (A -> B -> C)) -> B -> A -> C {
	return { y in { x in f(x)(y) } }
}

func psi<A, B, C>(f : (B -> B -> C)) -> (A -> B) -> A -> A -> C {
	return { g in { x in { y in f(g(x))(g(y)) } } }
}

func becard<A, B, C, D>(f : (C -> D)) -> (B -> C) -> (A -> B) -> A -> D {
	return { g in { h in { x in f(g(h(x))) } } }
}

func blackbird<A, B, C, D>(f : (C -> D)) ->  (A -> B -> C) -> A -> B -> D {
	return { g in { x in { y in f(g(x)(y)) } } }
}

func bluebirdprime<A, B, C, D>(f : (A -> C -> D)) -> A -> (B -> C) -> B -> D {
	return { x in { g in { y in f(x)(g(y)) } } }
}

func bunting<A, B, C, D, E>(f : (D -> E)) -> (A -> B -> C -> D) -> A -> B -> C -> E {
	return { g in { x in { y in { z in f(g(x)(y)(z)) } } } }
}

func cardinalprime<A, B, C, D>(f : (C -> A -> D)) -> (B -> C) -> A -> B -> D {
	return { g in { x in { y in f(g(y))(x) } } }
}

func cardinalstar<A, B, C, D>(f : (A -> C -> B -> D)) -> A -> B -> C -> D {
	return { x in { y in { z in f(x)(z)(y) } } }
}

func cardinalstarstar<A, B, C, D, E>(f : (A -> B -> D -> C -> E)) -> A -> B -> C -> D -> E {
	return { w in { x in { y in { z in f(w)(x)(z)(y) } } } }
}

func dickcissel<A, B, C, D, E>(f : (A -> B -> D -> E)) -> A -> B -> (C -> D) -> C -> E {
	return { x in { y in { g in { z in f(x)(y)(g(z)) } } } }
}

func dove<A, B, C, D>(f : (A -> C -> D)) -> A -> (B -> C) -> B -> D {
	return { x in { g in { y in f(x)(g(y)) } } }
}

func dovekie<A, B, C, D, E>(f : (C -> D -> E)) -> (A -> C) -> A -> (B -> D) -> B -> E {
	return { g in { x in { h in { z in f(g(x))(h(z)) } } } }
}

func eagle<A, B, C, D, E>(f : (A -> D -> E)) -> A -> (B -> C -> D) -> B -> C -> E {
	return { x in { g in { y in  return { z in f(x)(g(y)(z)) } } } }
}

func eaglebald<A, B, C, D, E, F, G>(f : (E -> F -> G)) -> (A -> B -> E) -> A -> B -> (C -> D -> F) -> C -> D -> G {
	return { g in { s in { t in { h in { u in { v in f(g(s)(t))(h(u)(v)) } } } } } }
}

func finch<A, B, C>(x : A) -> B -> (B -> A -> C) -> C {
	return { y in { f in f(y)(x) } }
}

func finchstar<A, B, C, D>(f : (C -> B -> A -> D)) -> A -> B -> C -> D {
	return { x in { y in { z in f(z)(y)(x) } } }
}

func finchstarstar<A, B, C, D, E>(f : (A -> D -> C -> B -> E)) -> A -> B -> C -> D -> E {
	return { s in { t in { u in { v in f(s)(v)(u)(t) } } } }
}

func goldfinch<A, B, C, D>(f : (B -> C -> D)) -> (A -> C) -> A -> B -> D {
	return { g in { x in { y in f(y)(g(x)) } } }
}

func hummingbird<A, B, C>(f : (A -> B -> A -> C)) -> A -> B -> C {
	return { x in { y in f(x)(y)(x) } }
}

func idstar<A, B>(f : (A -> B)) -> A -> B {
	return { x in f(x) }
}

func idstarstar<A, B, C>(f : (A -> B -> C)) -> A -> B -> C {
	return { x in { y in f(x)(y) } }
}

func jalt<A, B, C>(f : (A -> C)) -> A -> B -> C {
	return { x in { y in f(x) } }
}

func jaltprime<A, B, C, D>(f : (A -> B -> D)) -> A -> B -> C -> D {
	return { x in { y in { z in f(x)(y) } } }
}

func jay<A, B>(f : (A -> B -> B)) -> A -> B -> A -> B {
	return { x in { y in { z in f(x)(f(z)(y)) } } }
}

func kite<A, B>(_ : A) -> B -> B {
	return { y in y }
}

func owl<A, B>(x : ((A -> B) -> A)) -> (A -> B) -> B {
	return { y in y(x(y)) }
}

func phoenix<A, B, C, D>(f : (B -> C -> D)) -> (A -> B) -> (A -> C) -> A -> D {
	return { g in { h in { x in f(g(x))(h(x)) } } }
}

func quacky<A, B, C>(x : A) -> (A -> B) -> (B -> C) -> C {
	return { f in { g in g(f(x)) } }
}

func queer<A, B, C>(f : (A -> B)) -> (B -> C) -> A -> C {
	return { g in { x in g(f(x)) } }
}

func quirky<A, B, C>(f : (A -> B)) -> A -> (B -> C) -> C {
	return { x in { g in g(f(x)) } }
}

func quixotic<A, B, C>(f : (B -> C)) -> A -> (A -> B) -> C {
	return { x in { g in f(g(x)) } }
}

func quizzical<A, B, C>(x : A) -> (B -> C) -> (A -> B) -> C {
	return { f in { g in f(g(x)) } }
}

func robin<A, B, C>(x : A) -> (B -> A -> C) -> B -> C {
	return { f in { y in f(y)(x) } }
}

func robinstar<A, B, C, D>(f : (B -> C -> A -> D)) -> A -> B -> C -> D {
	return { x in { y in { z in f(y)(z)(x) } } }
}

func robinstarstar<A, B, C, D, E>(f : (A -> C -> D -> B -> E)) -> A -> B -> C -> D -> E {
	return { s in { t in { u in { v in f(s)(u)(v)(t) } } } }
}

func starlingprime<A, B, C, D>(f : (B -> C -> D)) -> (A -> B) -> (A -> C) -> A -> D {
	return { g in { h in { x in f(g(x))(h(x)) } } }
}

func thrush<A, B>(x : A) -> (A -> B) -> B {
	return { f in f(x) }
}

func vireo<A, B, C>(x : A) -> B -> (A -> B -> C) -> C {
	return { y in { f in f(x)(y) } }
}

func vireostar<A, B, C, D>(f : (B -> A -> B -> D)) -> A -> B -> B -> D {
	return { x in { y in { z in f(y)(x)(z) } } }
}

func vireostarstar<A, B, C, E>(f : (A -> C -> B -> C -> E)) -> A -> B -> C -> C -> E {
	return { s in { t in { u in { v in f(s)(v)(t)(u) } } } }
}

func warbler<A, B>(f : (A -> A -> B)) -> A -> B {
	return { x in f(x)(x) }
}

func warbler1<A, B>(x : A) -> (A -> A -> B) -> B {
	return { f in f(x)(x) }
}

func warblerstar<A, B, C, D, E>(f : (A -> B -> B -> C)) -> A -> B -> C {
	return { x in { y in f(x)(y)(y) } }
}

func warblerstarstar<A, B, C, D>(f : (A -> B -> C -> C -> D)) -> A -> B -> C -> D {
	return { x in { y in { z in f(x)(y)(z)(z) } } }
}

Interdefined.swift

func idiot<A>(a : A) -> A {
	return starling(kestrel)(kestrel(a))(a)
}

func kestrel<A, B>(a : A) -> B -> A {
	return { _ in return a }
}

func starling<A, B, C>(f : (A -> B -> C)) -> (A -> B) -> A -> C {
	return { g in return { x in return f(x)(g(x)) } }
}

func bluebird<A, B, C>(f : (B -> C)) -> (A -> B) -> A -> C {
	return starling(kestrel(starling))(kestrel)(f)
}

func cardinal<A, B, C>(f : (A -> B -> C)) -> B -> A -> C {
	return starling(bluebird(bluebird)(starling))(kestrel(kestrel))(f)
}

func idiotstar<A, B>(f: A -> B) -> A -> B {
	return cardinal(bluebird(bluebird)(idiot))(idiot)(f)
}

func psi<A, B, C>(f : (B -> B -> C)) -> (A -> B) -> A -> A -> C {
	return cardinal(bluebird(starling)(bluebird(cardinalstar)(dovekie)))(idiotstar)(f)
}

func becard<A, B, C, D>(f : (C -> D)) -> (B -> C) -> (A -> B) -> A -> D {
	return bluebird(bluebird(bluebird))(bluebird)(f)
}

func blackbird<A, B, C, D>(f : (C -> D)) ->  (A -> B -> C) -> A -> B -> D {
	return bluebird(bluebird)(bluebird)(f)
}

func bluebirdprime<A, B, C, D>(f : (A -> C -> D)) -> A -> (B -> C) -> B -> D {
	return bluebird(bluebird)(f)
}

func bunting<A, B, C, D, E>(f : (D -> E)) -> (A -> B -> C -> D) -> A -> B -> C -> E {
	return bluebird(bluebird(bluebird)(bluebird))(bluebird)(f)
}

func cardinalprime<A, B, C, D>(f : (C -> A -> D)) -> (B -> C) -> A -> B -> D {
	return bluebird(bluebird(cardinal))(bluebird)(f)
}

func cardinalstar<A, B, C, D>(f : (A -> C -> B -> D)) -> A -> B -> C -> D {
	return bluebird(cardinal)(f)
}

func cardinalstarstar<A, B, C, D, E>(f : (A -> B -> D -> C -> E)) -> A -> B -> C -> D -> E {
	return bluebird(cardinalstar)(f)
}

func dickcissel<A, B, C, D, E>(f : (A -> B -> D -> E)) -> A -> B -> (C -> D) -> C -> E {
	return bluebird(bluebird(bluebird))(f)
}

func dove<A, B, C, D>(f : (A -> C -> D)) -> A -> (B -> C) -> B -> D {
	return bluebird(bluebird)(f)
}

func dovekie<A, B, C, D, E>(f : (C -> D -> E)) -> (A -> C) -> A -> (B -> D) -> B -> E {
	return bluebird(bluebird)(bluebird(bluebird))(f)
}

func eagle<A, B, C, D, E>(f : (A -> D -> E)) -> A -> (B -> C -> D) -> B -> C -> E {
	return bluebird(bluebird(bluebird)(bluebird))(f)
}

func eaglebald<A, B, C, D, E, F, G>(f : (E -> F -> G)) -> (A -> B -> E) -> A -> B -> (C -> D -> F) -> C -> D -> G {
	return bluebird(bluebird(bluebird)(bluebird))(bluebird(bluebird(bluebird)(bluebird)))(f)
}

func finch<A, B, C>(x : A) -> B -> (B -> A -> C) -> C {
	return eagle(thrush)(thrush)(eagle)(thrush)(x)
}

func finchstar<A, B, C, D>(f : (C -> B -> A -> D)) -> A -> B -> C -> D {
	return bluebird(cardinalstar)(robinstar)(f)
}

func finchstarstar<A, B, C, D, E>(f : (A -> D -> C -> B -> E)) -> A -> B -> C -> D -> E {
	return bluebird(finchstar)(f)
}

func goldfinch<A, B, C, D, E>(f : (B -> C -> D)) -> (A -> C) -> A -> B -> D {
	return bluebird(bluebird)(cardinal)(f)
}

func hummingbird<A, B, C>(f : (A -> B -> A -> C)) -> A -> B -> C {
	return bluebird(warbler)(bluebird(cardinal))(f)
}

func idstar<A, B>(f : (A -> B)) -> A -> B {
	return cardinal(bluebird(bluebird)(idiot))(idiot)(f)
}

func idstarstar<A, B, C, D, E>(f : (A -> B -> C)) -> A -> B -> C {
	return bluebird(idstar)(f)
}

func jalt<A, B, C, D, E>(f : (A -> C)) -> A -> B -> C {
	return bluebird(kestrel)(f)
}

func jaltprime<A, B, C, D, E>(f : (A -> B -> D)) -> A -> B -> C -> D {
	return bluebird(bluebird(kestrel))(f)
}

func jay<A, B>(f : (A -> B -> B)) -> A -> B -> A -> B {
	return bluebird(bluebird(cardinal))(warbler(bluebird(cardinal)(bluebird(bluebird(bluebird)(bluebird)))))(f)
}

func kite<A, B, C, D, E>(x : A) -> B -> B {
	return kestrel(idiot)(x)
}

func owl<A, B, C, D, E>(x : ((A -> B) -> A)) -> (A -> B) -> B {
	return starling(idiot)(x)
}

func phoenix<A, B, C, D, E>(f : (B -> C -> D)) -> (A -> B) -> (A -> C) -> A -> D {
	return bluebird(bluebird(starling))(bluebird)(f)
}

func quacky<A, B, C, D, E>(x : A) -> (A -> B) -> (B -> C) -> C {
	return finchstar(bluebird)(x)
}

func queer<A, B, C, D, E>(f : (A -> B)) -> (B -> C) -> A -> C {
	return cardinal(bluebird)(f)
}

func quirky<A, B, C>(f : (A -> B)) -> A -> (B -> C) -> C {
	return bluebird(thrush)(f)
}

func quixotic<A, B, C, D, E>(f : (B -> C)) -> A -> (A -> B) -> C {
	return bluebird(cardinal)(bluebird)(f)
}

func quizzical<A, B, C, D, E>(x : A) -> (B -> C) -> (A -> B) -> C {
	return cardinal(bluebird(cardinal)(bluebird))(x)
}

func robin<A, B, C>(x : A) -> (B -> A -> C) -> B -> C {
	return bluebird(bluebird)(thrush)(x)
}

func robinstar<A, B, C, D>(f : (B -> C -> A -> D)) -> A -> B -> C -> D {
	return cardinalstar(cardinalstar)(f)
}

func robinstarstar<A, B, C, D, E>(f : (A -> C -> D -> B -> E)) -> A -> B -> C -> D -> E {
	return bluebird(robinstar)(f)
}

func starlingprime<A, B, C, D, E>(f : (B -> C -> D)) -> (A -> B) -> (A -> C) -> A -> D {
	return bluebird(bluebird(starling))(bluebird)(f)
}

func thrush<A, B>(x : A) -> (A -> B) -> B {
	return cardinal(idiot)(x)
}

func vireo<A, B>(x : A) -> B -> (A -> B -> B) -> B {
	return bluebird(cardinal)(thrush)(x)
}

func vireostar<A, B, D>(f : (B -> A -> B -> D)) -> A -> B -> B -> D {
	return cardinalstar(finchstar)(f)
}

func vireostarstar<A, B, C, D, E>(f : (A -> C -> B -> C -> E)) -> A -> B -> C -> C -> E {
	return bluebird(vireostar)(f)
}

func warbler<A, B>(f : (A -> A -> B)) -> A -> B {
	return cardinal(starling)(idiot)(f)
}

func warbler1<A, B>(x : A) -> (A -> A -> B) -> B {
	return cardinal(warbler)(x)
}

func warblerstar<A, B, C>(f : (A -> B -> B -> C)) -> A -> B -> C {
	return bluebird(warbler)(f)
}

func warblerstarstar<A, B, C, D>(f : (A -> B -> C -> C -> D)) -> A -> B -> C -> D {
	return bluebird(warblerstar)(f)
}

/// MARK: Control.Category

infix operator ° {}
infix operator <<< {}
infix operator >>> {}

infix operator >>= {}
infix operator >> {}

infix operator <**> {}

public func °<A, B, C>(f : (B -> C), g: (A -> B)) -> (A -> C) {
	return bluebird(f)(g)
}

public func <<<<A, B, C>(f : (B -> C), g : (A -> B)) -> (A -> C) {
	return bluebird(f)(g)
}

public func >>><A, B, C>(f : (A -> B), g : (B -> C)) -> (A -> C) {
	return Independent.queer(f)(g)
}

/// MARK: Control.Applicative


infix operator <^> {}
infix operator <^ {}

infix operator <*> {
	precedence 4
	associativity left
}

infix operator <* {
	precedence 4
	associativity left
}
infix operator *>{
	precedence 4
	associativity left
}

public func <^><A, B, C>(f : A -> B, g: (C -> A)) -> (C -> B) {
	return bluebird(f)(g)
}

public func <^<A, B, C>(x : A, g: (C -> B)) -> (C -> A) {
	return (bluebird ° kestrel)(x)(g)
}

public func pure<A, B>(x : A) -> (B -> A) {
	return kestrel(x)
}

public func <*><A, B, C>(f : (C -> A -> B), g : (C -> A)) -> (C -> B) {
	return starling(f)(g)
}


public func *><A, B, C>(f : (C -> A), g : (C -> B)) -> (C -> B) {
	return liftA2(kestrel(idiot))(f)(g)
}

public func <*<A, B, C>(f : (C -> A), g : (C -> B)) -> (C -> A) {
	return liftA2(kestrel)(f)(g)
}

public func <**><A, B, C>(f : (C -> A), g : (C -> A -> B)) -> (C -> B) {
	return liftA2(cardinal(idiotstar))(f)(g)
}

public func liftA<A, B, C>(f : (A -> B))(g : (C -> A)) -> (C -> B) {
	return bluebird(f)(g)
}

public func liftA2<A, B, C, D>(f : (A -> B -> C))(a : (D -> A))(b: (D -> B)) -> (D -> C) {
	return f <^> a <*> b
}

public func liftA3<A, B, C, D, E>(f : (A -> B -> C -> D))(a : (E -> A))(b : (E -> B))(c : (E -> C)) -> (E -> D) {
	return f <^> a <*> b <*> c
}

/// MARK: Control.Monad

public func >>=<A, B, C>(f : (C -> A), k : (A -> C -> B)) -> (C -> B) {
	return { (let r) in
		return k(f(r))(r)
	}
}

public func >><A, B, C>(f : (C -> A), g : (C -> B)) -> (C -> B) {
	return f >>= { (let _) in
		return g
	}
}

//public func mapM<A, B, C>(f : (A -> C -> B))(l : [A])(x : C) -> [B] {
//
//}
//
//public func mapM_<A, B, C>(f : (A -> C -> B))(l : [A])(x : C) -> () {
//
//}
//
//public func forM<A, B, C>(l : [A])(f : (A -> C -> B))(x : C) -> [B] {
//	return cardinal(mapM)(l)(f)(x:x)
//}
//
//public func forM_<A, B, C>(l : [A])(f : (A -> C -> B))(x : C) -> () {
//	return cardinal(mapM_)(l)(f)(x:x)
//}
//
//public func sequence<A, B>(l : [B -> A])(x : B) -> [A] {
//
//}
//
//public func sequence_<A, B>(l : [B -> A])(x : B) -> () {
//
//}