* What is your evaluation of the proposal?
I think it's a good idea. While the type is in some sense a "property" of the instance, it has always been a bit strange to have it there:
* `dynamicType` acts sort of like an extension of `Any`, but you're not actually allowed to extend `Any`.
* Using property syntax forced the designers to avoid the most obvious name, `type`, because users might want that name for their own purposes.
* Similar "universal" properties, like getting the size of an instance or reflecting it, are exposed as free functions. A fair number of the standard library's free functions could reasonably be exposed as members of `Any` or `AnyObject`, yet `dynamicType` was singled out for this treatment.
I am not convinced, however, by this proposal's argument against renaming to `typeof(_:)`. In a very brief survey of languages with a `typeof` operation (or some extremely similar keyword, like `TypeOf` or `type-of`), I found:
LANGUAGES WITH ONLY STATIC TYPES
* C: Textual substitution (more or less) of static type. (C++ and Objective-C inherit this from C.)
LANGUAGES WITH ONLY DYNAMIC TYPES
* R: Dynamic type (string)
* ActionScript: Dynamic type (string)
* Common Lisp: Dynamic type
LANGUAGES WITH BOTH
* D: Textual substitution (more or less) of static type, like C
* Crystal: Static type
* C#: N/A; used only with type names, in a similar role to `self` in Swift 2's `SomeType.self`
* Go: Dynamic type
* Visual Basic: Dynamic type
* GNU Pascal: Dynamic type
My conclusion is that, for the most part, languages use `typeof` in one of two ways:
1) It is part of their type grammar, where it represents a static type.
2) It is part of their expression grammar, where it represents a dynamic type.
(In Crystal, `typeof` is part of both grammars, and always represents a static type. C# uses it in a weird, idiosyncratic way.)
If Swift were to support category 1, it would almost certainly be considered "compiler magic" and thus be spelled `#typeof`. So I don't think there's much ambiguity in what `typeof(_:)` would mean in Swift.
Given that using it to mean "dynamic type" is highly precedented in other languages, and given that it is much shorter than `dynamicType` and matches an existing pattern in the standard library, I believe we should use the name `typeof` instead of `dynamicType`.
* Is the problem being addressed significant enough to warrant a change to Swift?
Yes. Let's get rid of this compromised weirdness.
* Does this proposal fit well with the feel and direction of Swift?
Yes. We've been clearing out these kinds of cobwebs a lot lately.
* If you have used other languages or libraries with a similar feature, how do you feel that this proposal compares to those?
Most languages where I've used this kind of thing use `class` to return the dynamic type, but this isn't a sensible option in Swift, which has richly-typed instances which aren't classes.
* How much effort did you put into your review? A glance, a quick reading, or an in-depth study?
I wouldn't quite call this review "in-depth", but I put maybe an hour of work into it.