erica

import PlaygroundSupport
import SwiftUI

extension View {
  public func offset(by offset: CGPoint) -> Self.Modified<_OffsetEffect> {
    self.offset(x: offset.x, y: offset.y)
  }
}

struct LiveView : View {

JohnSundell

#!/usr/bin/env bash

# Put this file in /usr/local/bin and then run chmod +x on it to make it executable

command=$1
shift

case $command in
    "init" )
        swift package init "$@"

gonzalezreal

import Foundation

struct ImageAttachment: Codable {
    let url: URL
    let width: Int
    let height: Int
}

struct AudioAttachment: Codable {
    let title: String

damienlaughton

//
//  UIAccessorizedTextField.swift
//  AccessorizedTextField
//
//  Created by Damien Laughton on 28/03/2018.
//  2018 Mobilology Limited. No rights reserved.
//

import Foundation
import UIKit

SpacyRicochet

import UIKit
import PlaygroundSupport

public extension UIColor {
    public func hsba() -> (hue: CGFloat, saturation: CGFloat, brightness: CGFloat, alpha: CGFloat)? {
        var hue: CGFloat = .nan, saturation: CGFloat = .nan, brightness: CGFloat = .nan, alpha: CGFloat = .nan
        guard self.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha) else {
            return nil
        }
        return (hue: hue, saturation: saturation, brightness: brightness, alpha: alpha)

erica

import UIKit
import PlaygroundSupport
// https://gist.github.com/erica/6f13f3043a330359c035e7660f3fe7f5
// Original Video: https://www.youtube.com/watch?v=TTmWUSgNOHk
// Video: https://www.youtube.com/watch?v=hmAB3WJOQTU
// Video: https://www.youtube.com/watch?v=DWtavuvmKdw (with zoom and fade)

// String to animate and its attributes
var string = "Hello, playground"
let attributes: [String: Any] = [

andymatuschak

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

beccadax

let color = "blue"
let num = 42

localized("Colorless green ideas sleep furiously.")
localized("Colorless \(color) ideas sleep furiously.")
localized("\(num.formatted("%05d")) colorless green ideas sleep furiously.")

phatak-dev

#Compilng You need g++ 4.9 to compile this code. Follow these steps to install g++-4.9

After installing run the following command to compile

/usr/bin/g++-4.9 -std=c++11 lambda.cpp

#Running

./a.out

steipete

BOOL PSPDFSystemFunctionOverriddenInCategory(Class theClass, SEL selector, NSString *__autoreleasing* categoryName) {
    NSCParameterAssert(theClass);
    NSCParameterAssert(selector);

    Dl_info info;
    if (dladdr(class_getMethodImplementation(theClass, selector), &info)) {
        // /System/Library/Frameworks is a common denominator, some methods are in /usr/lib/libobjc.A.dylib
        // Custom app is in /private/var/mobile/Containers/Bundle/Application/<UID>/PSPDFCatalog.app/PSPDFCatalog
        if (!strstr(info.dli_fname, "/System/Library") && !strstr(info.dli_fname, "/usr/lib")) {
            if (categoryName) *categoryName = @(info.dli_sname);