idiomatic "map contains" in a switch/case statement?

[Steven Johnson]

If I want to do a test of "does this map contain this entry", it's
simple enough to do in an if statement:

m := map[string]int{"foo":1}
if _, ok := m["foo"]; ok {
fmt.Println("map contains foo")
}

But similar syntax doesn't work in switch:

m := map[string]int{"foo":1}
switch {
case _, ok := m["foo"]; ok:
fmt.Println("map contains foo")
}

Is there any baked-in way to do such a test in switch?

I can of course use a helper function, but that's kinda awkward:

func contains(m map[string]int, s string) bool {
_, ok := m[s]
return ok
}

m := map[string]int{"foo":1}
switch {
case contains(m, "foo"):
fmt.Println("map contains foo")
}

[Rob Pike]

If you know there will never be a non-zero element for a key present
in the map, you could do

switch {
case m["wassup"] != 0:
etc()
}

If 0 is a valid element, that won't work. But don't you dis helper
functions. They help. And they're functional.

-rob

[Steven Johnson]

On Wed, Nov 7, 2012 at 11:37 AM, Rob Pike <r...@golang.org> wrote:
> If you know there will never be a non-zero element for a key present
> in the map, you could do

Won't help in this case, alas.

> But don't you dis helper functions. They help. And they're functional.

As a general rule, sure. But why can't we have the if-syntax also work
for case-syntax? Is there a reason I'm overlooking, or was it just an
oversight?

[minux]

On Thu, Nov 8, 2012 at 3:39 AM, Steven Johnson <s...@google.com> wrote:

> But don't you dis helper functions. They help. And they're functional.

As a general rule, sure. But why can't we have the if-syntax also work
for case-syntax? Is there a reason I'm overlooking, or was it just an
oversight?

if you want that, why not just use nested if?

switch true is only a shorthand for one frequently used form of nested if

sequence (and the same trick is even used in good old C).

[Steven Johnson]

On Wed, Nov 7, 2012 at 11:42 AM, minux <minu...@gmail.com> wrote:
> if you want that, why not just use nested if?

Probably what I'll end up doing. Was curious because it seems that
idiomatic Go seems to prefer switch to repeated if-else statements;
this syntactic nit makes it infeasible to do an exact equivalent in
these cases.

[jorelli]

m := map[string]int{"foo":1} 

f := func(key string) bool { _, ok := m[key]; return ok }

switch {

    case f(key):

        // whatever

[Steven Johnson]

On Wed, Nov 7, 2012 at 2:34 PM, jorelli <jordan...@gmail.com> wrote:
> m := map[string]int{"foo":1}
> f := func(key string) bool { _, ok := m[key]; return ok }

Or, eliminating the middleman:

m := map[string]int{"foo":1}
switch {

case func()bool{ _, ok := m["foo"]; return ok}():

fmt.Println("map contains foo")
}

Don't think I want to go down that particular road, though...