rileytestut

import Foundation

// Export running app as .ipa, then return path to exported file.
// Returns String because app crashes when returning URL from async function for some reason...
func exportIPA() async throws -> String
{
    // Path to app bundle
    let bundleURL = Bundle.main.bundleURL
    
    // Create Payload/ directory

swiftui-lab

import SwiftUI
import WebKit
import Combine

class WebViewData: ObservableObject {
    @Published var loading: Bool = false
    @Published var scrollPercent: Float = 0
    @Published var url: URL? = nil
    @Published var urlBar: String = "https://nasa.gov"
    

taradinoc

$.lang.register('retrorole.usage', 'Usage: !retrorole <channel> <msg-id> <emoji> <role>');
$.lang.register('retrorole.added', 'Added role "$1" to $2 user(s) ($3 failed).');
$.lang.register('retrorole.err.channel', 'Cannot find channel "$1".');
$.lang.register('retrorole.err.message', 'Cannot find message "$1" in that channel.');
$.lang.register('retrorole.err.role', 'Cannot find role "$1".');

mjm

import SwiftUI

private let linkDetector = try! NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)

struct LinkColoredText: View {
    enum Component {
        case text(String)
        case link(String, URL)
    }

chriseidhof

final class Loader: BindableObject {
    let didChange = PassthroughSubject<Data?, Never>()
    var task: URLSessionDataTask!
    var data: Data? = nil {
        didSet {
            didChange.send(data)
        }
    }
    
    init(_ url: URL) {

nicklockwood

/// Withable is a simple protocol to make constructing
/// and modifying objects with multiple properties
/// more pleasant (functional, chainable, point-free)
public protocol Withable {
  init()
}

public extension Withable {
  /// Construct a new instance, setting an arbitrary subset of properties
  init(with config: (inout Self) -> Void) {

alexruperez

//
//  UIResponder+UserActivity.swift
//

import UIKit
import CoreSpotlight
import MapKit

public extension UIResponder {

gokselkoksal

public class Channel<Value> {
    
    private class Subscription {
        
        weak var object: AnyObject?
        private let notifyBlock: (Value) -> Void
        private let queue: DispatchQueue
        
        var isValid: Bool {
            return object != nil

smileyborg

// UICollectionView Objective-C example

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
        
    NSIndexPath *selectedIndexPath = [[self.collectionView indexPathsForSelectedItems] firstObject];
    if (selectedIndexPath != nil) {
        id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
        if (coordinator != nil) {
            [coordinator animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {

tylermilner

//
// The code snippets below showcase common "problem code" that can take a long time to compile.
// These examples were primarily observed in Swift 2/3 and may no longer be relevant in Swift 4 or higher.
//

/// 1. Array concatenation
// Observed by Robert Gummesson - https://medium.com/@RobertGummesson/regarding-swift-build-time-optimizations-fc92cdd91e31#c75c
// Joining two arrays together with the '+' operator can be expensive to compile.

let someArray = ["a", "b"] + ["c", "d"]