let path = bezierPath.cgPath
// path is of type CGPath and can be used in a shared code with iOS, tvOS or watchOS targets

AVCaptureDevice.toggleFlashlight(with: .max)

CAAnimation.patternReplocator(with: UIImage("image"), size: CGSize(width: 600, height: 600), targetLayer: drawerView.layer)

CGSize(width: 10, height: 20) + CGSize(width: 25.4, height: 23.6)
CGSize(width: 10, height: 20) - CGSize(width: 25.4, height: 23.6)
CGSize(width: 10, height: 20) * CGSize(width: 25.4, height: 23.6)
CGSize(width: 10, height: 20) / CGSize(width: 25.4, height: 23.6)

var origin: CGPoint = .zero
let addPoint = origin + CGPoint(x: 10, y: 3)
origin += CGPoint(x: 12, y: 5)
let subPoint = origin - CGPoint(x: 12, y: 5)
        
let interpolatedPoint = CGPoint.lerp(start: pointOne, end: pointTwo, t: 2)

let point = CGPoint(x: 3, y: 5)
let _ = point.length()
let _ = point.angle
let _ = point.normalized()
let distanceBetweenTwoPoints = point.distanceTo(anotherPoint)
let _ = point.lengthSquared()

let rect = CGRect(origin: .zero, size: CGSize(width: 100, height:
            200))
let newSize = rect.scaled(to: targetSize)

let rect = CGRect(origin: .zero, size: CGSize(width: 100, height:
            200))
rect.topLeft
rect.topRight
rect.bottomLeft
rect.bottomRight

let rect = CGRect(origin: .zero, size: CGSize(width: 100, height:
            200))
rect.mid

let rect = CGRect(origin: .zero, size: CGSize(width: 100, height:
            200))
rect.aspectFit(inRect: targetRect)

let val: CGFloat = 4.32
let roundedVal = val.rounded(toPlaces: 1) // roundedVal holds `4.3`

let invertedImage = ciImage.inverted
// invertedImage holds the same image data but with inverted colors

let helloWorldQRImage = CIImage.qrImage(from: "Hello World!")
// helloWorldQRImage holds image data that represents QR code for `Hello World!` message

let redQRImage = qrImage.tinted(by: .red)
// redQRImage holds the same QR image data as before but tinted by red color

let transparentImage = ciImage.transparent
let blackTransparentImage = anotherImage.blackTransparent

// Binding is as easy as writing just a single line of code:
viewModel.bind(\.progressSlider, to: progressSlider, at: \.value)

// Observing for changes is thinner than the `Swifts 4.0` updated `KVO`:
viewModel.observe(\.buttonTitle) { [button] in
        button!.setTitle($0, for: .normal)
}

class FeedTableViewCell: UITableViewCell, Identifiable {
       // ... 
       // Implementation details
       // ... 
}

// Somewhere in `UITableViewControllerDelegate`:
let cell = dequeueReusableCell(withIdetifier: cell. reuseIdentifier)

var imageView = UIImageView().then {
        $0.layer.cornerRadius = 10
        $0.contentMode = .scaleAspectFill
        $0.clipsToBounds = true
}

let stringVariable = Variable("Initial Value")
let newValue = "New Value"
stringVariable.value = newValue

stringVariable.onUpdate = {
        let isEqual = $0 == newValue
        XCTAssert(isEqual)
}

let debouncer = Debouncer(delay: 2.0)
debouncer.schedule {
        value = "Changed Value"            
}
// After 2.0 seconds the value will be changed to "Changed Value"

let array: ObservableArray = [1,2,3,4,5]
array += 6
array += [7,8]

array.allChanges = { change in
        // Both changes will, for addition of `6` and `[7,8]` will be reflected in `change` property and the appropriate callbacks will be made
}

array.removeFirst()
array.removeLast()
array.remove(at: 4)

let url = URL(fileURLWithPath: "/somePath/subpath/file.rtf")
let fileHandle = try FileHandle(forWritingTo: url)
var textOutputStream = TextOutputStream(fileHandle)

print("\(outputString)", &textOutputStream)
// The print statement will write the output stream to the specified FileHandle at the specified URL. This stream mimics Java's SDK File Output Stream. 

var unicodeOutputStream = UnicodeOutputStream()
print("👨‍👩‍👧‍👧", to: &unicodeOutputStream)

// Will print all the unicode indices + characters + names

func double<T: Numeric>(array: [T]) -> [T] {
        return array.map { $0 * 2 }
}
        
func square<T: Numeric>(array: [T]) -> [T] {
        return array.map { $0 * $0 }
}
        
func toStringArray<T: Numeric>(array: [T]) -> [String] {
        return array.map { "\($0)" }
}

let data = [1,2,3,4,5]
let newData = (double ->> square ->> toStringArray)(data)        
// newData now equals to ["4", "16", "36", "64", "100"]

// 1. Add conformance to BuilderProtocol
extension Song: BuilderProtocol { /* empty implementation */ }

// 2. Then you can use Key-Path builder approach:
let song = Song()
        .init(\.author,         with: author)
        .init(\.name,           with: name)
        .init(\.genre,          with: genre)
        .init(\.duration,       with: duration)
        .init(\.releaseDate,    with: releaseDate)

extension Actor {
    struct Lenses {
        static let name = Lens<Actor, String>(
            get: {$0.name},
            set: {(me, value) in Actor(name: value, surname: me.surname) }
        )
        static let surname = Lens<Actor, String>(
            get: {$0.surname},
            set: {(me, value) in Actor(name: me.name, surname: value) }
        )
    }
}

extension Movie {
    struct Lenses {
        static let mainActor = Lens<Movie, Actor?>(get: { movie in
            let actor: Actor? = movie.actors.first
            return actor
        }, set: { me, actor -> Movie in
            guard let actor = actor else { return me }
            
            return Movie(name: me.name, year: me.year, actors: [actor] + me.actors)
        })
    }
}

let objectPool = ObjectPool(objects: [resource, anotherResource, thirdResource])
let reusedResource = objectPool.dequeue()
objectPool.enqueue(object: reusedResource)
objectPool.eraseAll()

let observerOne = ObserverOne()
var observerTwo: ObserverTwo? = ObserverTwo()
let observerThree = ObserverThree()

let subject = Subject()
subject += [observerOne, observerTwo!, observerThree]

subject ~> EmailNotification(message: "Hello Observers, this messag was sent from the Subject!")

// Will produce the following output:
// 
// Observer One:  data: Optional("Hello Observers, this messag was sent from the Subject!")
// Observer Two:  data: Optional("Hello Observers, this messag was sent from the Subject!")
// Observer Three:  data: Optional("Hello Observers, this messag was sent from the Subject!")

// Create the view controllers that will be delegates
let containerViewController = ContainerViewController()
let profileViewController = ProfileViewController()

let profileModel = ProfileModel()

// Attach the delegates
profileModel.delegates.add(delegate: containerViewController)
profileModel.delegates.add(delegate: profileViewController)

// Change the model
profileModel.name = "John"

// After changing `name` property we got the following in console:
// ContainerViewControllers:  didUpdate(name:)  value:  John
// ProfileViewController:  didUpdate(name:)  value:  John

// Assume that we needed to remove one of the delegates:
profileModel.delegates.remove(delegate: profileViewController)

// And again update the model:
profileModel.city = "New York"
// This time the console outputs is the following:
// ContainerViewControllers:  didUpdate(city:)  value:  New York

// We again attach ProfileViewController
profileModel.delegates.add(delegate: profileViewController)

// Custom closure that is called outside of the model layer, for cases when something custom is required without the need to touch the original code-base. For instance we may implement this function in our view-model layer when using MVVM architecture
profileModel.delegates.update { modelDelegate in
    modelDelegate.didSave()
}

var stack: Stack = [1,2,3,4,5,6,7,8,1]
let lastElement = stack.pop()
stack.push(element: 10)

var queue: Queue = [1,2,3,4,5,6,7,8,1]
queue.enqueue(element: 9)
let dequeuedElement = queue.dequeue()

var queue = PriorityQueue<Int>(elements: [2, 1, 4, 3, 5], order: >)
queue.enqueue(9)

var dequeue = Dequeue([1,2,34,5,6,7])
let back = dequeue.dequeueBack()
let front = dequeue.dequeueFront()

dequeue.enqueue(front: 99)
dequeue.enqueue(back: 99)

var list: LinkedList = [1,2,4,5]
list.pop()

var newList = LinkedList<Int>(sequence: list)
newList.pop()

var list: DoublyLinkedList = [1,2,4,5,6,7]
list.head
list.tail

list.removeHead()
list.removeTail()

list.push(newHead: 99)
list.push(newTail: 101)

var maxHeap = Heap<Int>(order: >)
maxHeap.insert(node: 1)
maxHeap.insert(node: 5)
maxHeap.insert(node: 2)
maxHeap.insert(node: 7)
maxHeap.insert(node: 9)

maxHeap.index(of: 3)
let sortedHeapmaxHeap.sorted()

let result = [1,2,3,4,5,6,7,8,9,10].skip(5)
// result array contains all the elements except the first 5 e.g. [6,7,8,9,10]

let result = [1,2,3,4,5,6,7,8,9,10].all { $0 < 20 }
// result will be true since all the elements are less than 20

let result = [1,2,3,4,5,6,7,8,9,10].any { $0 < 5 }
// result will be true since there are a number of elements that are less than 5

let result = [1,2,4,5,6,7,8,9,10].contains(elements: 1,2,4,5)
// result will be true since the target array contains all the specified elements

let result = [1,2,4,5,6,7,8,9,10].contains(elements: 9,10,11,12)
// result will be false since the target array does not contain 11 and 12

let testA = [1,2,3,4,5]
let testB = [4,5,7,8,9]

let result = testA.difference(elements: testB)
// result will be [1,2,3]

let result = testB.difference(elements: testA)
// result will be [7,8,9]

let testA = [1,2,3,4,5]
let testB = [4,5,6,7]

let result = testA.intersection(values: testB)
// result will be [4,5]

let result = [1,2,4,5,6,7,8].union(value: [8,9,10])
// result will be [1, 2, 4, 5, 6, 7, 8, 9, 10]

var test = [1,2,3,4,5,6,7,8]

test.remove(object: 8)
// test contains the following elements [1,2,3,4,5,6,7]

test.remove(objects: [1,2,4])
// test contains the following elements [3,5,6,7]

test.remove(objects: 5,6)
// test contains the following elements [3,7]

// User is a .json file containing the following data:
// {
//    "name":"Willy",
//    "age":30
// }

let decodedUser = try? User.decodeFromFile(named: "User")
// decodedUser will be a Decodable struct named User with two properties for name and age

let className = Foo.nameOfclass
// className property holds `Foo`

NotificationCenter.post(notification: .userHasUpdated)

OperationQueue.isMain // if current operation queue is the main the result will be true, otherwise false
OperationQueue.onMain {
        // This closure will be executed on the main operation queue
}

let customUrlQRImage = url.qrImage()
// customUrlQRImage holds image data for QR image that represents the given URL address

let view = UIView()
view.mask(corners: .allCorners, with: 10)

let blendedColor = red.blend(with: blue, intensity: 0.5)

let brighterRed = red.increaseBrightness(0.25)

let downsampledImage = UIImage.downsample(imageAt: url, to: targetSize)
// downsampledImage stores a `UIImage` instance that was cached and downsized to the `targetSize`

UIAlertController.present(with: "Warning!", and: "The item will be deleted", from: targetViewController) { () -> [UIAlertAction] in
        let deleteAction = UIAlertAction(title: "Delete",
                                         style: .destructive,
                                         handler: { (action) in
                // Callback handling
        })
            
        let cancelAction = UIAlertAction(title: "Cancel",
                                         style: .cancel,
                                         handler: { (action) in
                // Callback handling
        })
            
        return [deleteAction, cancelAction]
}

// Instantiation of a view controller by explicitly setting the storyboard and identifier
let loginViewController = UIViewController.instantiateController(from: mainStoryboard, identifier: "LoginViewController")

// An another way to instantiate a UIViewController instnace: here the identifier will be the class name
let viewController = UIViewController.instantiateController(from: mainStoryboard)

window = UIWindow.create(with: coordinator.rootViewController, option: .keyAndVisible)

os_log("Received .json data from the remove", log: .network)
os_log("Attempting to sync with the main UI thread", log: .ui)

let flyoverAction = SCNAction.moveAlong(path: flyoverPath, z: 10, speed: plane.speed)
plane.run(flyoverAction)