How can I correctly use keyword scoped?

[kyoyama-kazusa]

Hello everyone.

I cannot determine which way is good to play with scoped. For example:

static void M1(params Span<Person> span)
{
    ref var thirdOne = ref span[2];
    ref readonly var fourthOne = ref span[3];
    var slicedSpan = span[1..^1];

    M2(ref thirdOne);
    M3(in fourthOne);
    M4(slicedSpan);
}

static void M2(ref Person person)
{
    person = person with { Name = "Foo", Age = 42 };
}

static void M3(ref readonly Person person)
{
    Console.WriteLine(person.ToString());
}

static void M4(Span<Person> spanSliced)
{
    foreach (ref readonly var element in spanSliced)
    {
        Console.WriteLine(element.ToString());
    }
}

readonly record struct Person(string Name, int Age, bool IsMale);

Such usages are often appeared in my code environment. However, all possible places of ref struct-typed and ref variables / parameters can be inserted with an extra keyword scoped:

static void M1(params scoped Span<Person> span) // Here
{
    scoped ref var thirdOne = ref span[2]; // Here
    scoped ref readonly var fourthOne = ref span[3]; // Here
    scoped var slicedSpan = span[1..^1]; // Here

    M2(ref thirdOne);
    M3(in fourthOne);
    M4(slicedSpan);
}

static void M2(scoped ref Person person) // Here
{
    person = person with { Name = "Foo", Age = 42 };
}

static void M3(scoped ref readonly Person person) // Here
{
    Console.WriteLine(person.ToString());
}

static void M4(scoped Span<Person> spanSliced) // Here
{
    foreach (scoped ref readonly var element in spanSliced) // Here
    {
        Console.WriteLine(element.ToString());
    }
}

readonly record struct Person(string Name, int Age, bool IsMale);

The compiler doesn't tell me whether such usage is wrong or not. Therefore, I cannot determine which usage is correct or better.

Was I missing something for details of keyword scoped? What is the "real" correct usage on this keyword?

I just took a look of source code on DefaultInterpolatedStringHandler:

Some methods of this type uses scoped keyword. However I have no idea why they are necessary. Is there any differences between parameter with scoped and without scoped?

Thank you!

[colejohnson66]

scoped is a little hard to grasp if you don't understand the concept of "lifetimes". It essentially means that the pointer value of the reference (or span) will not be used anywhere past the end of the containing method. The data may live longer if it's copied elsewhere. So, for AppendFormatted, since it copies the data from the span into a different buffer, the span's lifetime can be as small as the method.

There's a nice answer on StackOverflow that tries to explain it.

---

Someone correct me if I'm wrong, but I'm pretty sure it's similar to the following Rust lifetime annotations (note the lack of where 'a : 'b bounds):

pub fn append_formatted<'a, 'b>(&'a self, value: &'b [u8]) {
    // ...
}

[kyoyama-kazusa]

Thanks for your explanation and that link! There're still some questions in my mind, but it could be helpful after reading that thread. I'm going to try to learn for details of such usage.

[kyoyama-kazusa]

Hi.

I learnt the rule today, but there's still a question in my mind.

For this method, it uses scoped keyword to modify the argument source, telling the reference won't be returned outside the method or assigned to a field in a ref struct. However, Unsafe.AsRef does indeed return a reference that is re-interpreted as a mutable reference. Why it is marked scoped? I don't understand for this. Do I understand wrong?

[colejohnson66]

It is marked as scoped so that, regardless of what value is used as the parameter, the compiler will not complain. In short, using scoped allowed more things to be passed into the function.

However, this method's entire purpose is to lie to the compiler. Going back to the lifetimes analogy, Unsafe.AsRef is a way to "extend" the lifetime of a parameter. You're telling the compiler "I have a parameter that you think is scoped, but trust me, it's not.” It also makes a "read only" parameter mutable (similar to const_cast<T> in C++).

[CyrusNajmabadi]

Hi.

I learnt the rule today, but there's still a question in my mind.

For this method, it uses scoped keyword to modify the argument source, telling the reference won't be returned outside the method or assigned to a field in a ref struct. However, Unsafe.AsRef does indeed return a reference that is re-interpreted as a mutable reference. Why it is marked scoped? I don't understand for this. Do I understand wrong?

Scoped is to tell the compiler that this is ok and not to complain. The entire purpose of this method though is to be unsafe and and do unsafe things without being blocked.

[kyoyama-kazusa]

Thanks for @colejohnson66 and @CyrusNajmabadi!

Necessary scoped keyword usage will make code behave well and be safer. I think I misunderstood about the limitation before.