currying_generics.swift

// RUN: %target-run-simple-swift | FileCheck %s
// REQUIRES: executable_test

func curry<T, U, V>(f: (T, U) -> V)(_ x: T)(_ y: U) -> V {
  return f(x, y)
}

func curry<T1, T2, T3, T4>(f: (T1, T2, T3) -> T4)(_ x: T1)(_ y: T2)(_ z: T3) -> T4 {
  return f(x, y, z)
}

func concat(x: String, _ y: String, _ z: String) -> String {
  return x + y + z
}

@inline(never)
public func test_concat_closure(x: Int) -> String {
  var x = x
  let insult = curry(concat)("one ")(" two ")
  var gs = insult(" three ")
  if (x > 0) {
    gs = gs + insult(" four ")
    gs = gs + insult(" five ")
  } else {
    gs = gs + insult(" six ")
    gs = gs + insult(" seven ")
  }
  if (x > 10) {
     x += 100
  }
  return gs
}

public protocol P {
  func val() -> Int32
}

struct CP: P {
  let v: Int32

  func val() -> Int32 {
     return v
  }

  init(_ v: Int32) {
    self.v = v
  }
}

func compose(x: P, _ y: P, _ z: P) -> Int32 {
  return x.val() + y.val() + z.val()
}


@inline(never)
public func test_compose_closure(x: Int) -> Int32 {
  var x = x
  let insult = curry(compose)(CP(1))(CP(2))
  var gs = insult(CP(3))
  if (x > 0) {
    gs = gs + insult(CP(4))
    gs = gs + insult(CP(5))
  } else {
    gs = gs + insult(CP(6))
    gs = gs + insult(CP(7))
  }
  if (x > 10) {
     x += 100
  }
  return gs
}

let insult = curry(+)("I'm with stupid ☞ ")
print(insult("😡")) // CHECK: I'm with stupid ☞ 😡

let plus1 = curry(+)(1)
print(plus1(5)) // CHECK-NEXT: 6

let plus5 = curry(+)(5)
print(plus5(5)) // CHECK-NEXT: 10

print(insult("😰")) // CHECK-NEXT: I'm with stupid ☞ 😰


let concat_one_two = curry(concat)("one ")(" two ")
print(concat_one_two(" three ")) // CHECK-NEXT: one two three

print(test_concat_closure(20)) // CHECK-NEXT: one  two  three one  two  four one  two  five

print(test_compose_closure(20)) // CHECK-NEXT: 21

// rdar://problem/18988428

func clamp<T: Comparable>(minValue: T, _ maxValue: T)(n: T) -> T {
    return max(minValue, min(n, maxValue))
}

let clampFoo2 = clamp(10.0, 30.0)

print(clampFoo2(n: 3.0)) // CHECK-NEXT: 10.0

// rdar://problem/19195470

func pair<T,U> (a: T) -> U -> (T,U) {
	return { b in (a,b)	}
}

func pair_<T,U> (a: T)(b: U) -> (T,U) {
	return (a,b)
}

infix operator <+> { }
func <+><T,U,V> (lhs: T?, rhs: T -> U -> V) -> U -> V? {
	if let x = lhs {
		return { y in .Some(rhs(x)(y)) }
	} else {
		return { _ in nil }
	}
}

let a : Int? = 23
let b : Int? = 42
print((b <+> pair)(a!)) // CHECK-NEXT: (42, 23)
print((b <+> pair_)(a!)) // CHECK-NEXT: (42, 23)

//
// rdar://problem/20475584
//

struct Identity<A> { let value: A }
struct Const<A, B> { let value: A }

func fmap<A, B>(f: A -> B)(_ identity: Identity<A>) -> Identity<B> {
	return Identity(value: f(identity.value))
}

func fmap<A, B>(f: A -> B)(_ const: Const<A, B>) -> Const<A, B> {
	return const
}

// really Const()
func _Const<A, B>(a: A) -> Const<A, B> {
	return Const(value: a)
}
func const<A, B>(a: A)(_: B) -> A {
	return a
}

// really Identity()
func _Identity<A>(a: A) -> Identity<A> {
	return Identity(value: a)
}

func getConst<A, B>(c: Const<A, B>) -> A {
	return c.value
}

func runIdentity<A>(i: Identity<A>) -> A {
	return i.value
}


func view<S, A>(lens: (A -> Const<A, S>) -> S -> ((A -> S) -> Const<A, S> -> Const<A, S>) -> Const<A, S>)(_ s: S) -> A {
	return getConst(lens(_Const)(s)(fmap))
}

func over<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>)(_ f: A -> A)(_ s: S) -> S {
	return runIdentity(lens({ _Identity(f($0)) })(s)(fmap))
}

func set<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>)(_ x: A)(_ y: S) -> S {
	return over(lens)(const(x))(y)
}

func _1<A, B, C, D>(f: A -> C)(_ x: A, _ y: B)(_ fmap: (A -> (A, B)) -> C -> D) -> D {
	return fmap({ ($0, y) })(f(x))
}

func _2<A, B, C, D>(f: B -> C)(_ x: A, _ y: B)(_ fmap: (B -> (A, B)) -> C -> D) -> D {
	return fmap({ (x, $0) })(f(y))
}


public func >>> <T, U, V> (f: T -> U, g: U -> V) -> T -> V {
	return { g(f($0)) }
}

public func <<< <T, U, V> (f: U -> V, g: T -> U) -> T -> V {
	return { f(g($0)) }
}


infix operator >>> {
	associativity right
	precedence 170
}
infix operator <<< {
	associativity right
	precedence 170
}

let pt1 = view(_1)((1, 2))
print(pt1) // CHECK-NEXT: 1
let pt2 = over(_1)({ $0 * 4 })((1, 2))
print(pt2) // CHECK-NEXT: (4, 2)
let pt3 = set(_1)(3)((1, 2))
print(pt3) // CHECK-NEXT: (3, 2)
let pt4 = view(_2)("hello", 5)
print(pt4) // CHECK-NEXT: 5