The swift compiler was unable to resolve the overloaded convenience initializer. Being more explicit by marking the desired initializer with void: allows the compiler to successfully complete it's build. Resolves #37

In Promise.swift add debug outputs

    public init(callback: @escaping (_ resolve: @escaping ResolveCallBack,
        _ reject: @escaping RejectCallBack) -> Void) {
        promiseCallBack = callback
        print("+")
    }

    public init(callback: @escaping (_ resolve: @escaping ResolveCallBack,
        _ reject: @escaping RejectCallBack, _ progress: @escaping ProgressCallBack) -> Void) {
        promiseProgressCallBack = callback
        print("+")
    }

    deinit { print("-") }

Then if you run

func foo() {
    let a = Promise { r, _ in r() }
    let b = Promise { r, _ in r() }
    a.then{ print(".") }.then(b).then{ print(".") }
}
foo()

The output will be

+
+
+
.
+
+
+
+
.

After adding [weak self] to all registerThen<X> blocks

let p = Promise<X> { [weak self] resolve, reject in

and changing passAlongFirstPromiseStartFunctionAndStateTo<X> to

        } else {
            promise.initialPromiseStart = { [weak self] self?.start() }
        }

The output:

+
+
+
.
+
+
+
+
.
-
-

There are still strong ref cycles somewhere, any ideas?

I tried to use 3.0.0 in a project, compiling with Swift 4.0 from command line ... Got:

.../Source/Promise.swift:204:9: error: 'promiseProgressCallBack' is inaccessible due to 'private' protection level
        promiseProgressCallBack = { resolve, reject, progress in
        ^

.../Promise.swift:39:17: note: 'promiseProgressCallBack' declared here
    private var promiseProgressCallBack: ((_ resolve: @escaping ((T) -> Void),
                ^

.../Promise.swift:218:9: error: 'promiseProgressCallBack' is inaccessible due to 'private' protection level
        promiseProgressCallBack = { resolve, reject, progress in
        ^

.../Promise.swift:39:17: note: 'promiseProgressCallBack' declared here
    private var promiseProgressCallBack: ((_ resolve: @escaping ((T) -> Void),

It seems if you're using swift 4 toolchain, when you build 'then' from command line, it's built using swift 3 mode due to old manifest file format. Since Swift 4 changed access control rules the errors above appear.

When I changed 'then' Package.swift to:

// swift-tools-version:4.0
import PackageDescription

let package = Package(
   name: "then",
   products: [
      .library(
         name: "then",
         targets: ["then"]),
      ],
   dependencies: [
   ],
   targets: [
      .target(
         name: "then",
         dependencies: [])
      ]
)

Project built with no errors.

I created a new subfolder 'then' inside Sources and moved the source files to the folder to be able to compile the code, since new package manager requires it... (I tried with path property but with no success)

path: This property defines the path to the top-level directory containing the target's sources, relative to the package root. It is not legal for this path to escape the package root, i.e., values like "../Foo", "/Foo" are invalid.

• Background In Swift 5.5, Swift team introduced Swift concurrency feature (https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html), which includes a new keyword await.

This will cause confusion and conflict with freshOS/Then 's global function await.

Users will get compiler errors if they build freshOS/Then with Swift 5.5. Although they still can use Then.await to avoid naming conflict, but it's not very convenient.

• Changes
  • Rename await to awaitPromise.
    • Just FYI: Google's Promise also done this before: https://github.com/google/promises/commit/5d070816f183c8996626fe8ce066253feeb39723
  • Add one await function (which will call awaitPromise actually) with deprecated mark for short term back-port supports.

All unit test cases passed on my machine, with Xcode 13 Beta 3.

Hello, I have an issue with the whenAll feature.

The promises are executed successfully but the then block is never called. here is a code sample:

return Promise { resolve, reject  in
    let asyncMatchers = matchers.filter { $0.asyncMatch }
    var promises = [Promise<MatchResult>]()
    for matcher in asyncMatchers {
        promises.append(matcher.matchTermsAsync(from: phraseComponents))
    } 
    Promises.whenAll(promises).then { results in
        resolve(results)
    }
}

As walk arround I managed to make it work like this:

return Promise { resolve, reject  in
    let asyncMatchers = matchers.filter { $0.asyncMatch }
    async {
        for matcher in asyncMatchers {
               let matchResults = try await(matcher.matchTermsAsync(from: phraseComponents))
               results.append(contentsOf: matchResults)
         }
    }.then {
         resolve(results)
    }
}

Can you see any obvious reason why the .then block in never invoked? Does whenAll support concurrent execution for the promises?

Thank you.

I've found an instance where I can produce a memory leak when using a Promise from within a new Promise:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        noleaky().finally {

        }

        leaky().finally {
            
        }
    }

    func leaky() -> Promise<Void> {
        return Promise { [unowned self] resolve, reject in
            self.doSomething(for: 0)
                .then(self.doSomething)
                .onError(reject)
                .finally(resolve)
        }
    }

    func noleaky() -> Promise<Void> {
        return doSomething(for: 0)
            .then(doSomething)
            .then(Promise.resolve())
    }

    func doSomething(for blah: Int) -> Promise<Int> {
        return Promise.resolve(3)
    }

}

I'm not sure if this is expected or not? Sample project is attached. ThenLeakExample.zip

Cloning the library takes a long while. Receiving objects downloads 359MB and Resolving deltas is very long.

git clone https://github.com/freshOS/then.git
Cloning into 'then'...
remote: Counting objects: 897792, done.
remote: Total 897792 (delta 0), reused 0 (delta 0), pack-reused 897792
Receiving objects: 100% (897792/897792), `359.35 MiB` | 32.12 MiB/s, done.
Resolving deltas:  59% (234493/391788)  

This is a corner case but could be interesting support it. When we have 3 promises encapsulating synchronous code, if we try to chain all of them, the chaining is not working properly.

func promiseA() -> Promise<Int> { 
    return Promise { resolve, reject in 
        print("Promise A")
        resolve(result: 1) 
    } 
}

func promiseB() -> Promise<Int> {
    return Promise { resolve, reject in
        print("Promise B")
        resolve(result: 2)
    }
}

func promiseC() -> Promise<Int> {
    return Promise { resolve, reject in
        print("Promise C")
        resolve(result: 3)
    }
}

If we chain all of them, A and B are executed but C doesn't it:

promiseA().then(promiseB()).then(promiseC())

I think the problem in this case is in the method:

    public func then<X>(p:Promise<X>) -> Promise<X>{
        p.isFirstPromise = false
        successBlock = { t in p.start() }
        startPromiseIfNeeded()
        return p
    }

When then is executed over promiseA, is defined the successBlock and startPromiseIfNeeded provokes promiseA starts, at the end of promiseA the successBlock is executed and promiseB starts although as all the code is synchronous promiseA and promiseB are executed in the same cycle while promiseB still doesn't have a successBlock assigned to execute promiseC. So when then is executed over promiseB, this is already started and fulfilled, startPromiseIfNeeded never calls start.

I think a possible solution would be the next code although I'm not completely confident about it

    public func then<X>(p:Promise<X>) -> Promise<X>{
        p.isFirstPromise = false
        if state == .Fulfilled {
            p.start()
        } else {
            successBlock = { t in p.start() }
            startPromiseIfNeeded()
        }
        return p
    }

Really this is a corner case, because per definition a Promise encapsulates some asynchronous operation and in this situation we are encapsulating synchronous operations, but could be interesting because some times we need to simulate the results of async operations inside Promises.

Enable to .recover() a failed Promise with a default value or another Promise

Promise<Int>.reject()
  .recover(with: 12)
  .then { s in
    // s == 12
  }

Promise<String>.reject()
  .recover { e in
    return Promise.resolve("NeverMind")
  }.then { s in
  // s == NeverMind
  }

Hi all,

Like PromiseKit wrapping delegates example on CLLocationManager, I try to do the same with freshOS/then.

https://github.com/mxcl/PromiseKit/blob/master/Documentation/CommonPatterns.md#wrapping-delegate-systems

The promise is working with:

LocatorManager.shared.getLocation()
            .timeout(0.5)
            .then { location in
                print("then" + String(data: try! JSONEncoder().encode(location), encoding: .utf8)!)
            }.onError { error in
                print(error)
        }

but not with await, my app is blocked. An idea..?

Thank a lot for helping.

do {
            let location = try await(LocatorManager.shared.getLocation().timeout(0.2))
            print("await" + String(data: try! JSONEncoder().encode(location), encoding: .utf8)!)
            
        } catch {
            print(error)
        }

All LocatorManager singleton class code

import Foundation
import CoreLocation

public class LocatorManager: NSObject, CLLocationManagerDelegate {
    static let shared = LocatorManager()
    private let locationManager = CLLocationManager()
    private var promise = Promise<DeviceLocation>()
    
    override private init() {
        super.init()
        locationManager.delegate = self
        locationManager.requestWhenInUseAuthorization()
    }
    
    func getLocation() -> Promise<DeviceLocation> {
        self.promise = Promise<DeviceLocation> { _, reject, _ in
            if !CLLocationManager.locationServicesEnabled() {
                reject(LocatorError.locationServiceDisabled)
                return
            }
            
            if CLLocationManager.authorizationStatus() == .authorizedWhenInUse ||
                CLLocationManager.authorizationStatus() == .authorizedAlways {
                    self.locationManager.requestLocation()                
            } else {
                reject(LocatorError.noUserAuthorization)
            }
        }
        
        return self.promise
    }
    
    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        let deviceLocation = DeviceLocation(latitude: locations.last!.coordinate.latitude,
                                            longitude: locations.last!.coordinate.longitude)
        self.promise.fulfill(deviceLocation)
    }
    
    public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        self.promise.reject(error)
    }
}

public enum LocatorError: Error {
    case locationServiceDisabled
    case noUserAuthorization
}

Sorry, I probably should've opened this issue before the PR. I'm mostly pasting the info from #51 here so that we can discuss these better. I've begun working on integrating the changes necessary to allow compilation of the project on Xcode 10.2 using its Swift 5 toolchain.

All tests are currently passing, but I've had to relax the timings on some of them from 0.3 to 0.5 seconds in order to run successfully on simulators. Is that a problem?

Some changes, such as the ones made to Promise will be breaking the current API, as the compiler can't (any longer?) disambiguate the types on its own. I'm open to ideas on these solutions!

Thanks!

Hi all

In order to run my project in Apple Silicon I had to exclude the arch arm64. But I'm getting this error, could you add support to this please?

Could not find module 'Then' for target 'x86_64-apple-ios-simulator'; found: arm64-apple-ios-simulator, at: /Users/.../.../Developer/Xcode/DerivedData/..../Build/Products/Debug-iphonesimulator/Then.swiftmodule

To reproduce it:

In M1 - Apple Silicon Mac:

1. -Create new project
2. Instal Swift package Then 6.0.0
3. In build settings add excluded Architecture for Any iOS simulator SDK = arm64

Hi, we are using Then together with Vapor for a swift server side project. While doing some performance tests, we noticed that our current implementation is not able to support more than 64 concurrent requests without collapsing and being stuck in what it seems to be a deadlock.

For each request, we are always creating an async block and inside we'll be calling multiple async methods with await.

I've been able to reproduce the same issue using one of your tests. Our methods for each requests are similar to the testAsyncAwaitChainWorks one in AsyncAwaitTests class. If you modify that method to do the same code 100 times, it will look like this:

func testAsyncAwaitChainWorks() {
  for _ in 0..<100 {
    let exp = expectation(description: "")
    print("starting new task")
    async {
      print("starting async block")
      let userId = try await(fetchUserId())
      XCTAssertEqual(userId, 1234)
      let userName = try await(fetchUserNameFromId(userId))
      XCTAssertEqual(userName, "John Smith")
      let isFollowed = try await(fetchUserFollowStatusFromName(userName))
      XCTAssertFalse(isFollowed)
      exp.fulfill()
      print("finishing async block")
    }
  }
  waitForExpectations(timeout: 1000.0, handler: nil)
}

Executing this will print 100 times starting new task, but it will only print 64 times starting async block and finishing async block will not be printed at all, the execution will never finished.

Is there any way of avoiding this kind of issues and being able to use async/await approach while supporting a lot of concurrent requests?

Hi!

I saw that Cocoapods is deprecated now, I would like to suggest adding support again since it doesn't change the way to develop for SPM as well.

The library is a very useful library and Cocoapods still in use for a huge number of projects out there, would be nice to keep using this the way it is.

Thanks.

This function is really useful but was set as internal. I propose set as public so everyone can use this.

Use case:

• You keep the promise in a property or array and need to update the progress via delegate (e.g.: URLSessionTaskDelegate)

Hi, I'm a stranger who started using this library. I appreciate your effort for this! This PR is related to issue #50 to let you guys know about what I found. I'm using tag 4.2.1. I tried deleting tryStartInitialPromiseAndStartIfneeded() from progress(block) function because otherwise progress(float) in Promise may be called before registering the block passed from the progress function. I hope this helps. Thanks for reading!

Currently, this library can only return Float value when using .progress directive. However, Alamofire and other network libraries return Progress instance instead of Float.

I think thenPromise should be able to return Progress instance on .progress directive. For example:

return Promise<URL> { resolve, reject, progress in
    Alamofire.download(escapedUrl, to: destination)
        .downloadProgress { downloadProgress in // downloadProgress is Progress class
            // let currentProgress = Float(downloadProgress.completedUnitCount) / Float(downloadProgress.totalUnitCount)
            // progress(currentProgress)
            progress(downloadProgress) // <- should be able to write like this
        }
        .response { response in
            ...
        }
}