thatswiftguy

#Heading 1 ##Heading 2 ###Heading 3 ####Heading 4 #####Heading 5 ######Heading 6

---

Paragraph

thatswiftguy

// Mark:- First Point
private func addingOf(_ num1: Int, and num2: Int) {
  print("\(num1) + \(num2) = \(num1 + num2)")
}

// Mark:- Second Point
private func increment(_ value: inout Int) {
  value += 1
  print(value)
}

thatswiftguy

var myClosure = { (name : String) in
    print("Mycoluuure\(name)")
}

myClosure("yasir")

thatswiftguy

class SomeClass: SomeSuperclass, MyProtocol, AnotherProtocol {
    // class definition goes here
}

thatswiftguy

struct WeatherResponse : Decodable {
    let name : String
    let weather : [WeatherAPI]
    let main : MainAPI
}

struct WeatherAPI : Decodable {
    let description : String
}

thatswiftguy

class ViewModel : ObservableObject {

    @Published var temp : Double
    
    init(){
        temp = 0
        getData()
    }
    func getData() {
        

thatswiftguy

enum NetworkError : Error {
    case cityNotFound
    case timeOut
}

class WeatherService {
    
    static func getData(city : String , completionHandler : @escaping (Result<WeatherResponse, NetworkError>) -> ()) {
        
        guard let url = URL(string: "\(city)") else {

thatswiftguy

class ViewModel : ObservableObject {

    @Published var weatherData : WeatherResponse?
    @Published var showErrorAlert = false
    @Published var alertDescription = ""
    
    let city = "https://api.openweathermap.org/data/2.5/weather?q=delhi&appid={YOUR-API-KEY}&units=metric"
    
    init(){
        WeatherService.getData(city: city) { result in

thatswiftguy

extension Calendar {
    public func getAllDates(
        dateInterval: DateInterval,
        dateComponent: DateComponents) -> [Date] {
        
        var dates: [Date] = []
        dates.append(dateInterval.start)
        
        enumerateDates(startingAfter: dateInterval.start, matching: dateComponent, matchingPolicy: .nextTime) { date, _, stop in
            guard let date = date else {

thatswiftguy

func binarySearchWithRecursion(arr: [Int], target: Int, s: Int, e: Int) -> Int {
    if s > e {
        return -1
    }
    
    if arr[s] == target {
        return s
    }
    
    let med = e / arr.count