Question: I am extending a base class (one which I do not control) in Swift. I want to provide a class function for creating an instance typed to a subclass. A generic function is required. However, an implementation like the one below does not return the expected subclass type. 

```
class Calculator {
    func showKind() { println("regular") }
}

class ScientificCalculator: Calculator {
    let model: String = "HP-15C"
    override func showKind() { println("scientific") }
}

extension Calculator {
    class func create<T:Calculator>() -> T {
        let instance = T()
        return instance
    }
}

let sci: ScientificCalculator = ScientificCalculator.create()
sci.showKind()

```

The debugger reports `T` as `ScientificCalculator`, but `sci` is `Calculator` and calling `sci.showKind()` returns "regular". 

Is there a way to achieve the desired result using generics, or is it a bug?

Answer: 
There is a bug somewhere - I mean, not in your code :)

This is obviously a generic method:

```
class func create<T:Calculator>() -> T

```

`T` is inferred by the type of the variable the return value is assigned to, which in your case is `ScientificCalculator`.

A more interesting case. Let's modify the `create` function such that the type of `T` is made explicit, regardless of the type of the variable the instance is assigned to:

```
class func create<T:Calculator>(type: T.Type) -> T

let sci: ScientificCalculator = ScientificCalculator.create(ScientificCalculator.self)

```

The result is the same.

A more interesting observation: `sci` is a variable of `ScientificCalculator` type, but it points to an instance of `Calculator`. So this code:

```
sci.model

```

compiles, but generates a runtime exception - because there's no `model` property defined in the base class.

This is clearly a compiler bug: an instance of a superclass is assigned to a variable whose type is one of its subclasses - that should never be possible (although the opposite is possible)

Also read my answer to a [similar question](https://stackoverflow.com/a/26223323/148357)
This doesn't explain why your generic approach isn't working. I'm just looking for an alternative.

It seems with Swift that they have replaced factory methods with convenience initializers. You can create a new convenience initializer and add that with an extension to `Calculator`.

```
extension Calculator {
    convenience init(name: String) {
        println(name)
        self.init()
    }
}

let reg = Calculator(name: "Reg")
reg.showKind()  // "regular"

let sci = ScientificCalculator(name: "Sci")
sci.showKind()  // "scientific"

```