Deconstruction with out declarations

[jnm2]

I would like to be able to write:

var dict = new Dictionary<string, (Foo, Bar)>();

if (dict.TryGetValue(str, out var (_, bar)))
{
    // use bar
}

It's hard to think of a good name for the tuple other than t, but ideally I'd just get what I want and not have to name the tuple at all.

The compiler won't accept this today and I can't find existing discussion on it. Thoughts?

It would provide a nice symmetry with this:

foreach (var (_, bar) in dict.Values)
{
    // use bar
}

[DavidArno]

This could be achieved using my suggestion for extending as's functionality:

With hindsight, this was a rubbish idea, so retracted 😄

[CyrusNajmabadi]

Oh my...

[alrz]

I suppose this is already planned as out var (..) is frobidden.

[jnm2]

I want to be able to write out var (_, foo). It feels natural. I don't think it should be any more complex than that.

[CyrusNajmabadi]

Tagging @gafter. Neal, is this already in the bucket of work we're thinking about for the next wave of pattern matching/deconstruction? If not, could it be added. It certainly seems like deconstruction would naturally be available in these locations.

[HaloFour]

Would that be legal into existing variables?

Bar bar;
if (dict.TryGetValue(str, out (_, bar)))
{
    // use bar
}

Would construction/deconstruction with ref be much more of a stretch?

void SomeMethod(ref (Foo, Bar) tuple) { ... }

Foo foo = default;
Bar bar = default;
SomeMethod(ref (foo, bar));

[gafter]

Tagging @gafter. Neal, is this already in the bucket of work we're thinking about for the next wave of pattern matching/deconstruction? If not, could it be added. It certainly seems like deconstruction would naturally be available in these locations.

This was something that we took up in the LDM when we were triaging and decided against doing, at least for the near future. I can't find any notes about that decision (but I did find the earlier https://github.com/dotnet/csharplang/blob/master/meetings/2016/LDM-2016-04-12-22.md where it was introduced), but I remember we definitely put it off. Also, it doesn't currently have a champion.

[TechWatching]

It's too bad, it seems to be a small feature that is really missing.

[airbreather]

Just chiming in here to say that this has been coming up a lot for me since I've started using tuples. They're very convenient things to use as the TValue of a Dictionary<TKey, TValue>, especially when there's an existing Dictionary<TKey, TValue> variable where I want to add some more data while it's being built, and the current TValue isn't something that makes that easy for me.

[YairHalberstadt]

Given that

• the design of this should be relatively simple (there are no decisions to be made that I can think of - the design and implementation falls naturally out of current language features).

• this is a localised enough feature to be community implemented.

• there are no obvious downsides to the feature.

• it is consistent with the language as a whole, and in fact decreases the complexity of the language by increasing its consistency.

Is it worth championing this feature with the hope that a community member would implement it, even if the language/compiler team do not have time themselves?

[YairHalberstadt]

the design of this should be relatively simple (there are no decisions to be made that I can think of - the design and implementation falls naturally out of current language features).

To be more precise, although there are design questions around this, they are mostly along the lines of: "We know where we want to end up with this ideally. How much can we do in one go?". As such, the obvious answer is, however much gets implemented!

[zahirtezcan-bugs]

Regarding @HaloFour's example it will really be useful for wrapping dictionaries as a different view:

public bool TryGetValue(string key, out Bar bar)
{
    return dict.TryGetValue(key, out (_, bar))
}

[AqlaSolutions]

I'm shocked this still is not implemented

[gafter]

Just to add to the information on this, the reason the LDM was uncomfortable with this feature as proposed is that C#'s out and ref parameter passing modes are a form of by-reference, not a form of copy-on-return. In other words, when the assignment occurs within the method, the corresponding variable in the caller is modified immediately. This proposed feature would add a completely different copy-on-return parameter passing mode. And we simply are not that comfortable adding a new parameter passing mode.

[AqlaSolutions]

@gafter , this can be implemented just as a syntax sugar.

if (TryGetValue(key, out (var a, b)))
becomes

var a, b; // should be specific type here
bool $c = TryGetValue(key, out var $temp);
(a,b) = $temp;
if ($c)

[AqlaSolutions]

@gafter , uh, I reread your comment, so in multithreading environment those deconstructed a, b will not receive their values immediately as they are assigned inside TryGetValue but instead on return. Now I see your point.
What if we limit out deconstruction to newly declared or not initialized variables only? I mean out (a,b) is forbidden but out (var a, var b) is ok. Nothing will be able to access a and b until return anyway.

[AqlaSolutions]

Also connecting out, by-reference and "multiple returns" concepts seems wrong to me but it's a history already... E.g. TryGetValue implementation doesn't really need the by-reference thing, it just needs a way to pass a second return value. It would be better to introduce a separate keyword for copy-on-return e.g. outv without the guarantee of immediate assign. But who needs it now when we have tuples:

    public static (TValue value, bool success) TryGetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
    {
        bool success = dictionary.TryGetValue(key, out var v);
        return (v, success);
    }

and then

        var d = new Dictionary<string, (string, int)>();
        if (d.TryGetValue("key") is (var (v1, v2), true))
        {
            Console.WriteLine(v1);
        }

Also out deconstruction already works when you try to deconstruct inside deconstruction like (var (v1,v2), true). Each desconstruction calls public void Deconstruct(out x, out y...) so first deconstruction transforms into Deconstruct(out var (v1,v2), out bool boolean1) and this works!