I'm more inclined to prevent identifiers from starting with a digit.

It's true that we have a precedent with tuples, since they get numeric identifiers for each property place (e.g. `(1, 2).0`

and `(1, 2).1`

), but that's the only exception to the rule.

Since my field of expertise is mathematics, I would love the ability to define custom infix operators between numeric literals and variables with a blank identifier, in order to write modules having:

```
// strawman syntax
infix func ``(lhs: IntegerLiteral, rhs: Int) -> Int {
return lhs as Int * rhs
}
let x = 10
let y = x^2 - 4x + 4 // 4x is 4 * x
infix func ``(lhs: FloatLiteral, rhs: Complex) -> Complex {
return lhs as Complex * rhs
}
let i: Complex = (0, 1)
let z = 3 + 2i // 2i is 2 * i, i.e. (0, 2)
```

With your suggestion in place, this wouldn't be potentially possible anymore (well.. it's not possible even now since there should be a way to disambiguate `0x2p5`

which is `64`

written in hexadecimal notation, but I won't let my hopes fade away that easily~).

Numeric identifiers could be spelled between backticks where required, so those shouldn't be problematic:

```
let `1` = 1
1 // refers to the integer literal
`1` // refers to the variable `1`
struct TupleLike<A, B> {
let `0`: A
let `1`: B
init(_ a: A, _ b: B) {
`0` = a // or self.0 = a
`1` = b // or self.1 = b
}
}
let tuple = TupleLike("one", "two")
tuple.0 // is "one"
tuple.1 // is "two"
```