[swift-evolution] Fw: Re: Proposal: CustomConvertible protocol

Adrian Zubarev adrian.zubarev at devandartist.com
Fri Dec 4 08:27:59 CST 2015

I know that, but I couldn’t describe it better. I mean implicit casts are already there and do look the same:

class A {}
class B: A {}

let someA: A = B() // this works fine

protocol C {}

class D: C {}

let someC: C = D() // this works fine too
Sure it depends on the context, but the implicit cast functionality could be extended on my opinion.

I build a little prototype to be able to automatically cast math expression. It looks something like this:

let someDouble = Double(UInt(0) + Int(1)) // + is overloaded

// sometimes the compiler complains so I need to write this  

let someDouble = Double(UInt(0) + Int(1) as Expression)

// it would look better if we had implicit conversion enabled trough constructors
let someDouble: Double = UInt(0) + Int(1)

// or
let someDouble: Double = UInt(0) + Int(1) as Expression

Regards Adrian

Am 4. Dezember 2015 bei 15:15:59, Stepan Hruda (stepan.hruda at gmail.com) schrieb:

This is not how *LiteralConvertible protocols work, though. You can only initialize variables with specific literal values recognized by the parser, it never magically casts a type to a different type for you. Similar implicit casts in my opinion confuse whoever reads the code afterwards.

class SomeConvertible: BooleanLiteralConvertible {
    typealias BooleanLiteralType = Bool
    let boolean: Bool

    internal required init(booleanLiteral value: SomeConvertible.BooleanLiteralType) {
        self.boolean = value

func getBoolean() -> Bool {
    return false

let validConvertible: SomeConvertible = false
// Line below doesn’t compile
let invalidConvertible: SomeConvertible = getBoolean()

On Fri, Dec 4, 2015 at 8:51 AM, Adrian Zubarev <adrian.zubarev at devandartist.com> wrote:

We have finally a corner where people can share their ideas on how Swift can be improved, and I’m glad my ideas might be part of this fun.

Swift introduced a few Convertible protocols, but it still needs some more If you ask me.

Something like this:

public protocol CustomConvertible {
    typealias CustomType
    public init(value: Self.CustomType) // or in a better way I can't come up with

But it should work in a way that we could create more different types like enums and ErrorType.

protocol AConvertible: CustomConvertible { /* some stuff here*/ }
protocol BConvertible: CustomConvertible { /* some stuff here*/ }

struct A {
    var foo: Int = 0

struct B {
    var boo: String = "Hello World"

struct C: AConvertible, BConvertible {
    typealias CustomAType = A
    typealias CustomBType = B
    var magical: SomeType
    init(value: CustomAType) {
        // implement it
    init(value: CustomBType) {
        // implement it


let firstC: C = A() // this is what I'm missing in Swift
let secondC: C = B() // this would be a great syntax sugar

What do you think?

Regards Adrian

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20151204/630928a7/attachment-0001.html>

More information about the swift-evolution mailing list