Here’s Meyer’s singleton, a very simple lazily constructed singleton getter: Singleton &Singleton::self() { static Singleton instance; return instance; } This is lazy, and C++11 requires it to be thread-safe. In fact, I believe that at least g++ implements this in a thread-safe manner. So if that’s your target compiler or if you use a compiler … Read more
You could use a @property on the metaclass instead: class MyMetaClass(type): @property def my_data(cls): if getattr(cls, ‘_MY_DATA’, None) is None: my_data = … # costly database call cls._MY_DATA = my_data return cls._MY_DATA class MyClass(metaclass=MyMetaClass): # … This makes my_data an attribute on the class, so the expensive database call is postponed until you try to … Read more
Object initializers outside a constructor (or method) has to refer to static members only. This is because the instance hasn’t been constructed until the constructor is run, hence the fields are not “ready yet” and therefor cannot be referenced. Static fields work because they are initialized before fields. Note that the error isn’t caused by … Read more
lazy vars are only calculated once, the first time you use them. After that, they’re just like a normal variable. This is easy to test in a playground: class LazyExample { var firstName = “John” var lastName = “Smith” lazy var lazyFullName : String = { [unowned self] in return “\(self.firstName) \(self.lastName)” }() } let … Read more
I tried this […] lazy var personalizedGreeting: String = { return self.name }() it seems there are no retain cycles Correct. The reason is that the immediately applied closure {}() is considered @noescape. It does not retain the captured self. For reference: Joe Groff’s tweet.
Basically, you’re asking for synchronized creation of a singleton, without using any synchronization (previously-constructed variables). In general, no, this is not possible. You need something available for synchronization. As for your other question, yes, static variables which can be statically initialized (i.e. no runtime code necessary) are guaranteed to be initialized before other code is … Read more
Here is a quick version of a resettable lazy, it could be more elegant and needs double checked for thread safety, but this is basically the idea. You need something to manage (keep track) of the lazy delegates so you can call for reset, and then things that can be managed and reset. This wraps … Read more
With lazy initialization you crate instance only when its needed and not when the class is loaded. So you escape the unnecessary object creation. That being said there are other things to consider too. In lazy initialization you give a public API to get the instance. In multi-threaded environment it poses challenges to avoid unnecessary … Read more
The difference is in scope of application. The reason for making a collection association lazy is to avoid having it load the collection every time the parent object is loaded if you don’t really need it. If you are lazy-loading a collection normally, but for a particular use, you need to ensure the collection has … Read more
This is the latest scripture from the Xcode 6.3 Beta / Swift 1.2 release notes: let constants have been generalized to no longer require immediate initialization. The new rule is that a let constant must be initialized before use (like a var), and that it may only be initialized: not reassigned or mutated after initialization. … Read more