Applications face intrinsic memory and processing costs. Every object creation and every calculation adds to these costs. Using lazy initializers enables you to optimize performance by delaying expensive operations until they’re absolutely needed.

An object may never get around to using some property during its lifetime. By deferring creation you entirely save that cost. Or, consider a case where initialization is expensive. If you you spread out that cost over time, you have a lower peak demand across the app.

Lazy initializers move operations away from object creation to some point in the future. In Swift, you mark items with the @lazy attribute. This says “don’t perform this initialization until the property is explicitly requested”.

With playgrounds, you can see this attribute in action. In the following example, the lazyProperty does not exist until accessing the description property forces its creation. Once created, the property remains for the object lifetime but it’s also entirely possible for the object to never instantiate that property.

QuickLook is Apple’s embedded quick preview feature. It was first introduced in OS X Leopard back around 2007 or so. Since that time, the concept has broadened. Implementations now appear in iOS and have been added to the latest version of the Xcode IDE.

In Swift playgrounds, QuickLook provides small eye icons in the execution results gutter to the right of the code you enter. When you see an eye, you can tap on it to view a preview of the result that has been generated.

Although Xcode will QuickLook class components, it doesn’t provide direct, custom approach for the class as a whole. Each element is listed, and any inspections of those elements is passed along to embedded inspectors.

What you get generally looks something like this:

Even when what you really want is more like this:

Fortunately, Xcode and Swift enable you to build your own QuickLook class previews, albeit with limits. To support QL, your class must derive from NSObject. If you don’t explicitly descend from NSObject, throw an @objc annotation in there to provide compatibility, as in the following example.

@objc class BezierCircle {
    var color : UIColor
    var path : UIBezierPath
    var radius : Double
    init (_ radius : Double, _ color : UIColor = UIColor.redColor())
    {
        path = UIBezierPath(ovalInRect: CGRectMake(0, 0, 2*radius, 2*radius))
        self.radius = radius
        self.color = color
    }

By implementing debugQuickLookObject() in your class, you provide the object that Xcode displays in response to eye-icon clicks. For this Bezier circle example, I built an image using the internal path and color:

func debugQuickLookObject() -> AnyObject? {
    UIGraphicsBeginImageContext(CGSizeMake(radius * 2.0, radius * 2.0))
    color.set(); path.fill()
    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return image
}

As you see in the above image, the gutter text reflects the returned object, in this case a 100×100 image.  If you want to add more information, draw it into the image. You cannot return a tuple with this approach, and your QL return type must conform to the following classes. If you return a custom class other than these, the QuickLook behavior reverts to the default. If your QL object needs to be a tuple of some sort, consider adding a computed property instead.

enum QuickLookObject {
  case Text(String)
  case Int(Int64)
  case UInt(UInt64)
  case Float(Double)
  case Image(Any)
  case Sound(Any)
  case Color(Any)
  case BezierPath(Any)
  case AttributedString(Any)
  case Rectangle(Double, Double, Double, Double)
  case Point(Double, Double)
  case Size(Double, Double)
  case Logical(Bool)
  case Range(UInt64, UInt64)
  case View(Any)
  case Sprite(Any)
  case URL(String)
  case _Raw(UInt8[], String)
}

Yesterday, I stumbled across this write-up by Mikael Konutgan courtesy of a bit of mistaken attribution. It shows you how to implement custom type conversions, enabling you to bridge Swift classes and functions to structs and non-standard classes. This is helpful information for anyone who has struggled with error messages that state some item “is not convertible” to another type.

What caught my eye was tuples-on-demand. With this, you could use tuple assignment to access struct fields in parallel, as in this example:

var myCGRect = CGRectMake(0, 0, 50, 100)
let (_, _, w, h) = myCGRect

This is not built-in behavior. This derives from implementing the following extension. The __conversion() function enables you to convert from the Core Graphics rectangle structure to a Swift-style 4-tuple.

extension CGRect {
    func __conversion() -> (Double, Double, Double, Double) {
        return (self.origin.x, self.origin.y, self.size.width, self.size.height)
    }
}

Even better, you can overload the conversion and allow type inference to determine the return-tuple style you’re looking for:

extension CGRect {
    func __conversion() -> (Double, Double, Double, Double) {
        return (self.origin.x, self.origin.y, self.size.width, self.size.height)
    }
    func __conversion() -> (Double, Double) {
        return (self.size.width, self.size.height)
    }
}

Although Konutgan’s main point is discussing how you can use this approach to connect Swift classes and structures to Cocoa/Touch equivalents, it’s this flexible conversion that really stood out to me. I should add that the built-in conversion items use the @conversion keyword (thanks SH) but that extra notation does not seem to be strictly necessary in my testing.

There are any number of built-in conversion functions that you can inspect using Command-Click.

Finally? This is not the material you thought you were googling for.

Here’s code. Please test if you have a chance. It’s still very young.

For your random pleasure. Have fun improving these!

let arc4RandomMax = Double(0x100000000)
func Random01() -> Double
{
    var randDouble = Double(arc4random())
    return randDouble / arc4RandomMax
}

func RandomInteger(max : UInt32) -> Int
{
    return Int(arc4random_uniform(max))
}

The always wonderful John Holdsworth has put together a replacement ivar_getTypeEncoding() written for Swift classes as part of his XprobePlugin pack. He tells me this is under an MIT license. Update: John asks me to change that to public domain.

/*****************************************************
 ********* ivar_getTypeEncoding() for swift **********
 *****************************************************/

struct _swift_class;

struct _swift_type {
    unsigned long flags;
    const char *typeIdent;
};

struct _swift_field {
    unsigned long flags;
    union {
        struct _swift_type *typeInfo;
        Class objcClass;
    };
    void *unknown;
    struct _swift_field *conditional;
    union {
        struct _swift_class *swiftClass;
        struct _swift_field *subType;
    };
    struct _swift_field *extraType;
};

struct _swift_data {
    unsigned long flags;
    const char *className;
    int fieldcount, flasg2;
    const char *ivarNames;
    struct _swift_field **(*get_field_data)();
};

struct _swift_class {
    union {
        Class meta;
        unsigned long flags;
    };
    Class supr;
    void *buckets, *vtable, *pdata;
    int size, tos, mds, eight;
    struct _swift_data *swiftData;
};

static const char *typeInfoForName( const char *name ) {
    return strdup([[NSString stringWithFormat:@"@\"%s\"", name] UTF8String]);
}

static const char *typeInfoForClass( Class aClass ) {
    return typeInfoForName( class_getName(aClass) );
}

static const char *ivar_getTypeEncodingSwift( Ivar ivar, Class aClass ) {
    struct _swift_class *swiftClass = (__bridge struct _swift_class *)aClass;
    if ( !((unsigned long)swiftClass->pdata & 0x1) )
        return ivar_getTypeEncoding( ivar );

    struct _swift_data *swiftData = swiftClass->swiftData;
    const char *nameptr = swiftData->ivarNames;
    const char *name = ivar_getName(ivar);
    int ivarIndex;

    for ( ivarIndex=0 ; ivarIndexfieldcount ; ivarIndex++ )
        if ( strcmp(name,nameptr) == 0 )
            break;
        else
            nameptr += strlen(nameptr)+1;

    if ( ivarIndex == swiftData->fieldcount )
        return NULL;

    struct _swift_field **swiftFields = swiftData->get_field_data();
    struct _swift_field *field = swiftFields[ivarIndex];
    struct _swift_class *ivarClass = field->swiftClass;

    // this could probably be tidied up if I knew what was going on...
    if ( field->flags == 0x2 && (field->conditional->flags > 0x2 || (ivarClass && ivarClass->flags>0x2) ) )
        return typeInfoForName(field->typeInfo->typeIdent);
    else if ( field->flags == 0xe )
        return typeInfoForClass(field->objcClass);
    else if ( field->conditional && field->conditional->flagsconditional->flags == 0xe )
            return typeInfoForClass(field->conditional->objcClass);
        else
            return field->conditional->typeInfo->typeIdent+1;
    }
    else if ( !ivarClass )
        return field->typeInfo->typeIdent+1;
    else if ( ivarClass->flags == 0x1 )
        return field->subType->typeInfo->typeIdent+1;
    else if ( ivarClass->flags == 0xe )
        return typeInfoForClass(field->subType->objcClass);
    else
        return typeInfoForClass((__bridge Class)ivarClass);
}