Naweel Anwer

Multipart request in Swift

Fri, 09 Sep 2016 00:00:00 +0000

Understanding Protocol Oriented programming in Swift

Sun, 04 Sep 2016 00:00:00 +0000

WWDC2015 was all about Protocol oriented programming. How is it different?

Lets see.

Inheritance

Inheritance is widely used and loved by lot. But people have started talking against Inheritance

Consider a simple example:

class Shape {
    var color: String!
    func area() -> Double {
        fatalError("This method is abstract & must be overridden before using")
    }
}

class Circle: Shape {
    var radius: Double! = 10.4
    override func area() -> Double {
        return radius * radius * M_PI
    }
}

class Square: Shape {
    var sideLength: Double! = 10.0
    override func area() -> Double {
        return sideLength * sideLength
    }
}

Protocol Oriented Solution

Lets reimplement above code using Protocols

protocol Shape {
    var color: String { get set}
    func area() -> Double
}

struct Circle: Shape {
    var color: String
    var radius: Double
    func area() -> Double {
        return radius * radius * M_PI
    }
}

struct Square: Shape {
    var color: String
    var sideLength: Double
    func area() -> Double {
        return sideLength * sideLength
    }
}

var arr = [Shape]()
arr.append(Circle(color: "Red", radius: 10.0))
arr.append(Square(color: "Green", sideLength: 50))

Benefits of protocol oriented code

Code reuse in Value types

One of the basic difference between Class and struct is that classes can inherit while structs cannot. Swift clearly is promoting value type over reference type. So protocols can be used to make your code more reusable in Value-type environment.

Clarity

The structures in above example more clearly state their properties and methods. There is no hidden property/method.

But if you conform to a lot of protocols, it makes your class definition very long. But you could always use Object composition

Conform to multiple protocols

One of the drawbacks of inheritance is there cannot be multiple superclasses(This design is discouraged although). But on the contrary a Struct/Class can conform to multiple protocols

UIImageView extension to load image from URL

Mon, 22 Aug 2016 00:00:00 +0000

Here is a simple UIImageView extension to load image from URL

Paramaters

url: NSURL
Location of remote image
placeHolder: UIImage? = nil
Image to be set if remote image is not available
completionHandler: (success: Bool) -> ())? = nil
Optional handler invoked after the image is set

Extension

extension UIImageView {
    func setImageFromURL(
        url: NSURL,
        placeHolder: UIImage? = nil,
        completion: ((success: Bool) -> ())? = nil ) {

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
            if let imageData: NSData = NSData(contentsOfURL: url) {
                let newImage = UIImage(data: imageData)
                dispatch_async(dispatch_get_main_queue()) {
                    self.image = newImage
                    completion?(success: true)
                }
            } else {
                dispatch_async(dispatch_get_main_queue()) {
                    self.image = placeHolder
                    completion?(success: false)
                }
            }
        }
    }
}

More flexible arrays in Swift

Mon, 22 Aug 2016 00:00:00 +0000

There comes a time when you have to create an Array of objects which are of different types. A generic solution to this problem is to create an Array<AnyObject>

Array<AnyObject>

Array can accommodate almost everything into it. But wait..

Why do you need it?

Whenever there comes a need to create an array of anyobject, just consider redesigning the code instead. Why would you create a list of heterogenous type in the first place?

But if the list is somewhat similar then you can use Protocol oriented Programming for this.

Protocol Oriented Solution

Swift is focusing more on protocol oriented programming. So if you have to create an array of similar but not the same data types, then you can make all the similar types conform to a Protocol and create an array of the Protocol.

Here is the example

protocol Shape {
    var color: String { get set}
    func area() -> Double
}

struct Circle: Shape {
    var color: String
    var radius: Double
    func area() -> Double {
        return radius * radius * M_PI
    }
}

struct Square: Shape {
    var color: String
    var sideLength: Double
    func area() -> Double {
        return sideLength * sideLength
    }
}

var arr = [Shape]()
arr.append(Circle(color: "Red", radius: 10.0))
arr.append(Square(color: "Green", sideLength: 50))

Awesome swift libraries

Thu, 14 Jul 2016 00:00:00 +0000

Some of the libraries that I use frequently

AFDateHelper

A must have date helper for Swift

Alamofire

Undoubtedly the most popular Networking library for Swift

R.swift

Get strong typed, autocompleted resources like images, fonts, colors, localized strings, reusable cells and segues.

SwiftyJSON

SwiftyUserDefaults

Type safe User defaults

XCGLogger

Logging library

LayoutKit

Autolayout library by Linkedin.

SnapKit

DSL to make autolayout easy on iOS and macOS

Gecco

Simply highlight items for your tutorial walkthrough, written in Swift

SwiftyAttributes

Swift extensions that make it a breeze to work with attributed strings.

RazzleDazzle

Add scrollview-powered animations to the app intro of your iOS app

Tryouts of reduce function in Swift

Fri, 23 Oct 2015 00:00:00 +0000

Swift has a set of awesome high order functions like map, filter and reduce. Although reduce is relatively complex, it has immense flexibility and power. Reduce has flexibility to such an extent that it can do all possible array operations.

Array methods re implemented using reduce

You can check out some of the array functionalities that I have re implemented using reduce

array.count

let totalElements = ["A", "B", "C", "D", "E"].reduce(0) { $0.0 + 1}
// Returns 5

array.insertElement(atIndex)

let newElement = "NEW"; let atIndex = 3
let newList: [String] = ["A", "B", "C", "D", "E"].reduce([String]()) { (accum, char) in
    if accum.count == atIndex {
        return accum + [newElement, char]
    }
    return accum + [char]
}
// Returns ["A", "B", "C", "NEW", "D", "E"]

array.last

let chars = ["A", "B", "C", "D", "E"]
let lastElement: String = chars.reduce(chars[0]) { (_, char) in
    return char
}
// Returns "E"

map using reduce

If this wasnt impressive enough, check out how map can be implemented using reduce.

let stringedNums = [1, 2, 3, 4].map { String( $0) }

// reduce implementation of above map
let stringedNums = [1, 2, 3, 4].reduce([String]()) { (accum, num) in
    return accum + [String(num)]
}
// Returns ["1", "2", "3", "4"]

filter using reduce

Similarly filter implementation is

// Filters odd numbers from array
[1, 2, 3, 4, 5].filter {
    $0 % 2 == 0
}

// reduce equivalent of above filter
[1, 2, 3, 4, 5].reduce([Int]()) { (accum, num) in
    return num % 2 == 0 ? accum + [num] : accum
}
// Returns [2, 4]

Now what ?

reduce can be used to implement native array methods. It can also be used as map and filter. But what was the point ?

Point was to show how powerful reduce function is. It happens that we unknowingly chain map and filter as requirement changes. This chaining becomes cumbersome. If you have very specific requirements you can always use reduce. You get the desired outcome in one array traversal.

Equatable enums in Swift

Mon, 28 Sep 2015 00:00:00 +0000

Equating enums in swift for simple cases like this one is pretty straight forward.

enum Vehicle {
    case Car, Bike
}

let v1 = Vehicle1.Car
let v2 = Vehicle1.Bike

v1 == v2 // False

But things get complicated, when the enum matures to something like this. Here you cannot use == operator directly.

enum Vehicle {
    enum CarType {
        case Sedan, SUV, MUV, HatchBack
    }
    enum BikeType {
        case Sports, Cruiser, Dirt
    }

    case Car(CarType)
    case Bike(BikeType)
    case Other(String)
}

So to equate enum like this we have two options

Use the complicated nested switch casing
or Implement the Equatable protocol.

But using the nested switch casing has clear drawbacks. Hence we implement the Equatable protocol as we usually do for Classes.

// Conform to Equatable protocol
extension Vehicle: Equatable {}

func ==(lhs: Vehicle, rhs: Vehicle) -> Bool {
    switch (lhs, rhs) {
    case (.Car(let a), .Car(let b)):
        return a == b
    case (.Bike(let a), .Bike(let b)):
        return a == b
    case let (.Other(a), .Other(b)): // One let can also be used instead of multiple let
        return a == b
    default: return false
    }
}

After defining the == function we can equate our enums.

Vehicle.Car(.Sedan)      == Vehicle.Car(.Sedan)      // true
Vehicle.Car(.Sedan)      == Vehicle.Car(.MUV)        // false
Vehicle.Bike(.Sports)    == Vehicle.Car(.Sedan)      // false
Vehicle.Bike(.Sports)    == Vehicle.Bike(.Sports)    // true
Vehicle.Other("tractor") == Vehicle.Car(.HatchBack)  // false
Vehicle.Other("Bus")     == Vehicle.Car(.HatchBack)  // false
Vehicle.Other("tractor") == Vehicle.Other("tractor") // true
Vehicle.Other("tractor") == Vehicle.Other("crane")   // false

Our enum comparison has now clarity and brevity. And most important it’s readable

For more information on comparison protocol you refer to this post written by Matt Thompson on NSHipster.