//给一个数组,要求用swift写一个函数,交换数组中的两个元素。
    var nums = [1,2,3,4,5,6,7]
    //        func swap(_ nums: inout [Int], _ a : Int, _ b : Int) {
    //            let temp = nums[a]
    //            nums[a] = nums[b]
    //            nums[b] = temp
    //        }
    
    //2.泛型
    //        func swap<T>(_ nums: inout [T], _ a : Int, _ b : Int) {
    //            let temp = nums[a]
    //            nums[a] = nums[b]
    //            nums[b] = temp
    //        }
    //
    func swap<T>(_ nums: inout [T], _ a : Int, _ b : Int) {
        let count = nums.count
        //安全判断
        if a == b || a < 0 || a > count - 1 || b < 0 || b > count - 1   {
            return
        }
        (nums[a],nums[b]) = (nums[b],nums[a])
    }

//循环引用(属性前+weak修饰)
class Node {
    var value = 0
    weak var prev : Node?
    weak var next : Node?
    init(_ value : Int) {
        self.value = value
    }
    deinit {
        print("deinit")
    }
}

let a = Node(0)
 let b = Node(1)
        
a.prev = b
b.next = a

简单：
func addTwo(input : Int) -> Int {
        return input + 2
    }
//什么是柯里化? //柯里化指的是从一个多参数函数变成一连串单参数函数的变换
    func add (input : Int) -> (Int) -> Int {
        return { value in
            return input + value
        }
    }
let addTwo = add(input: 2)
let oupPut = addTwo(8)
print(oupPut)

class BankCard {
        //余额
        var balance : Double = 0.0
        //存钱方法
        func deposit(amount: Double) {
            balance += amount
            print("deposit:\(balance)")
        }
        
    }

//柯里化?
let card = BankCard()
card.deposit(amount: 100)
        
let deposit = BankCard.deposit
deposit(card)(100)