Pitch: Within `switch` Statements, Allow Consolidation of `where` Cases For A Common `let/var value`

Evolution Pitches
1

I sometimes find when reading through more complex switch-case statements, that as conditions accumulate, the statements can be more complicated to read than is necessary. While some of this comes down to encouraging good practices by developers, a syntactic sugar came to mind that might help in this effort.

That is, within switch statements, allow consolidation of where cases for a common let value. It would do the following:

  1. Allow for grouping of related logic while reducing boilerplate
  2. Improve readability by enforcing use of an identical name for related logic on a common value.
func foo(parameter: Int) { 
    switch parameter {
    case 1:
        bar()
    case 2..10:
        baz()
    case let value {
        where condition:
            value.function()...
        where condition2:
            value.function2()...
        where (multipleCondition && multipleCondition2 && multipleCondition3) || multipleCondition4:
            value.function2()...
        where condition4:
            value.function3()...
        }
    default:
        break
    }
}

It is functionally equivalent to the following constructions that I find deficient:

  1. It is most similar to this construction. However this is more verbose than what I am proposing:

    func foo(parameter: Int) { 
    switch parameter {
    case 1:
        bar()
    case 2..10:
        baz()
    case let value 
        switch value {
        case condition:
            value.function()...
        case condition2:
            value.function1()...
        case (multipleCondition && multipleCondition2 && multipleCondition3) || multipleCondition4:
            value.function2()...
        case condition4:
            value.function3()...
        }
    default:
        break
    }
}

  2. This construction is slightly more verbose (V1), but because there is no restriction on what name can be used the case let it allows each case to have a different name (V2), which can lead to a small cognitive penalty:

V1:

func foo(parameter: Int) { 
    switch parameter {
    case 1:
        bar()
    case 2..10:
        baz()
    case let value where condition:
        value.function()...
    case let value where condition2:
        value.function1()...
    case let value where (multipleCondition && multipleCondition2 && multipleCondition3) || multipleCondition4:
        value.function2()...
    case let value where condition4:
        value.function3()...
    default:
        break
    }
}

V2:

func foo(parameter: Int) { 
    switch parameter {
    case 1:
        bar()
    case 2..10:
        baz()
    case let value where condition:
        value.function()...
    case let valueDifferentName where condition2: 
        valueDifferentName.function()...
    case let valueUniquelyName where (multipleCondition && multipleCondition2 && multipleCondition3) || multipleCondition4:
        valueUniquelyName.function2()...
    case let anotherValueName where condition4:
        anotherValueName.function3()...
    default:
        break
    }
}
1 Like
2

I'm having difficulty discerning which syntax you are proposing. Does the first code block represent what you would like?

(my confusion stems, I think, from the fact that you lead into the first code block with 'avoids this:')

3

Thanks for your clarifying comment. That avoids this was a leftover edit. I am indeed proposing the first.

I should update this in a clearer overall format. I was excited and posted too quickly, probably.

4

The nested switch in 1. is so close to the proposed solution, and also easier to interpret, that it seems unlikely that the proposed new syntax is warranted.

1 Like