// See: https://devforums.apple.com/message/1000934#1000934

import Foundation

// Logic

operator prefix ¬ {}
@prefix func ¬ (value: Bool) -> Bool {
    return !value
}

operator infix ∧ { associativity left precedence 120 }
func ∧ (left: Bool, right: Bool) -> Bool {
    return left && right
}

operator infix ∨ { associativity left precedence 110 }
func ∨ (left: Bool, right: Bool) -> Bool {
    return left || right
}

operator infix ⊻ { associativity left precedence 140 }
func ⊻ (left: Bool, right: Bool) -> Bool {
    return left ^ right
}

operator infix ⊼ { associativity left precedence 120 }
func ⊼ (left: Bool, right: Bool) -> Bool {
    return ¬(left ∧ right)
}

operator infix ⊽ { associativity left precedence 110 }
func ⊽ (left: Bool, right: Bool) -> Bool {
    return ¬(left ∨ right)
}

operator prefix ⊦ {}
@prefix func ⊦ (condition: @auto_closure () -> Bool) {
    assert(condition, "Assertion Failed")
}

// Math

operator infix × { associativity left precedence 150 }
func × (left: Double, right: Double) -> Double {
    return left * right
}

operator infix ÷ { associativity left precedence 150 }
func ÷ (left: Double, right: Double) -> Double {
    return left / right
}

operator infix ∕ { associativity left precedence 150 }
func ∕ (left: Double, right: Double) -> Double {
    return left / right
}

operator prefix √ {}
@prefix func √ (number: Double) -> Double {
    return sqrt(number)
}

operator prefix ∛ {}
@prefix func ∛ (number: Double) -> Double {
    return cbrt(number)
}

operator infix ± { associativity left precedence 140 }
func ± (left: Double, right: Double) -> (Double, Double) {
    return (left + right, left - right)
}

operator prefix ± {}
@prefix func ± (value: Double) -> (Double, Double) {
    return 0 ± value
}

operator infix ∓ { associativity left precedence 140 }
func ∓ (left: Double, right: Double) -> (Double, Double) {
    return (left - right, left + right)
}

operator prefix ∓ {}
@prefix func ∓ (value: Double) -> (Double, Double) {
    return 0 ∓ value
}

operator infix ∣ { associativity left precedence 150 }
func ∣ (left: Int, right: Int) -> Bool {
    return left % right == 0
}

operator infix ∤ { associativity left }
func ∤ (left: Int, right: Int) -> Bool {
    return ¬(left ∣ right)
}

// Sets

operator infix ∈ { associativity left }
func ∈<T: Equatable> (left: T, right: Array<T>) -> Bool {
    let filtered = right.filter {$0 == left}
    return filtered.count > 0
}

operator infix ∉ { associativity left }
func ∉<T: Equatable> (left: T, right: Array<T>) -> Bool {
    return ¬(left ∈ right)
}

operator infix ∋ { associativity left }
func ∈<T: Equatable> (left: Array<T>, right: T) -> Bool {
    return right ∈ left
}

operator infix ∌ { associativity left }
func ∌<T: Equatable> (left: Array<T>, right: T) -> Bool {
    return right ∉ left
}

operator infix ∩ { associativity left }
func ∩<T: Equatable> (left: Array<T>, right: Array<T>) -> Array<T> {

    var intersection: Array<T> = []
    for value in left {
        if value ∈ right {
            intersection.append(value)
        }
    }

    return intersection
}

operator infix ∪ { associativity left }
func ∪<T: Equatable> (left: Array<T>, right: Array<T>) -> Array<T> {

    var union: Array<T> = left
    for value in right {
        if ¬(value ∈ left) {
            union.append(value)
        }
    }

    return union
}

operator infix ⊂ { associativity left }
func ⊂<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    for value in left {
        if ¬(value ∈ right) {
            return false
        }
    }

    return true
}

operator infix ⊆ { associativity left }
func ⊆<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return left == right || (left ⊂ right)
}

operator infix ⊊ { associativity left }
func ⊊<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return left ⊂ right
}

operator infix ⊄ { associativity left }
func ⊄<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return ¬(left ⊂ right)
}

operator infix ⊃ { associativity left }
func ⊃<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return right ⊂ left
}

operator infix ⊇ { associativity left }
func ⊇<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return right ⊆ left
}

operator infix ⊋ { associativity left }
func ⊋<T: Equatable> (left: Array<T>, right: Array<T>) -> Bool {
    return left ⊃ right
}

// Sequences

operator prefix ∑ {}
@prefix func ∑ (values: Array<Double>) -> Double {
    return reduce(values, 0.0, +)
}

operator prefix ∏ {}
@prefix func ∏ (values: Array<Double>) -> Double {
    return reduce(values, 1.0, *)
}

operator infix ⋅ {}
func ⋅ (left: Array<Double>, right: Array<Double>) -> Double? {
    if left.count != right.count {
        return nil
    }

    var product: Array<Double> = []
    for (index, _) in enumerate(left) {
        let (a, b) = (left[index], right[index])
        product.append(a * b)
    }

    return ∑product
}

// Comparison

operator infix ⩵ { associativity left }
func ⩵<T: Equatable> (left: T, right: T) -> Bool {
    return left == right
}

//operator infix ≤ { associativity left }
//func ≤<T: Equatable> (left: T, right: T) -> Bool {
//    return left < right || left == right
//}

//operator infix ≥ { associativity left }
//func ≥<T: Equatable> (left: T, right: T) -> Bool {
//    return left > right || left == right
//}

//operator infix ≬ { associativity left }
//func ≬<T: Equatable> (left: T, right: (T, T)) -> Bool {
//    return left > right.0 && left < right.1
//}