There are some implicit conversions with literals which are currently magical, like

```
let a: Double = 3
```

and there's clunky code related to conversions like when you want to do an exponent with two integers and get back an integer:

```
Int(pow(Double(radix), Double(power)))
```

I propose to clean up code and eliminate the magic around explicit conversions by adding a simple compile step that when you have:

```
let x: SomeType = yWithAnotherType // This gives an error right now
// Check if there's a constructor for SomeType like init(x: AnotherType) and if so desugar to
let x: SomeType = SomeType(yWithAnotherType)
```

This could also be done for method arguments too so for instance when you do:

```
let x: Int = pow(yInt, zInt)
// Desugars to:
let x: Int = Int(pow(Double(radix), Double(power)))
```

But this may be harder since pow might be overloaded and there may be more than one definition of it that could support implicit conversion.

I think at least the first idea deserves some thought as it would eliminate the need for a lot of common tedious manual conversions and there's no possible ambiguity if you already defined the type for the variable. This could also be used for concise code like:

```
let card: Card = 'A♥'
let hand: [Card] = ['3♦', 'A♥', 'K♥']
```