staticVoidMan

var test: Int = 1000
let data = Data(bytes: &test, count: MemoryLayout<Int>.size)

var number: Int = 0
number = data.withUnsafeBytes { (pointer: UnsafePointer<Int>) -> Int in
    return pointer.pointee
}

staticVoidMan

class Bird {
    
    enum BiologicalSex {
        case undetermined
        case male
        case female
    }
    
    var name: String?
    var biologicalSex: BiologicalSex

staticVoidMan

import Foundation

struct Result {
    
    enum Level {
        case junior
        case senior
        case enticer
        case undetermined(String)
    }

staticVoidMan

enum IrregularData {
    
    case string(String)
    case bool(Bool)
    case int(Int)
    case unknown(Any?)
    
}

extension IrregularData: Decodable {

staticVoidMan

enum MyData {
    
    case string(String)
    case bool(Bool)
    case int(Int)
    case unknown
    
}

extension MyData: Decodable {

staticVoidMan

var animals = ["Dog", "Cat", "Hamster", "Pig"]
var animalTags = [3, 2, 4, 1]

//Zip the two together
let animalsTagsZip = zip(animals, animalTags)

//Sort them based on your requirement to get an array of (String, Int) tuples
let animalsTagsSorted = animalsTagsZip.sorted { (lhs, rhs) -> Bool in
    return lhs.1 > rhs.1
}

staticVoidMan

let myString: String??? = "Hello, World!"

print(myString!!!)

if case let safelyUnwrappedString??? = myString {
    print(safelyUnwrappedString)
}

if let safelyUnwrappedString = myString as? String {
    print(safelyUnwrappedString)

staticVoidMan

//Ref: https://www.klundberg.com/blog/swift-4-keypaths-and-you/

struct Person {
    var name: String
}

let aKeyPath = \Person.name

type(of: aKeyPath).rootType //Root type of the keyPath: Person
type(of: aKeyPath).valueType //Value type of the keyPath: String

staticVoidMan

struct Person {
    var name: String
    var likes: [String:[Any]]?
}

let aKeyPath = \Person.likes?["friends"]?[0]

type(of: aKeyPath).rootType
type(of: aKeyPath).valueType

staticVoidMan

enum MyError: Error {
    case RuntimeError(String)
}

func doSomething(_ completion: (Bool) throws -> Void) rethrows {
    // Try the completion as the closure could throw
    try completion(false)
}

do {