> * 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
* Javascript: Dynamic type (string)
* 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.
--
Brent Royal-Gordon
Architechies
_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
