Temporary transform type in specific block

[Thaina]

As oppose to feature Is-As from pattern matching https://github.com/dotnet/roslyn/blob/future/docs/features/patterns.md

if (expr is string s) {
    // code using s
}

I would like to propose syntax for temporary transform type of variable in a block

object obj;
var(obj as string) {
    int l0 = obj.Length; // No error, obj temporarily be string in this block
}

int l1 = obj.Length; // Compiler error

It work like if(a is Type) in kotlin that would make compiler see the variable a in if block as a type specified automatically. But since that would be a breaking change in C# so it could be another syntax that never been used before

If the object is not that type, or null, then it would skip the block like it testing if(obj is string)

Also it would be possible for

var(s = obj as string) {
    // code using s , obj is still object. but not come in this block if s is null
}

ps. Another idea is reusing keyword try in if

if(obj try string && !string.IsNullOrWhiteSpace(obj)) {  // obj would become string after try expression
    int l0 = obj.Length;
}

ps2. Another keyword would be better? for(obj as string) { } const(obj as string) { } let(obj as string) { }
or maybe we don't need keyword

(obj as string)
{
    int l0 = obj.Length;
}

[iam3yal]

I don't know what you dislike about the syntax below and what you really love about your own suggestion but to me the following seems pretty great and solid syntax.

if (expr is string s) {
    // code using s
}

Some of the suggestion you made are really weird, I mean reusing for, const doesn't make much sense to me.

[Thaina]

@eyalsk What I don't like about that syntax? everything

It like you declare object in reverse order of normally
It like you need to write

0 = int b;
b.ToString();

It also not use = to declare variable. It just add a variable and assume that variable was set
It counter intuitive from C# in every way

What I like about my syntax
Actually I would like to have it like kotlin. It would do what I propose if we just write

object obj;
if(obj is string) {
    int l0 = obj.Length; // No error, obj temporarily be string in this block
}

But it cannot do so this in C#, So I try to make a syntax that imitate it

It also better because we can use only one variable, don't need to make new and keep track of it. We just want to use the origin variable so it should be in the same name

ps. I think for is somehow not weird. It just like you make a shorthand syntax for

object obj;
for(var s = obj as string; s != null; s= null)
    return s.Length;
// assume this is shorthand of that by dropping ;;
for(var s = obj as string)
    return s.Length;
// equal to
for(obj as string)
    return obj.Length;

[gafter]

A swiftish way to handle this would be

if (let string s = expr) ...

[Thaina]

I actually don't like let, but that seem interesting alternative

maybe this?

object obj;
if(let string obj)
    return obj.Length;

[iam3yal]

@Thaina

It like you declare object in reverse order of normally

I guess I can agree with you on that given that you refer to the fact that you state an expression and then you declare a variable in order to have an access to it.

If it was possible I'd love to have something like this:

if (string s = expr) ...

But I think that this isn't possible and probably been discussed so maybe something like this:

if (string s : expr) ...

but honestly, I like the is operator proposal too so I don't mind it even though I understand what you try to convey.

What I like about my syntax
Actually I would like to have it like kotlin. It would do what I propose if we just write

I really dislike the fact that you have to declare the variable outside to the scope of the if statement and the reason for that is in most cases you already have existing thing that you want to operate on, why have extra noise there? also, having the variable outside the scope can lead to some weird readability issues where the variable is used inside the scope of the statement but weirdly enough it's declared outside.

I think for is somehow not weird. It just like you make a shorthand syntax for

for is used for iterations and reusing this for something else doesn't make sense, it adds nothing but confusion.

[Thaina]

@eyalsk I don't know what you misunderstand about kotlin but, no it not add noise. kotlin actually remove noise

It work like this

// This is not C# but Kotlin
int GetIntValue(object obj)
{
    if(obj is string)
        return obj.Length; // obj became string in this block

    if(obj is int)
        return obj; // obj became int in this block

    if(obj is KeyValuePair<string,int>)
        return obj.Value; // obj became KeyValuePair<string,int> in this block

    if(obj is IEnumerble)
        return obj.Count(); // obj became IEnumerble in this block

   return (int)obj.GetHashCode(); // obj is just object outside if-is block
}

It is what you actually want, you already have existing thing that you want to operate on. In kotlin you don't need to make a temporary variable in the scope. Why have noise there?

[iam3yal]

@Thaina ahh okay, I thought you need to declare an extra variable for some reason but thanks for the clarification.

So yeah, this can work pretty nicely, I think.

int GetIntValue(object obj)
{
    if(obj : string)
        return obj.Length; // obj became string in this block

    if(obj : int)
        return obj; // obj became int in this block

    if(obj : KeyValuePair<string,int>)
        return obj.Value; // obj became KeyValuePair<string,int> in this block

    if(obj : IEnumerble)
        return obj.Count(); // obj became IEnumerble in this block

   return (int)obj.GetHashCode(); // obj is just object outside if-is block
}

[Thaina]

Like : symbol. I like to use symbol as operator than keyword

[TonyValenti]

This makes me think of nullability tracking except with types.

[TonyValenti]

Also, if this is implemented, I think that the type of obj in the block should be the union of its current type and whatever types/interfaces were fulfilled in order to fulfill the IF statement.