struct Vector2D {
    var x = 0.0, y = 0.0
}

extension Vector2D {
    static func + (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }
}

let vector = Vector2D(x: 3.0, y: 1.0)
let another = Vector2D(x: 2.0, y: 4.0)
let combined = vector + another

extension Vector2D {
    static prefix func - (vector: Vector2D) -> Vector2D {
        return Vector2D(x: -vector.x, y: -vector.y)
    }
}

let vector = Vector2D(x: 3.0, y: 1.0)
let negative = -vector

extension Vector2D {
    static func += (left: inout Vector2D, right: Vector2D) {
        return left = left + right;
    }
}

var original = Vector2D(x: 1.0, y: 2.0)
let toAdd = Vector2D(x: 3.0, y: 4.0)
original += toAdd

extension Vector2D : Equatable {
    static func == (left: inout Vector2D, right: Vector2D) -> Bool {
        return (left.x == right.x) && (left.y == right.y)
    }
}

struct Vector3D : Equatable {
    var x = 0.0, y = 0.0, z = 0.0
}

let vector = Vector3D(x: 2.0, y: 3.0, z: 4.0)
let another = Vector3D(x: 2.0, y: 3.0, z: 4.0)
if (vector == another) {
    print("These two vectors are also equivalent.")
}

prefix operator +++
extension Vector2D {
    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
        vector += vector
        return vector
    }
}

let vector = Vector2D(x: 2.0, y: 3.0)
let afterDoubling = +++vector

precedencegroup MyPrecedence {
    associativity: left
    lowerThan: AdditionPrecedence
}

      infix operator +-: AdditionPrecedence
      extension Vector2D {
          static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
              return Vector2D(x: left.x + right.x, y: left.y - right.y)
          }
      }

//      infix operator *^: MultiplicationPrecedence
      infix operator *^: MyPrecedence
      precedencegroup MyPrecedence {
          associativity: left
          lowerThan: AdditionPrecedence
      }

      extension Vector2D {
          static func *^ (left: Vector2D, right: Vector2D) -> Vector2D {
              return Vector2D(x: left.x * right.x, y: left.y * left.y + right.y * right.y)
          }
      }

      let first = Vector2D(x: 1.0, y: 2.0)
      let second = Vector2D(x: 3.0, y: 7.0)
      let plusMinusVector = first +- second
      let third = Vector2D(x: 2.0, y: 2.0)
      let vector = first +- second *^ third
      print(vector.x)
      print(vector.y)

let interval = 5
for tickMark in stride(from: 0, to: 50, by: interval) {
    print(tickMark)
}

for tickMark in stride(from: 0, through: 50, by: interval) {
    print(tickMark)
}

var count = 0
repeat {
    print(count)
    count += 1
} while count < 5

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("(0, 0) is at the origin")
case (_, 0):
    print("(\(somePoint.0), 0) is on the x-axis")
case (0, _):
    print("(0, \(somePoint.1)) is on the y-axis")
case (-2...2, -2...2)
    print("(\(somePoint.0), \(somePoint.1)) is inside the box")
default:
    print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}

let somePoint = (1, 1)
switch somePoint {
case (let x, 0):
    print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with an y value of \(y)")
case let (x, y):
    print("somewhere else at (\(x), \(y))")
}

let somePoint = (1, 1)
switch somePoint {
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    print("(\(x), \(y)) is just some arbitrary point")
}

let somePoint = (1, 1)
switch somePoint {
case (let distance, 0), (0, let distance):
    print("On the axis, \(distance) from the origin")
default
    print("Not on an axis")
}

let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
    fallthrough
default:
    description += " an integer."
}
print(description)

var number = 10
whileLoop: while number > 0 {
    switch number {
    case 9:
        print("9")
    case 10:
        var sum = 0
        for index in 0...10 {
            sum += index
            if index == 9 {
                print(sum)
                break whileLoop
            }
        }
    default:
        break
    }
    number -= 1
}

if #available(platform name version, ..., *) {
    // statements to execute if the APIs are available
} else {
    // fallback statements to execute if the APIs are unavailable
}

if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fail back to earlier iOS and macOS APIs
}

let someOptional: Int? = 42
if case .some(let x) = someOptional {
    print(x)
}

if case let x? = someOptional {
    print(x)
}

let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
for case let number? in arrayOfOptionalInts {
    print("Found a \(number)")
}

protocol Animal {
    var name: String { get }
}

struct Dog: Animal {
    var name : String {
        return "dog"
    }
    var runSpeed: Int
}

struct Bird: Animal {
    var name: String {
        return "bird"
    }

    var flightHeight: Int
}

struct Fish: Animal {
    var name: String {
        return "fish"
    }
    var depth: Int
}

let animals:[Any] = [Dog(runSpeed: 55), Bird(flightHeight: 2000), Fish(depth: 100)]

for animal in animals {
    switch animal {
    case let dog as Dog:
        print("\(dog.name) can run \(dog.runSpeed)")
    case let fish as Fish:
        print("\(fish.name) can dive depth \(fish.depth)")
    case is Bird:
        print("bird can fly!")
    default:
        print("unknown animal!")
    }
}

func ~= (pattern: String, value: Int) -> Bool {
    return pattern == "\(value)"
}

switch point {
case ("0", "0"):
    print("(0, 0) is at the origin.")
default:
    print("The point is at \(point.0), \(point.1)).")
}

struct Employee {
    var salary: Float
}
let e = Employee(salary: 9999)
func ~= (lhs: Range<Float>, rhs: Employee) -> Bool {
    return lhs.contains(rhs.salary)
}

switch e {
case 0.0..<1000:
    print("艰难生活")
case 1000..<5000:
    print("小康社会")
case 5000..<10000:
    print("活得很滋养")
default:
    break
}

let numbers = [Int](0...7)
print(numbers)
let persons = ["zhangsan": 27, "lisi": 28, "wangwu": 29]
let names = [String](persons.keys)
print(names)

let numbers = [Int](2...7)
for (index, num) in numbers.enumerated() {
    print("the index is: \(index)")
    print(num * 10)
}

var numbers = [Int](2...7)
numbers.append(100)
print(numbers)
numbers.append(contentsOf: 200...205)
print(numbers)

let array = [5, 2, 10, 1, 0, 100, 46, 99]
array.prefix(4)
array.prefix(upTo: 4)
array.prefix(through: 4)
print(array.prefix { $0 < 10 })

var array = [10, 20, 45, 30, 98, 101, 30, 4]
let index = array.partition { (element) -> Bool
    in 
    element > 30
}
print(array)
let partition1 = array[..<index]
let partition2 = array[index...]
print(partition1)
print(partition2)

struct Person {
    var name: String
    var age: Int
}

extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
        hasher.combine(age)
    }
}

var personSet = Set<Person>()
personSet.insert(Person(name: "zhangsan", age: 28))

struct Person {
    var name: String
    var age: Int
}

extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
    }
}

extension Person: Equatable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name
    }
}

var personSet = Set<Person>()
personSet.insert(Person(name: "zhangsan", age: 28))
personSet.update(with: Person(name: "zhangsan", age: 38))

enum Barcode {
case upc(Int, Int, Int, Int)
case qrCode(String)
}

var produceBarcode = Barcode.upc(8, 85909, 51226, 3)
print(produceBarcode)
produceBarcode = .qrCode("ABCDEFGHIJKLMNOP")
print(produceBarcode)

indirect enum ArithmeticExpression {
case number(Int)
case addition(ArithmeticExpression, ArithmeticExpression)
case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

class DataImporter {
    var fileName = "data.txt"
    init() {
        print("DataImporter inits")
    }
}

class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
print("manager.data.append finish")
print(manager.importer.fileName)

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + size.width / 2
            let centerY = origin.y + size.height / 2
            return Point(x: centerX, y: centerY)
        }
        // set(newCenter) {
        //     origin.x = newCenter.x - size.width / 2;
        //     origin.y = newCenter.y - size.height / 2;
        // }
        set {
            origin.x = newValue.x - size.width / 2;
            origin.y = newValue.y - size.height / 2;
        }
    }
}

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 200
stepCounter.totalSteps = 360
stepCounter.totalSteps = 896

var count: Int = 0 {
    willSet(newCount) {
        print("About to set count to \(newCount)")
    }
    didSet {
        if count > oldValue {
            print("Added \(count - oldValue)")
        }
    }
}

count = 10
if count = 10 {
    print("ten")
}

class SomeClass {
    static var storedTypeProperty = "Some Value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

struct TimesTable {
    let multipler: Int
    subscript(index: Int) -> Int {
        return multipler * index;
    }
}
let threeTimesTable = TimesTable(multipler: 3)
print("six times three is \(threeTimesTable[6])")

extension Array: TextRepresentable where Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" + itemsAsText.joined(separator: ", ") + "]"
    }
}
let myDice = [d6, d12]
print(myDice.textualDescription)

struct Hamster {
    var name: String
    var textualDescription: String {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentable {}

extension Collection where Iterator.Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" + itemsAsText.joined(separator: ", ") + "]"
    }
}

@interface MyClass : NSObject

- (NSUInteger)indexOfString:(NSString *)aString NS_REFINED_FOR_SWIFT;

@end

extension MyClass {
    func indexOfString(aString: String!) -> Int? {
        let index = Int(__index(of: aString))
        if (index == NSNotFound) return nil
        return index;
    }
}

struct ValueType {
    var name: String
}

var object = ValueType(name: "Objective-C")
let name = \ValueType.name

// set
object[KeyPath: name] = "swift"
// get
let valueOfName = object[keyPath: name]
print(valueOfName)

class Person: NSObject {
    @objc dynamic var age = 0
}

@objc dynamic let p = Person()
var ob : NSKeyValueObservation?

p.addObserver(self, forKeyPath: "age" options: [.new, .old], context: nil)

self.ob = observe(\.p.age, options: [.new, .old]) { (_, change) in
    print(change.newValue as Any)
}

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
    if keyPath == "age" {
        print("age 被改变了")
        print(change as Any)
    }
}

public List<HeavyHitter> topK(String[] events, int k) {
    Map<String, Integer> frequencyTable = new HashMap<String, Integer>();
    for (String event: events) {
        frequencyTable.put(event, frequencyTable.getOrDefault(event, 0) + 1);
    }

    PriorityQueue<HeavyHitter> heap = 
        new PriorityQueue<HeavyHitter>(Comparator.comparing( e -> e.getFrequency()));

    for (Map.Entry<String, Integer> entry : frequencyTable.entrySet()) {
        heap.offer(new HeavyHitter(entry.getKey(), entry.getValue()));

        if (heap.size() > k) {
            heap.poll();
        }
    }

    List<HeavyHitter> result = new ArrayList<HeavyHitter>();
    while (heap.size() > 0) {
        result.add(heap.poll());
    }

    return result;
}

class HeavyHitter {
    private final String identifier;
    private final int frequency;

    public HeavyHitter(String identifier, int frequency) {
        this.identifier = identifier;
        this.frequency = frequency;
    }
}