steipete

- (BOOL)textView:(UITextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text {
    // Horrible HACK for bug in UITextView where it won't scroll to the new line after pressing enter in the text view.
    // I feel dirty for having to write this. Buggy at least within iOS 7.0 - 7.1b1.
    if (PSPDFIsUIKitFlatMode() && [text isEqualToString:@"\n"] && range.location == textView.text.length) {
        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC));
        dispatch_after(popTime, dispatch_get_main_queue(), ^{
            CGPoint contentOffset = textView.contentOffset;
            CGFloat fontSize = textView.font.pointSize;
            if (textView.contentSize.height - fontSize > textView.bounds.size.height) {
                contentOffset.y += fontSize + 2.f; // add spacing

simonwhitaker

/*
 * Calling math.h functions like `floor` and `floorf` on CGFloat variables
 * becomes problematic when compiling the same code for both 32-bit and 
 * 64-bit platforms, since CGFloat is double on 64-bit, float on 32-bit. 
 * Hence, if you compile with -Wconversion set, `floorf` will give a warning 
 * on 64-bit, while `floor` gives a warning on 32-bit.
 *
 * Here's a suggested implementation of an architecture-independent `floor` 
 * function, written using plain old function overloading which is enabled 
 * using the `__attribute__((overloadable))` Clang language extension.

soffes

// I wish something like this (with a better name for the keyword):

@missing UILabel *titleLabel {
	UILabel *label = [[UILabel alloc] init];
	return label;
};

// Could turns into this:

@interface ViewController ()

peeblesjs

operator infix --> {}
func --> (instance: Any, key: String) -> Any? {
    let mirror = reflect(instance)
    
    for index in 0 ..< mirror.count {
        let (childKey, childMirror) = mirror[index]
        if childKey == key {
            return childMirror.value
        }
    }

jbrennan

Hello Everyone,

The Swift 3 release is nearing completion, so it is time to look back on the release, learn from what happened, and use it to shape what we (the Swift community) do in the year ahead. Overall, Swift 3 is going to be an absolutely amazing release, and it is impressive how much got done. Thank you to everyone who contributed to making it happen. Instead of diving into a flurry of new proposals immediately, it is important to take stock of where we are, and look at the bigger picture.

Metapoint: this email is ridiculously long and covers multiple topics. Instead of replying to it directly, it is best to start new threads on individual topics that you’d like to discuss. Just tag them with “[Swift 4]” in the subject line.

Swift 3 Retrospective

Every year of Swift’s development has been completely different from the previous one, and I expect Swift 4 to continue this trend. With a goal of learning and improving year over year, here are some observations & retrospective about Swi

max-mapper

Your API does REST, but can it SLEEP?

SLEEP (Syncable Lightweight Event Emitting Persistence) is an emerging standard for distributed data sync using HTTP and JSON. A generalized version of CouchDB's much lauded built-in replication, SLEEP extends the REST architecture to define a way in which databases can offer syncable JSON APIs that foster open data innovation by allowing developers to replicate entire databases over the net.

---

SLEEP comes from the Apache CouchDB project which is now widely known for it's multi-master streaming HTTP + JSON replication. This is possible in part because of the CouchDB _changes feed, which is a particular API that lets you see if there have been any changes made to the database since last time you synchronized. CouchDB can efficiently implement the _changes feed because of one subtle difference between it and most other databases: it stores a history of all changes that happen to the database, including deletes.

If you synchronize data from a remote source and then the

pyrtsa

// Hello, fellow Swift programmer!
//
// Here's a demonstration of a few ways of cleaning up the unwrapping of
// optionals in Swift.
//
// Swift is known to have both OO and functional background. Thus, there is
// probably some middle ground programming style that is *more* functional than
// Objective-C, and probably less so than Haskell. This playground tries to
// compare their differences in the pretty common scenario of dealing with
// errors or missing input.

tomlokhorst

func unwrap<T1, T2>(optional1: T1?, optional2: T2?) -> (T1, T2)? {
  switch (optional1, optional2) {
    case let (.Some(value1), .Some(value2)):
      return (value1, value2)
    default:
      return nil
  }
}

func unwrap<T1, T2, T3>(optional1: T1?, optional2: T2?, optional3: T3?) -> (T1, T2, T3)? {

tonyarnold

#if DEBUG
/**
 Toggles assertion of Core Data managed object contexts. Only available when DEBUG is defined.

 When enabled, your application will throw an exception when accessing or modifying entities in a context other than their own.
 */
void TCBToggleAssertingContextQueues();
#endif

bstahlhood

//
//  UIImage+Retina4.h
//  StunOMatic
//
//  Created by Benjamin Stahlhood on 9/12/12.
//  Copyright (c) 2012 DS Media Labs. All rights reserved.
//

#import <UIKit/UIKit.h>