Refactor metatypes

Proposal: SE-NNNN
Author: Anton Zhilin
Status: Awaiting review
Review manager: TBD

Introduction

Rename metatypes T.Type to Metatype<T>
Add Type<T> struct that wraps a static type
Make T.self syntax create Type<T>
Move static size, stride, alignment functions to Type<T>
Rename Mirror to DebugRepresentation and CustomReflectable to CustomDebugRepresentable
Add Mirror struct that is intended to replace metatypes for most use cases
Move dynamic size, stride, alignment functions to Mirror

Swift-evolution thread: Discussion thread topic for that proposal

Motivation

The following tasks require metatype-like types:

Explicit specialization of functions and expressing specific static types
Dynamic dispatch of static methods
Representing any value as a tree, for debug purposes
Retrieving and passing around information about dynamic types; reflection

Current state of things:

(1) is given to metatypes T.Type
- Instance of metatype is usually ignored
- For example, if you pass Derived.self as Base.self into function taking T.Type, it will work with Base
- This raises concerns: are metatypes perfectly suited for that purpose?
(2) is also given to metatypes
- Because they are used so often, it's tempting to add useful methods to them, but we can't, because it's not a struct
(3) is given to Mirror
- Does its name reflect what it's intended to do?
- Mirror.DisplayStyle contains optional and set as special cases, but does not contain function
- Mirror collects all information possible at initialization, while for true reflection we want laziness
- Mirror allows customization. For example, Array<T> is represented with a field for each of its elements. Do we want this for "true" reflection we want to add in the future?
(4) is given to both metatypes and Mirror
- Metatypes are generic. But do we want genericity in reflection? No, we almost always want to cast to Any.Type
- Metatypes are used for getting both static and dynamic sizes
- In this context, distinction between generic parameter T and value of metatype instance is unclear
- People are confused that Mirror is intended to be used for full-featured reflection, while it does not aim for that

Proposed solution

`Metatype<T>`

Rename T.Type to Metatype<T>
Remove T.self. Construction of metatypes will look like Type<T>.metatype, see below
Metatypes will be used only for dynamic dispatch of static methods, see example

protocol HasStatic   { static func staticMethod() -> String }
struct A : HasStatic { static func staticMethod() -> String { return "A" } }
struct B : HasStatic { static func staticMethod() -> String { return "B" } }

func callStatic(_ metatype: Metatype<HasStatic>) {
    let result = metatype.staticMethod()   
    print(result)
}

let a = Type<A>.metatype
let b = Type<B>.metatype
callStatic(a)  //=> A
callStatic(b)  //=> B

dynamicType will be renamed to dynamicMetatype:

func dynamicMetatype<T>(_ instance: T) -> Metatype<T>

`Type<T>`

T.self will be repurposed to return Type<T> that is declared as follows:

struct Type<T> : Hashable, CustomStringConvertible, CustomDebugStringConvertible {

  // Type<T> is equivalent to (), but parametrized with type T
  init()
  
  static var size: Int { get }
  static var stride: Int { get }
  static var alignment: Int { get }
  static var metatype: Metatype<T> { get }
  
  // Equivalent to static versions
  var size: Int { get }
  var stride: Int { get }
  var alignment: Int { get }
  var metatype: Metatype<T> { get }
  
  // Implementation of protocols
  var hashValue: Int { get }
  var description: String { get }
  var debugDescription: String { get }
}

Size of Type<T> struct equals 0. It will be used for generic function specialization:

func performWithType(_ type: Type<T>)
performWithType(Float.self)

`Mirror`

Rename current Mirror to DebugRepresentation and CustomReflectable to CustomDebugRepresentable.

A completely different type with name Mirror will be introduced.

Mirror wraps metatypes and replaces usage of metatypes with as?, is, etc. Mirror contains dynamic versions of size, stride and alignment. Size of Mirror is 8 bytes. Mirror provides a starting point for adding fully functional reflection in the future.

struct Mirror : Hashable, CustomStringConvertible, CustomDebugStringConvertible {
  
  /// Create mirror, reflecting type, which is reflected by a metatype
  init(_: Metatype<Any>)
  
  /// Create mirror, reflecting type T
  init<T>(_: Type<T>)
  
  /// Create mirror, reflecting dynamic type of a given instance
  init<T>(reflecting: T)
  
  var size: Int { get }
  var stride: Int { get }
  var alignment: Int { get }
  var metatype: Metatype<Any> { get }
  
  var hashValue: Int { get }
  var description: String { get }
  var debugDescription: String { get }
  
  /// Checks if type reflected by `self` is a subtype of type reflected by another `Mirror`.
  func `is`(_ mirror: Mirror) -> Bool
  
  /// Checks if type reflected by `self` is a subtype of `T`.
  func `is`<T>(_ type: Type<T>) -> Bool
  
  /// Checks if type reflected by `self` is a subtype of type reflected by a metatype.
  func `is`<T>(_ metatype: Metatype<T>) -> Bool
}

Summary of metatype-like types

Before

T.Type does 3 things:
- Specialization of functions
- Dynamic dispatch of static methods
- Partial reflection using as, is and functions like sizeofValue
Mirror does 2 things:
- It is primarily indented for use in debugging, like PlaygroundQuickLook
- With less success, it can be used for reflection

After

Type<T> does specialization of functions
Mirror does reflection
Metatype<T> does dynamic dispatch of static methods
DebugRepresentation is used in debugging

Impact on existing code

Changes are source-breaking, automatic migration is possible.

T.Type → Metatype<T>
T.self → Type<T>.metatype
Mirror → DebugRepresentation
CustomReflectable → CustomDebugRepresentable
- customMirror → customDebugRepresentation
sizeof(T.self) → Type<T>.size
sizeof(metatype) → Mirror(metatype).size

Migrating metatype variables to use `Type<T>` and `Mirror`

Metatype<T> is a safe default for transition, but we want to discourage usage of metatypes. In some cases, we can provide fix-its to replace usage of Metatype<T> with Type<T> or Mirror.

To change type of a variable named type from Metatype<T> to Type<T>:

Replace its type with Type<T>
Use the migration patterns below
If some use case does not match any of these, the variable cannot be migrated to type Type<T>

Migration patterns:

type = T.self.metatype → type = T.self
type = U.self.metatype where U != T → Automatic migration impossible
type = Type<T>.metatype → type = T.self
type = Type.metatype where U != T → Automatic migration impossible
type = otherMetatype where otherMetatype: Metatype<T> → type = T.self
type = otherMetatype where otherMetatype: Metatype, U != T → Automatic migration impossible
type = mirror.metatype where mirror: Mirror → Automatic migration impossible
otherMetatype = type where otherMetatype: Metatype → otherMetatype = Type<T>.metatype
Mirror(type) → Mirror(type)
type as otherMetatype where otherMetatype: Metatype → type.metatype as metatype
type as? otherMetatype → Automatic migration impossible
type as! otherMetatype → Automatic migration impossible
type is otherMetatype → Automatic migration impossible

How to change type of a variable named type from Metatype<T> to Mirror:

Replace its type with Mirror
Use the migration patterns below
If some use case does not match any of these, the variable cannot be migrated to type Mirror

Migration patterns:

type: Metatype<T> → type: Mirror
type = U.self.metatype → type = Mirror(U.self)
type = Type.metatype → type = Mirror(U.self)
type = otherMetatype → type = Mirror(otherMetatype)
type = mirror.metatype where mirror: Mirror → type = mirror
otherMetatype = type → otherMetatype = type.metatype
Mirror(type) → type
type as otherMetatype → type.metatype as! otherMetatype
type as? otherMetatype → type.metatype as? otherMetatype
type as! otherMetatype → type.metatype as! otherMetatype
type is otherMetatype → type.is(otherMetatype)

We can also migrate metatype parameters of a function, where assignment means passing an argument to that function.

In two cases we will apply these transitions automatically:

If a generic function takes parameter Metatype<T>, then we can try to replace Metatype<T> with Type<T>
We can try to replace usage of Metatype<Any> (aka AnyMetatype) with Mirror

Standard library

Besides dynamicMetatype, the following global functions will be affected:

func transcode<Input, InputEncoding, OutputEncoding>(
    _: Input,
    from: Type<InputEncoding>,
    to: Type<OutputEncoding>,
    stoppingOnError: Bool,
    sendingOutputTo: @noescape (OutputEncoding.CodeUnit) -> Swift.Void
) where Input : IteratorProtocol, InputEncoding : UnicodeCodec,
        OutputEncoding : UnicodeCodec, InputEncoding.CodeUnit == Input.Element

func unsafeBitCast<T, U>(_: T, to: Type<U>)

func unsafeDowncast<T : AnyObject>(_: AnyObject, to: Type<T>)

Other standard library functions that took T.Type will most likely take Type<T>.

Future directions

Remove `self`

We can replace T.self notation with type literals T. Examples:

unsafeBitCast(1.0, to: Int)
let dynamicSize = Mirror(reflecting: something).size

Then we can add Type(_: Type<T>) initializer for disambiguation:

Int.self.size     // works with this proposal, but what if we drop `.self`?
Int.size          // will be error after dropping `.self`
Type<Int>().size  // works, but looks worse
Type(Int).size    // looks much better

When combined with this proposal, the result will be to eliminate all "magical" members that existed in the language: dynamicType, Type and self. There is also Self, but it acts like an associatedtype.

Extend reflection with `Mirror`

Reflection is one of stated goals for Swift 4. With this proposal, adding reflection becomes as simple as extending Mirror. For example, we can add the following computed property:

typealias FieldDescriptor = (name: String, type: Mirror, getter: (Any) -> Any, setter: (inout Any, Any) -> ())
var fields: [FieldDescriptor] { get }

Anton3/NNNN-refactor-metatypes.md

Refactor metatypes

Introduction

Motivation

Proposed solution

`Metatype<T>`

`Type<T>`

`Mirror`

Summary of metatype-like types

Before

After

Impact on existing code

Migrating metatype variables to use `Type<T>` and `Mirror`

Standard library

Future directions

Remove `self`

Extend reflection with `Mirror`

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 19, 2016 •

edited

Loading

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 20, 2016

DevAndArtist commented Jul 20, 2016

Anton3/NNNN-refactor-metatypes.md

Refactor metatypes

Introduction

Motivation

Proposed solution

Metatype<T>

Type<T>

Mirror

Summary of metatype-like types

Before

After

Impact on existing code

Migrating metatype variables to use Type<T> and Mirror

Standard library

Future directions

Remove self

Extend reflection with Mirror

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 19, 2016

Anton3 commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 19, 2016 • edited Loading

DevAndArtist commented Jul 19, 2016

DevAndArtist commented Jul 19, 2016

Anton3 commented Jul 20, 2016

DevAndArtist commented Jul 20, 2016

`Metatype<T>`

`Type<T>`

`Mirror`

Migrating metatype variables to use `Type<T>` and `Mirror`

Remove `self`

Extend reflection with `Mirror`

Anton3 commented Jul 19, 2016 •

edited

Loading