Swift - Extensions

Functionality of an existing class, structure or enumeration type can be added with the help of extensions. Type functionality can be added with extensions but overriding the functionality is not possible with extensions.

Swift Extension Functionalities −

• Adding computed properties and computed type properties


• Defining instance and type methods.


• Providing new initializers.
• Defining subscripts


• Defining and using new nested types


• Making an existing type conform to a protocol

Extensions are declared with the keyword 'extension'

Syntax

extension SomeType { 
    // new functionality can be added here 
 }  

Existing type can also be added with extensions to make it as a protocol standard and its syntax is similar to that of classes or structures.

extension SomeType: SomeProtocol, AnotherProtocol { 
    // protocol requirements is described here
  }  

Computed Properties

Computed 'instance' and 'type' properties can also be extended with the help of extensions.

extension Int { 
    var add: Int {return self + 100 } 
    var sub: Int { return self - 10 }  
   var mul: Int { return self * 10 }  
   var div: Int { return self / 5 } 
 }
    let addition = 3.add 
 print("Addition is \(addition)") 
 let subtraction = 120.sub 
 print("Subtraction is \(subtraction)")
    let multiplication = 39.mul
  print("Multiplication is \(multiplication)") 
   let division = 55.div 
 print("Division is \(division)")  
  let mix = 30.add + 34.sub 
 print("Mixed Type is \(mix)")

When we run the above program using playground, we get the following result −

Addition is 103 
 Subtraction is 110 
 Multiplication is 390 
 Division is 11 
 Mixed Type is 154  

Initializers

Swift 4 provides the flexibility to add new initializers to an existing type by extensions. The user can add their own custom types to extend the types already defined and additional initialization options are also possible. Extensions supports only init(). deinit() is not supported by the extensions.

struct sum { 
    var num1 = 100, num2 = 200  } 
   struct diff { 
    var no1 = 200, no2 = 100 
 }    struct mult { 
    var a = sum() 
    var b = diff() 
 } 
   let calc = mult() 
 print ("Inside mult block \(calc.a.num1, calc.a.num2)") 
 print("Inside mult block \(calc.b.no1, calc.b.no2)") 
 let memcalc = mult(a: sum(num1: 300, num2: 500),
b: diff(no1: 300, no2: 100)) 
 print("Inside mult block \(memcalc.a.num1, memcalc.a.num2)") 
 print("Inside mult block \(memcalc.b.no1, memcalc.b.no2)")  
  extension mult { 
    init(x: sum, y: diff) { 
       let X = x.num1 + x.num2 
       let Y = y.no1 + y.no2   
  } 
 } 
   let a = sum(num1: 100, num2: 200) 
 print("Inside Sum Block:\( a.num1, a.num2)") 
   let b = diff(no1: 200, no2: 100) 
 print("Inside Diff Block: \(b.no1, b.no2)")

When we run the above program using playground, we get the following result −

Inside mult block (100, 200) 
 Inside mult block (200, 100)
  Inside mult block (300, 500) 
 Inside mult block (300, 100) 
 Inside Sum Block:(100, 200) 
 Inside Diff Block: (200, 100)  

Methods

New instance methods and type methods can be added further to the subclass with the help of extensions.

extension Int { 
    func topics(summation: () -> ()) { 
       for _ in 0..<self {  
         summation() 
       }  
   }
  } 
   4.topics(summation: { 
    print("Inside Extensions Block") 
 }) 
   3.topics(summation: { 
    print("Inside Type Casting Block") 
 })

When we run the above program using playground, we get the following result −

  Inside Extensions Block 
 Inside Extensions Block 
 Inside Extensions Block 
 Inside Extensions Block 
 Inside Type Casting Block 
 Inside Type Casting Block 
 Inside Type Casting Block  

topics() function takes argument of type '(summation: () → ())' to indicate the function does not take any arguments and it won't return any values. To call that function multiple number of times, for block is initialized and call to the method with topic() is initialized.

Mutating Instance Methods

Instance methods can also be mutated when declared as extensions.

Structure and enumeration methods that modify self or its properties must mark the instance method as mutating, just like mutating methods from an original implementation.

extension Double { 
    mutating func square() { 
       let pi = 3.1415  
      self = pi * self * self  
   } 
 }
    var Trial1 = 3.3
  Trial1.square()
  print("Area of 
circle is: \(Trial1)") 
   var Trial2 = 5.8 
 Trial2.square()
  print("Area of circle is: \(Trial2)") 
   var Trial3 = 120.3  Trial3.square() 
 print("Area of circle is: \(Trial3)")

When we run the above program using playground, we get the following result −

Area of circle is: 34.210935 
 Area of circle is: 105.68006 
 Area of circle is: 45464.070735  

Subscripts

Adding new subscripts to already declared instances can also be possible with extensions.

extension Int { 
    subscript(var multtable: Int) -> Int {
        var no1 = 1
        while multtable > 0 {    
       no1 *= 10  
         --multtable    
    }   
     return (self / no1) % 10    
 } 
 } 
   print(12[0]) 
 print(7869[1])
  print(786543[2])

When we run the above program using playground, we get the following result −

2 
 6 
 5  

Nested Types

Nested types for class, structure and enumeration instances can also be extended with the help of extensions.

extension Int { 
    enum calc {  
      case add 
       case sub 
       case mult  
      case div 
       case anything 
    }   
  var print: calc { 
       switch self {    
       case 0: 
             return .add   
        case 1: 
             return .sub
           case 2:  
            return .mult  
         case 3:   
           return .div  
         default: 
             return .anything
        } 
    } 
 }  
  func result(numb: [Int]) {
     for i in numb { 
       switch i.print { 
          case .add: 
             print(" 10 ") 
          case .sub: 
             print(" 20 ") 
          case .mult:
              print(" 30 ")    
       case .div: 
 print(" 40 ") 
          default: 
             print(" 50 ")  
      } 
    } 
 } 
 result(numb: [0, 1, 2, 3, 4, 7])

When we run the above program using playground, we get the following result −

 10 
 20 
 30 
 40 
 50
 50