Swift, Functions, Optionals

Online Swift Playground 

//Functions
func greetings() {
    print("Hi!")
}
greetings()

func greetingsName(name str: String) {
    print("Hi " + str + "!")
}
greetingsName(name: "Mike")

func areaOfRect(_ w: Int = 1, h: Int = 1) -> Int {
    let area = w * h
    return area
}
let theArea = areaOfRect(5, h: 5)
print("area =", theArea)
print("default parameters", areaOfRect())

func greet(name: String) -> String {
    "Hi " + name + "!"
}
print(greet(name: "Mike"))

func rettup() -> (Int, Int) {
    let x = 5
    return(x, x)
}
print(rettup().0, rettup().1)

func notret() -> Never {
   //infinite
}

//Pass by value
func foo(value: Int) {
    value += 1  //error
    print("in foo +1: \(value)")
}

//Pass by ref
func foo(value: inout Int) {
    value += 1
    print("in foo +1: \(value)")
}

var x:Int  = 5
print("before foo: \(x)")
foo(value: &x)
print("after foo: \(x)")

//Overloading
func get() -> Int {
    42
}
func get() -> String {
    "str"
}
let valInt: Int = get()
let valStr: String = get()
print(valInt, valStr)

//Function pointer
func add(_ a: Int, _ b: Int) -> Int{
    a + b
}
func sub(_ a: Int, _ b: Int) -> Int{
    a - b
}
func foo(_ fn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print(fn(a, b))
}
foo(add, 5, 2)
foo(sub, 5, 2)

//Doxygen
/// Calculates the sum of two values
/// - Parameters:
///    - a: The first value.
///    - b: The second value.
/// - Returns: The sum of the two values.

//Optional
var x: Int?
x = 10
x = Int("5")
//x = Int("Cat")
//x = nil
print(x)

//Unwrap
if x != nil {
    print(x! + 1)
}

var a: Int? = 5
//a = nil
var res = a ?? 0
//res = a != nil ? a! : 0
print(res)

//Binding
let p1:(Int?, Int?) = (5, 5)
if let x = p1.0,
   let y = p1.1 {
    print("x:\(x), y:\(y)")
}else{
    print("nil")
}

var z: Int? = 5
if let z = z, z <= 5 {
    print("z:\(z)")
}else{
    print("nil")
}

//Guard
func foo(_ str: String?) {
   guard let str = str, str.count != 0 else {
      print("exit")
      return
   }
   // code
   print("run \(str)")
}
var str:String? = "str"
//str = nil
foo(str)

func parse(str: String) -> Int? {
   if let num = Int(str) {
      return num
   }else{
      return nil
   }
}
func str2num(str: String) {
    guard let num = parse(str: str) else {
        print("exit")
        return
    }
    print("run \(num)")
}
str2num(str: "1")