I have revised the entity class and added a component getter that uses Swift generics to eliminate the need for type casting the result. This will lead to more concise code in most cases, and makes it less likely for us to make mistakes when using the engine to build a game.

Previously, components were accessed by passing a `type: String` to the entity’s `get` method. The entity would return an object of type `LGComponent?`, that is, an optional component of no specific type. The result was that we had to access components like this:

var positionComponent = entity.get(LGPosition.type()) as? LGPosition

If we wanted to unwrap it using optional binding in Swift, we still had to cast it:

if let positionComponent = entity.get(LGPosition.type()) as LGPosition
{
	// do stuff
}

What we want instead is to make that more concise, not forcing a developer to repeat himself. Here’s what we want to be able to do to access a component:

var positionComponent = entity.get(LGPosition)

Until recently, I thought that such functionality was either not possible in Swift or (at least) not possible yet. Swift does not allow us to use `Class` as the type of a function parameter, like we might do in Java. We cannot even use Swift’s own Metatype Type, as far as I can tell. However, I found something that does work — using generics and making the parameter of type `T.Type` like this:

func get(type: T.Type) -> T?
{
	return components[type.type()] as? T
}

This is the first time I have been able to make practical use of the Metatype Type, and it works exactly as expected. I have already updated the GitHub repository and all calls to the `get` method have been made more concise. There are still a couple of puzzles I have not been able to solve in Swift:

• Variadic Parameters, as in `get(type: Metatype…)`, will not work with this approach.
• Components still require an explicit `type()` to be defined, because the Swift’s `Metatype` can’t be hashed as a dictionary key like Objective-C’s `id` could.

If you know how to do either of those things, let me know in the comments! Check out the source code and tell me what you think! I am still working through how to implement tile collisions most efficiently without resorting to giving tiles actual physics bodies.