What's Changed

• Feature/fork merging by @0xLeif in https://github.com/0xLeif/Fork/pull/15
• Promote Array extension to Sequence by @0xLeif in https://github.com/0xLeif/Fork/pull/16

Full Changelog: https://github.com/0xLeif/Fork/compare/1.1.0...1.2.0

What's Changed

• Add Array.asyncCompactMap by @0xLeif in https://github.com/0xLeif/Fork/pull/14

Full Changelog: https://github.com/0xLeif/Fork/compare/1.0.1...1.1.0

What's Changed

• Add async and throwing capability to value closure for Fork by @0xLeif in https://github.com/0xLeif/Fork/pull/12
• Remove await and prefer parallel await using async let for ForkedArray by @0xLeif in https://github.com/0xLeif/Fork/pull/12

Full Changelog: https://github.com/0xLeif/Fork/compare/1.0.0...1.0.1

Fork

Parallelize two or more async functions

What is Fork?

Fork allows for a single input to create two separate async functions that return potentially different outputs. Forks can also merge their two functions into one which returns a single output.

The word "fork" has been used to mean "to divide in branches, go separate ways" as early as the 14th century. In the software environment, the word evokes the fork system call, which causes a running process to split itself into two (almost) identical copies that (typically) diverge to perform different tasks. Source

Why use Fork?

Swift async-await makes it easy to write more complicated asynchronous code, but it can be difficult to parallelize multiple functions.

The Swift Book has the following example for downloading multiple images.

let firstPhoto = await downloadPhoto(named: photoNames[0])
let secondPhoto = await downloadPhoto(named: photoNames[1])
let thirdPhoto = await downloadPhoto(named: photoNames[2])

let photos = [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

Now the code above is still asynchronous, but will only run one function at a time. In the example above, firstPhoto will be set first, then secondPhoto, and finally thirdPhoto.

To run these three async functions in parallel we need to change the code to this following example.

async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

The above code will now download all three photos at the same time. When all the photos have been downloaded it will show the photos.

This is a simple async-await example of running code in parallel in which you might not need to use Fork. More complicated examples though might require async dependencies. For example what if we needed to authenticate with a server; then use the auth token to download the photos while also fetching some data from the database. This is where Fork is useful!

When using Fork, functions will be ran in parallel and higher order forks will also be ran in parallel.

Objects

• Fork: Using a single input create two separate async functions that return LeftOutput and RightOutput.
• ForkedActor: Using a single actor create two separate async functions that are passed the actor.
  • KeyPathActor: A generic Actor that uses KeyPaths to update and set values.
• ForkedArray: Using a single array and a single async function, parallelize the work for each value of the array.

Basic usage

import Fork

Fork Example

let fork = Fork(
    value: 10,
    leftOutput: { $0.isMultiple(of: 2) },
    rightOutput: { "\($0)" }
)
        
let leftOutput = try await fork.left()
let rightOutput = try await fork.right()

XCTAssertEqual(leftOutput, true)
XCTAssertEqual(rightOutput, "10")
        
let mergedFork: () async throws -> String = fork.merge(
    using: { bool, string in
        if bool {
            return string + string
        }
            
        return string
    }
)
        
let output = await mergedFork()

XCTAssertEqual(output, "1010")

ForkedActor Example

actor TestActor {
    var value: Int = 0
    
    func increment() {
        value += 1
    }
}

let forkedActor = ForkedActor(
    actor: TestActor(),
    leftOutput: { actor in
        await actor.increment()
    },
    rightOutput: { actor in
        try await actor.fork(
            leftOutput: { await $0.increment() },
            rightOutput: { await $0.increment() }
        )
        .act()
    }
)

let actorValue = await forkedActor.act().value

XCTAssertEqual(actorValue, 3)

ForkedActor KeyPathActor Example

let forkedActor = ForkedActor(
    value: 0,
    leftOutput: { actor in
        await actor.update(to: { $0 + 1 })
    },
    rightOutput: { actor in
        try await actor.fork(
            leftOutput: { actor in
                await actor.update(to: { $0 + 1 })
            },
            rightOutput: { actor in
                await actor.update(\.self, to: { $0 + 1 })
            }
        )
        .act()
    }
)

let actorValue = try await forkedActor.act().value

XCTAssertEqual(actorValue, 3)

ForkedArray Example

A ForkedArray makes it easy to perform an asynchronous function on all of the elements in an Array. ForkedArray helps with the example above.

let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
let photos = try await forkedArray.output()

Extra Examples

Vapor ForkedActor Example

Service Example

let service = Fork(
    value: AppConfiguration(),
    leftOutput: { configuration in
        Fork(
            value: AuthService(configuration),
            leftOutput: { authService in ... },
            rightOutput: { authService in ... }
        )
    },
    rightOutput: { configuration in
        ...
    }
)

let mergedServiceFork: async throws () -> AppServices = service.merge(
    using: { authFork, configurationOutput in
        let services = try await authFork.merged(...)
            
        services.logger.log(configurationOutput)
            
        return services
    }
)

What's Changed

• Added KeyPathActor and Release/1.0.0 by @0xLeif in https://github.com/0xLeif/Fork/pull/11

Full Changelog: https://github.com/0xLeif/Fork/compare/0.7.0...1.0.0

Fork

Parallelize two or more async functions

What is Fork?

Fork allows for a single input to create two separate async functions that return potentially different outputs. Forks can also merge their two functions into one which returns a single output.

The word "fork" has been used to mean "to divide in branches, go separate ways" as early as the 14th century. In the software environment, the word evokes the fork system call, which causes a running process to split itself into two (almost) identical copies that (typically) diverge to perform different tasks. Source

Why use Fork?

Swift async-await makes it easy to write more complicated asynchronous code, but it can be difficult to parallelize multiple functions.

The Swift Book has the following example for downloading multiple images.

let firstPhoto = await downloadPhoto(named: photoNames[0])
let secondPhoto = await downloadPhoto(named: photoNames[1])
let thirdPhoto = await downloadPhoto(named: photoNames[2])

let photos = [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

Now the code above is still asynchronous, but will only run one function at a time. In the example above, firstPhoto will be set first, then secondPhoto, and finally thirdPhoto.

To run these three async functions in parallel we need to change the code to this following example.

async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

The above code will now download all three photos at the same time. When all the photos have been downloaded it will show the photos.

This is a simple async-await example of running code in parallel in which you might not need to use Fork. More complicated examples though might require async dependencies. For example what if we needed to authenticate with a server; then use the auth token to download the photos while also fetching some data from the database. This is where Fork is useful!

When using Fork or ForkedActor, both functions will be ran in parallel. Higher order forks will also be ran in parallel.

Basic usage

import Fork

Fork Example

let fork = Fork(
    value: 10,
    leftOutput: { $0.isMultiple(of: 2) },
    rightOutput: { "\($0)" }
)
        
let leftOutput = try await fork.left()
let rightOutput = try await fork.right()

XCTAssertEqual(leftOutput, true)
XCTAssertEqual(rightOutput, "10")
        
let mergedFork: () async throws -> String = fork.merge(
    using: { bool, string in
        if bool {
            return string + string
        }
            
        return string
    }
)
        
let output = await mergedFork()

XCTAssertEqual(output, "1010")

ForkedActor Example

actor TestActor {
    var value: Int = 0
    
    func increment() {
        value += 1
    }
}

let forkedActor = ForkedActor(
    actor: TestActor(),
    leftOutput: { actor in
        await actor.increment()
    },
    rightOutput: { actor in
        try await actor.fork(
            leftOutput: { await $0.increment() },
            rightOutput: { await $0.increment() }
        )
        .act()
    }
)

let actorValue = await forkedActor.act().value

XCTAssertEqual(actorValue, 3)

ForkedActor KeyPathActor Example

let forkedActor = ForkedActor(
    value: 0,
    leftOutput: { actor in
        await actor.update(to: { $0 + 1 })
    },
    rightOutput: { actor in
        try await actor.fork(
            leftOutput: { actor in
                await actor.update(to: { $0 + 1 })
            },
            rightOutput: { actor in
                await actor.update(\.self, to: { $0 + 1 })
            }
        )
        .act()
    }
)

let actorValue = try await forkedActor.act().value

XCTAssertEqual(actorValue, 3)

ForkedArray Example

A ForkedArray makes it easy to perform an asynchronous function on all of the elements in an Array. ForkedArray helps with the example above.

let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
let photos = try await forkedArray.output()

Extra Examples

Vapor ForkedActor Example

Service Example

let service = Fork(
    value: AppConfiguration(),
    leftOutput: { configuration in
        Fork(
            value: AuthService(configuration),
            leftOutput: { authService in ... },
            rightOutput: { authService in ... }
        )
    },
    rightOutput: { configuration in
        ...
    }
)

let mergedServiceFork: async throws () -> AppServices = service.merge(
    using: { authFork, configurationOutput in
        let services = try await authFork.merged(...)
            
        services.logger.log(configurationOutput)
            
        return services
    }
)

What's Changed

• Add async map and filter to array by @0xLeif in https://github.com/0xLeif/Fork/pull/10

Full Changelog: https://github.com/0xLeif/Fork/compare/0.6.3...0.7.0

ForkedArray Examples

let photoNames: [String] = ...
func isValidPhoto(named: String) async -> Bool { ... }
func downloadPhoto(named: String) async -> Photo { ... }

ForkedArray init

let forkedArray: ForkedArray<String, Photo> = ForkedArray(
    photoNames,
    filter: isValidPhoto(named:),
    map: downloadPhoto(named:)
)
let photos: [Photo] = try await forkedArray.output()

Array ForkedArray init

let forkedArray = photoNames.fork
    filter: isValidPhoto(named:),
    map: downloadPhoto(named:)
)
let photos: [Photo] = try await forkedArray.output()

Array asyncFilter

let photoNames: [String] = try await photoNames.asyncFilter(isValidPhoto(named:))

Array asyncMap

let photos: [Photo] = try await photoNames.asyncMap(downloadPhoto(named:))

What's Changed

• Added better Task cancellation for ForkedArray in https://github.com/0xLeif/Fork/commit/6fe18c31103371e42f2a0e1c49f4b0da99d70c89

Full Changelog: https://github.com/0xLeif/Fork/compare/0.6.2...0.6.3

What's Changed

• Add Array extension by @0xLeif in https://github.com/0xLeif/Fork/pull/9

Full Changelog: https://github.com/0xLeif/Fork/compare/0.6.1...0.6.2

What's Changed

• Update README.md by @0xLeif in https://github.com/0xLeif/Fork/pull/7
• Forked array cleanup by @0xLeif in https://github.com/0xLeif/Fork/pull/8

Full Changelog: https://github.com/0xLeif/Fork/compare/0.6.0...0.6.1

What's Changed

• Feature/void improvements by @0xLeif in https://github.com/0xLeif/Fork/pull/6

Full Changelog: https://github.com/0xLeif/Fork/compare/0.5.0...0.6.0

What's Changed

• Feature/void by @0xLeif in https://github.com/0xLeif/Fork/pull/5

Full Changelog: https://github.com/0xLeif/Fork/compare/0.4.0...0.5.0

What's Changed

• Feature/array by @0xLeif in https://github.com/0xLeif/Fork/pull/4

Full Changelog: https://github.com/0xLeif/Fork/compare/0.3.0...0.4.0

What's Changed

• Feature/actors by @0xLeif in https://github.com/0xLeif/Fork/pull/2
• Update README and Tests by @0xLeif in https://github.com/0xLeif/Fork/pull/3

Full Changelog: https://github.com/0xLeif/Fork/compare/0.2.0...0.3.0

ForkedActor Example

actor TestActor {
    var value: Int = 0
    
    func increment() {
        value += 1
    }
}

let forkedActor = ForkedActor(
    actor: TestActor(),
    leftOutput: { actor in
        await actor.increment()
    },
    rightOutput: { actor in
        try await actor.fork(
            leftOutput: { await $0.increment() },
            rightOutput: { await $0.increment() }
        )
        .act()
    }
)

try await forkedActor.act()

let actorValue = await forkedActor.actor.value

XCTAssertEqual(actorValue, 3)

What's Changed

• Update merge closure to be async throwing by @0xLeif in https://github.com/0xLeif/Fork/pull/1

Full Changelog: https://github.com/0xLeif/Fork/compare/0.1.0...0.2.0

Fork

Using a single input create two separate async functions

What is Fork?

Fork allows for a single input to create two separate async functions that return potentially different outputs. Forks can also merge their two functions into one which returns a single output.

The word "fork" has been used to mean "to divide in branches, go separate ways" as early as the 14th century. In the software environment, the word evokes the fork system call, which causes a running process to split itself into two (almost) identical copies that (typically) diverge to perform different tasks. Source

Basic usage

import Fork

Basic Example

let fork = Fork(
    value: 10,
    leftOutput: { $0.isMultiple(of: 2) },
    rightOutput: { "\($0)" }
)
        
let leftOutput = try await fork.left()
let rightOutput = try await fork.right()

XCTAssertEqual(leftOutput, true)
XCTAssertEqual(rightOutput, "10")
        
let mergedFork: () async throws -> String = fork.merge(
    using: { bool, string in
        if bool {
            return string + string
        }
            
        return string
    }
)
        
let output = await mergedFork()

XCTAssertEqual(output, "1010")

Service Example

let service = Fork(
    value: AppConfiguration(),
    leftOutput: { configuration in
        Fork(
            value: AuthService(configuration),
            leftOutput: { authService in ... },
            rightOutput: { authService in ... }
        )
    },
    rightOutput: { configuration in
        ...
    }
)

let mergedServiceFork: async throws () -> AppServices = service.merge(
    using: { authFork, configurationOutput in
        guard let services = authFork.merged(...) else { return }
            
        services.logger.log(configurationOutput)
            
        return services
    }
)

Fork

Using a single input create two separate async functions

What is Fork?

Fork allows for a single input to create two separate async functions that return potentially different outputs. Forks can also merge their two functions into one which returns a single output.

The word "fork" has been used to mean "to divide in branches, go separate ways" as early as the 14th century. In the software environment, the word evokes the fork system call, which causes a running process to split itself into two (almost) identical copies that (typically) diverge to perform different tasks. Source

Basic usage

import Fork

Basic Example

let fork = Fork(
    value: 10,
    leftOutput: { $0.isMultiple(of: 2) },
    rightOutput: { "\($0)" }
)
        
let leftOutput = try await fork.left()
let rightOutput = try await fork.right()

XCTAssertEqual(leftOutput, true)
XCTAssertEqual(rightOutput, "10")
        
let mergedFork: () async throws -> String = fork.merge(
    using: { bool, string in
        if bool {
            return string + string
        }
            
        return string
    }
)
        
let output = await mergedFork()

XCTAssertEqual(output, "1010")

Service Example

let service = Fork(
    value: AppConfiguration(),
    leftOutput: { configuration in
        Fork(
            value: AuthService(configuration),
            leftOutput: { authService in ... },
            rightOutput: { authService in ... }
        )
    },
    rightOutput: { configuration in
        ...
    }
)

let mergedServiceFork: async throws () -> AppServices = service.merge(
    using: { authFork, configurationOutput in
        guard let services = authFork.merged(...) else { return }
            
        services.logger.log(configurationOutput)
            
        return services
    }
)