swift | The Swift Programming Language | iOS library

by apple C++ Version: swift-5.7.3-RELEASE License: Apache-2.0

kandi X-RAY | swift Summary

swift is a C++ library typically used in Mobile, iOS applications. swift has no bugs, it has a Permissive License and it has medium support. However swift has 1 vulnerabilities. You can download it from GitHub.

The Swift Programming Language

Support

Quality

Security

License

Reuse

kandi-support Support

swift has a medium active ecosystem.
It has 61746 star(s) with 9944 fork(s). There are 2523 watchers for this library.
There were 5 major release(s) in the last 6 months.
There are 5692 open issues and 7601 have been closed. On average issues are closed in 481 days. There are 627 open pull requests and 0 closed requests.
It has a neutral sentiment in the developer community.
The latest version of swift is swift-5.7.3-RELEASE

swift Support

Best in #iOS

Average in #iOS

swift Support

Best in #iOS

Average in #iOS

quality kandi Quality

swift has 0 bugs and 0 code smells.

swift Quality

Best in #iOS

Average in #iOS

swift Quality

Best in #iOS

Average in #iOS

security Security

swift has 1 vulnerability issues reported (0 critical, 0 high, 1 medium, 0 low).
swift code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

swift Security

Best in #iOS

Average in #iOS

swift Security

Best in #iOS

Average in #iOS

license License

swift is licensed under the Apache-2.0 License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

swift License

Best in #iOS

Average in #iOS

swift License

Best in #iOS

Average in #iOS

build Reuse

swift releases are available to install and integrate.
Installation instructions, examples and code snippets are available.
It has 30858 lines of code, 1869 functions and 250 files.
It has medium code complexity. Code complexity directly impacts maintainability of the code.

swift Reuse

Best in #iOS

Average in #iOS

swift Reuse

Best in #iOS

Average in #iOS

Top functions reviewed by kandi - BETA

kandi's functional review helps you automatically verify the functionalities of the libraries and avoid rework.
Currently covering the most popular Java, JavaScript and Python libraries. See a Sample Here

Get all kandi verified functions for this library.

swift Key Features

The Swift Programming Language

swift Examples and Code Snippets

Community Discussions

Trending Discussions on swift

UIButton with custom image still shows titleLabel even though I set it to blank - Swift iOS
Swift Concurrency announced for iOS 13 in Xcode 13.2 - how did they achieve this?
Xcode Playground Failed to launch
What's the library should I import for UTTypeImage, which is the replacement of kUTTypeImage in iOS 15?
Xcode 13 instruments is not a developer tool or in PATH (React native)
How to prevent actor reentrancy resulting in duplicative requests?
Cancelling an async/await Network Request
What are the differences between xcodebuild, xcrun and swift command line tools?
Xcode 13.2 - Adding package hangs on "Preparing to validate"
Xcode 13.2 - Internal error : Missing Package Description Module

Trending Discussions on swift

QUESTION

UIButton with custom image still shows titleLabel even though I set it to blank - Swift iOS

Asked 2022-Mar-18 at 16:53

I'm pretty new to Swift, currently writing an AR game. Seems like my issue is very basic, but I can't figure it out.

I added a button to an AR Scene through the storyboard and linked it to an IBAction function (which works correctly when the button is clicked). I gave the button an image and deleted the Title. See how the button shows up in the storyboard: button in Xcode storyboard without Title

But when I run the app, the button image shows up with a default label (saying "Button") as shown in this image: button in iPhone screenshot WITH label next to the button image

I can't figure out why this label is there and how to remove it. Should I add the button programmatically instead of adding it through the storyboard? Should the button be treated differently because it's an AR app?

I was able to remove the label by adding the same UIButton as an IBOutlet and adding the following line in viewWillAppear:

restartButton.titleLabel?.text = ""

But this feels to me like a workaround and not a real solution. Also, as soon as I click on the button, the label shows up again. I tried to add the same workaround line to the function when the button is clicked, but that didn't help.

I'm sure I'm missing something very simple. Your help would be appreciated.

Thanks!

ANSWER

Answered 2021-Nov-23 at 21:07

When Interface Builder isn't playing nice, I often open the Storyboard file in a text editor (I use Sublime Text) and edit it manually.

I had a similar issue - I had a button with an image, I had deleted the default "Button" title text in IB, which looked fine in Xcode, but when I ran it, the word "Button" was still there. So I found this line using Sublime Text and deleted it there:

<state key="normal" title="Button"/>

After that, it worked correctly.

Source https://stackoverflow.com/questions/69980698

QUESTION

Swift Concurrency announced for iOS 13 in Xcode 13.2 - how did they achieve this?

Asked 2022-Mar-11 at 12:26

Xcode 13.2 Beta release notes features a promise for Swift Concurrency support for iOS 13.

You can now use Swift Concurrency in applications that deploy to macOS 10.15, iOS 13, tvOS 13, and watchOS 6 or newer. This support includes async/await, actors, global actors, structured concurrency, and the task APIs. (70738378)

However, back in Summer 2021 when it first appeared at WWDC it was hard constrained to be run on iOS 15+ only.

My question is: what changed? How did they achieve backwards compatibility? Does it run in any way that is drastically different from the way it would run in iOS 15?

ANSWER

Answered 2021-Oct-28 at 14:06

Back-deploying concurrency to older OS versions bundles a concurrency runtime library along with your app with the support required for this feature, much like Swift used to do with the standard library prior to ABI stability in Swift 5, when Swift could be shipped with the OS.

This bundles parts of the Concurrency portions of the standard library (stable link) along with some additional support and stubs for functionality (stable link).

This bundling isn't necessary when deploying to OS versions new enough to contain these runtime features as part of the OS.

Since the feature on iOS 15+ (and associated OS releases) was stated to require kernel changes (for the new cooperative threading model) which themselves cannot be backported, the implementation of certain features includes shims based on existing functionality which does exist on those OSes, but which might perform a little bit differently, or less efficiently.

You can see this in a few places in Doug Gregor's PR for backporting concurrency — in a few places, checks for SWIFT_CONCURRENCY_BACK_DEPLOYMENT change the implementation where some assumptions no longer hold, or functionality isn't present. For example, the GlobalExecutor can't make assumptions about dispatch_get_global_queue being cooperative (because that threading model doesn't exist on older OSes), so when backporting, it has to create its own queue for use as the global cooperative queue. @objc-based actors also need to have their superclass swizzled, which doesn't need to happen on non-backdeployed runtimes. (Symbols also have to be injected in some places into the backdeploy libs, and certain behaviors have to be stubbed out, but that's a bit less interesting.)

Overall, there isn't comprehensive documentation on the exact differences between backdeploying and not (short of reading all of the code), but it should be safe to assume that the effective behavior of the backdeployed lib will be the same, though potentially at the cost of performance.

Source https://stackoverflow.com/questions/69746388

QUESTION

How to prevent actor reentrancy resulting in duplicative requests?

Asked 2022-Jan-21 at 06:56

In WWDC 2021 video, Protect mutable state with Swift actors, they provide the following code snippet:

actor ImageDownloader {
    private var cache: [URL: Image] = [:]

    func image(from url: URL) async throws -> Image? {
        if let cached = cache[url] {
            return cached
        }

        let image = try await downloadImage(from: url)

        cache[url] = cache[url, default: image]

        return cache[url]
    }

    func downloadImage(from url: URL) async throws -> Image { ... }
}

The issue is that actors offer reentrancy, so cache[url, default: image] reference effectively ensures that even if you performed a duplicative request because of some race, that you at least check the actor’s cache after the continuation, ensuring that you get the same image for the duplicative request.

And in that video, they say:

A better solution would be to avoid redundant downloads entirely. We’ve put that solution in the code associated with this video.

But there is no code associated with that video on the website. So, what is the better solution?

I understand the benefits of actor reentrancy (as discussed in SE-0306). E.g., if downloading four images, one does not want to prohibit reentrancy, losing concurrency of downloads. We would, effectively, like to wait for the result of a duplicative prior request for a particular image if any, and if not, start a new downloadImage.

ANSWER

Answered 2022-Jan-05 at 00:30

The key is to keep a reference to the Task, and if found, await its value.

Perhaps:

actor ImageDownloader {
    private var cache: [URL: Image] = [:]
    private var tasks: [URL: Task<Image, Error>] = [:]

    func image(from url: URL) async throws -> Image {
        if let image = try await tasks[url]?.value {
            print("found request")
            return image
        }

        if let cached = cache[url] {
            print("found cached")
            return cached
        }

        let task = Task {
            try await download(from: url)
        }

        tasks[url] = task
        defer { tasks[url] = nil }

        let image = try await task.value
        cache[url] = image

        return image
    }

    private func download(from url: URL) async throws -> Image {
        let (data, response) = try await URLSession.shared.data(from: url)
        guard
            let response = response as? HTTPURLResponse,
            200 ..< 300 ~= response.statusCode,
            let image = Image(data: data)
        else {
            throw URLError(.badServerResponse)
        }
        return image
    }
}

Source https://stackoverflow.com/questions/70586562

QUESTION

Cancelling an async/await Network Request

Asked 2022-Jan-03 at 22:23

I have a networking layer that currently uses completion handlers to deliver a result on the operation is complete.

As I support a number of iOS versions, I instead extend the network layer within the app to provide support for Combine. I'd like to extend this to now also a support Async/Await but I am struggling to understand how I can achieve this in a way that allows me to cancel requests.

The basic implementation looks like;


protocol HTTPClientTask {
    func cancel()
}

protocol HTTPClient {
    typealias Result = Swift.Result<(data: Data, response: HTTPURLResponse), Error>
    @discardableResult
    func dispatch(_ request: URLRequest, completion: @escaping (Result) -> Void) -> HTTPClientTask
}

final class URLSessionHTTPClient: HTTPClient {
    
    private let session: URLSession
    
    init(session: URLSession) {
        self.session = session
    }
    
    func dispatch(_ request: URLRequest, completion: @escaping (HTTPClient.Result) -> Void) -> HTTPClientTask {
        let task = session.dataTask(with: request) { data, response, error in
            completion(Result {
                if let error = error {
                    throw error
                } else if let data = data, let response = response as? HTTPURLResponse {
                    return (data, response)
                } else {
                    throw UnexpectedValuesRepresentation()
                }
            })
        }
        task.resume()
        return URLSessionTaskWrapper(wrapped: task)
    }
}

private extension URLSessionHTTPClient {
    struct UnexpectedValuesRepresentation: Error {}
    
    struct URLSessionTaskWrapper: HTTPClientTask {
        let wrapped: URLSessionTask
        
        func cancel() {
            wrapped.cancel()
        }
    }
}

It very simply provides an abstraction that allows me to inject a URLSession instance.

By returning HTTPClientTask I can call cancel from a client and end the request.

I extend this in a client app using Combine as follows;

extension HTTPClient {
    typealias Publisher = AnyPublisher<(data: Data, response: HTTPURLResponse), Error>

    func dispatchPublisher(for request: URLRequest) -> Publisher {
        var task: HTTPClientTask?

        return Deferred {
            Future { completion in
                task = self.dispatch(request, completion: completion)
            }
        }
        .handleEvents(receiveCancel: { task?.cancel() })
        .eraseToAnyPublisher()
    }
}

As you can see I now have an interface that supports canceling tasks.

Using async/await however, I am unsure what this should look like, how I can provide a mechanism for canceling requests.

My current attempt is;

extension HTTPClient {
    func dispatch(_ request: URLRequest) async -> HTTPClient.Result {

        let task = Task { () -> (data: Data, response: HTTPURLResponse) in
            return try await withCheckedThrowingContinuation { continuation in
                self.dispatch(request) { result in
                    switch result {
                    case let .success(values): continuation.resume(returning: values)
                    case let .failure(error): continuation.resume(throwing: error)
                    }
                }
            }
        }

        do {
            let output = try await task.value
            return .success(output)
        } catch {
            return .failure(error)
        }
    }
}

However this simply provides the async implementation, I am unable to cancel this.

How should this be handled?

ANSWER

Answered 2021-Oct-10 at 13:42

async/await might not be the proper paradigm if you want cancellation. The reason is that the new structured concurrency support in Swift allows you to write code that looks single-threaded/synchronous, but it fact it's multi-threaded.

Take for example a naive synchronous code:

let data = tryData(contentsOf: fileURL)

If the file is huge, then it might take a lot of time for the operation to finish, and during this time the operation cannot be cancelled, and the caller thread is blocked.

Now, assuming Data exports an async version of the above initializer, you'd write the async version of the code similar to this:

let data = try await Data(contentsOf: fileURL)

For the developer, it's the same coding style, once the operation finishes, they'll either have a data variable to use, or they'll be receiving an error.

In both cases, there's no cancellation built in, as the operation is synchronous from the developer's perspective. The major difference is that the await-ed call doesn't block the caller thread, but on the other hand once the control flow returns it might well be that the code continues executing on a different thread.

Now, if you need support for cancellation, then you'll have to store somewhere some identifiable data that can be used to cancel the operation.

If you'll want to store those identifiers from the caller scope, then you'll need to split your operation in two: initialization, and execution.

Something along the lines of

extension HTTPClient {
    // note that this is not async
    func task(for request: URLRequest) -> HTTPClientTask {
        // ...
    }
}

class HTTPClientTask {
    func dispatch() async -> HTTPClient.Result {
        // ...
    }
}

let task = httpClient.task(for: urlRequest)
self.theTask = task
let result = await task.dispatch()

// somewhere outside the await scope
self.theTask.cancel()

Source https://stackoverflow.com/questions/69506002

QUESTION

What are the differences between xcodebuild, xcrun and swift command line tools?

Asked 2022-Jan-01 at 19:34

We can build and run Swift code/projects from the command line via multiple commands without using Xcode. I have heard of xcodebuild, xcrun and swift used for Xcode development. I do use fastlane but I don't really understand the tools powering it under the hood.

I am an iOS developer who uses a Mac. I develop using Xcode so I haven't used these command-line tools before.

What are the differences between each command? Are there any cases where I'd be better off using one over the other?

ANSWER

Answered 2021-Sep-13 at 17:36

Tl;DR

xcodebuild and xcrun help build Xcode projects in a headless context, for example in CI setups. swift is the Swift REPL and is largely used for Swift on Server apps. As such, we can build apps without knowing about or using the tools regularly in mobile app development. We use xcodebuild and xcrun under the hood interacting with Xcode even though we don't realise it because they're bundled in Xcode's Command Line tools (documentation archive, but still relevant).

fastlane is an example CI tool that automates the build process, certificate signing, and interfacing with App Store Connect, using these tools.

xcodebuild

xcodebuild is part of Xcode's bundled command-line tools package. From the manpages:

build Xcode projects and workspaces

xcodebuild builds one or more targets contained in an Xcode project, or builds a scheme contained in an Xcode workspace or Xcode project.

xcodebuild has lots of options and use cases. The options are equivalent to certain user actions within the Xcode IDE. Example usage:

xcodebuild -workspace MyWorkspace.xcworkspace -scheme MyScheme

Builds the scheme MyScheme in the Xcode workspace MyWorkspace.xcworkspace.

In the command above, we build the workspace without Xcode, using what Xcode runs internally for compilation. Xcode can only be installed on macOS and we have the same limitations for using its command-line tools, including xcodebuild and xcrun.

xcrun

xcrun is another Xcode command-line tool part of Xcode's CLI tools. From the manpages:

run or locate development tools

xcrun provides a means to locate or invoke coexistence- and platform-aware developer tools from the command-line, without requiring users to modify makefiles or otherwise take inconvenient measures to support multiple Xcode toolchains.

xcrun [-sdk SDK] -find <tool_name>

xcrun is also commonly used with Xcode-select to manage multiple Xcode versions on the same machine. Every version of Xcode comes bundled with its own development tools, and we can use xcrun to get the current path to them:

xcrun xcode-select --print-path

swift

swift is the Swift REPL. swift is a command-line tool that includes the Swift toolchain but can also be installed outside of the Xcode bundled tools. swift is different from xcodebuild and xcrun because it is compiled Swift rather than C. swift is not well documented in the MacOS manpages documentation, however, Apple has documented these tools on its blog:

Xcode 6.1 introduces yet another way to experiment with Swift in the form of an interactive Read Eval Print Loop, or REPL.

A REPL is essentially an interactive compilation environment or shell. First, the REPL reads code, then evaluates it, prints, and repeats the process. As you can imagine, there is much less we can develop using a REPL compared to an IDE. However, there are other use cases for Swift than iOS, watchOS, and macOS development.

swift includes the standard library and doesn't include libraries such as Foundation and UIKit. These Swift libraries are almost certainly needed for iOS or macOS development, so we can't develop apps using the swift REPL alone. However, Swift on Server projects regularly use swift to run Swift code on Linux and even Windows machines.

For wider adoption, Apple has made swift available on different Operating Systems where Xcode is not readily available. Swift now also has Docker support and Windows. Docker enables us to run swift on any machine regardless of the underlying OS. swift in these applications serves as a scripting language.

Bonus notes for SoS

swift is used largely for Swift on Server. Swift on Server has great performance for server applications, with a lower memory footprint, fast startup time, and deterministic performance. Although it is not quite as fast as .NET core for some tasks, this is because Swift is much safer with a rigorous type system, garbage collection with ARC, and fewer optimisations for server-specific apps. Many early adopters praise the improved language type system, memory efficiency, and algorithmic performance. In fact, Swift vapor is comparable to Python and Ruby in efficiency for JSON Serialization tasks. Swift is comparable to Java in very few tasks, but this is likely to change as the language and ecosystem grow.

Source https://stackoverflow.com/questions/69030618

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install swift

If you are interested in:. We also have an FAQ that answers common questions.
Contributing fixes and features to the compiler: See our How to Submit Your First Pull Request guide.
Building the compiler as a one-off: See our Getting Started guide.
Building a toolchain as a one-off: Follow the Getting Started guide up until the "Building the project" section. After that, follow the instructions in the Swift Toolchains section below.
Try the suggestions in Troubleshooting build issues. Make sure you are using the correct release of Xcode. If you have changed Xcode versions but still encounter errors that appear to be related to the Xcode version, try passing --clean to build-script. When a new version of Xcode is released, you can update your build without recompiling the entire project by passing --reconfigure to build-script.

Support

Contributions to Swift are welcomed and encouraged! Please see the Contributing to Swift guide. To be a truly great community, Swift.org needs to welcome developers from all walks of life, with different backgrounds, and with a wide range of experience. A diverse and friendly community will have more great ideas, more unique perspectives, and produce more great code. We will work diligently to make the Swift community welcoming to everyone. To give clarity of what is expected of our members, Swift has adopted the code of conduct defined by the Contributor Covenant. This document is used across many open source communities, and we think it articulates our values well. For more, see the Code of Conduct.

Find more information at: