Should this parametric mutability example work?

Mojo
,
1

Is parametric mutability working? Or am I misunderstanding what it is? This does not let me mutate y.

@value
struct MyThing:
    var thing: String


fn by_ref[
    is_mutable: Bool, //, origin: Origin[is_mutable]
](ref [origin]y: MyThing):
    """A function that takes a reference that is parametric over mutability."""

    @parameter
    if is_mutable:
        y.thing = String("Can overwrite it")

    print(y.thing)

Error

error: expression must be mutable in assignment
        y.thing = String("Can overwrite it")

But this works as expected:

fn take_mut(mut y: MyThing):
    """A function that takes an mutable reference of a MyThing."""
    y.thing = "Overwritten!"
    # y = MyThing("Overwritten twice!") # also works
    print(y.thing)

And the ref docs say From inside the called function, a ref argument looks like a read or mut argument.

2

Nope, not yet i think,
it is a sharp edge that can be solved with rebind or mut_cast :+1:
(refine the parameter)

I think it was on the sharp edges page at some point but not sure :+1:

This function is meant to be used in uncommon cases where a parametric type depends on the value of a constrained parameter in order to manually refine the type with the constrained parameter value.
`

Another different solution is to create two function overloads:
one for mutable and one for not mutable

3

Thanks for saving my sanity! Overloading the mutability is very slick. I’ll give that a try.

I reread the sharp edges doc and don’t see anything about this there. It’s odd that the docs for ref demonstrate it, but don’t actually do any mutation, which made me question whether I really understood what was going on.

If any Modular people come by, is this a known thing on a roadmap for fixing? This is a pretty awesome feature coming from Rust.

4

Sorry just found it, it moved to an in-depth page that explains it :+1: :white_check_mark: :

(Mojo manual :arrow_right: Parameterization :arrow_right: The rebind() builtin)

1 Like
5

I’ve been looking through the standard library for an example of using rebind to change the mutability, but haven’t found one. Have you see this in action somewhere I can look at?

6

This was the best I was able to come up with so far:

fn take_ref[
    is_mutable: Bool, //, origin: Origin[is_mutable]
](y: Pointer[MyThing, origin]):
    """A function that takes a reference that is parametric over mutability."""

    @parameter
    if is_mutable:
        var y_mut = rebind[
            Pointer[MyThing, MutableOrigin.cast_from[origin].result]
        ](y)
        y_mut[].thing = String("Can overwrite it")

    print(y[].thing)

Trying to overload with a take(mut y: MyThing) and take(read y: MyThing) result in the call site giving an error saying I need to cast, but I have no idea how to cast appropriately there.

Likewise, I can’t figure out how to rebind ref[origin] MyThing because rebind can’t include a ref keyword.

7

Yep, here is an example for the overloads,
it is possible to cast the origin but i’m not super keen to encourage this !

This example is quite simple and we keep it parametrized with no cast, no rebind:

fn MyFunc[o:ImmutableOrigin](arg: Pointer[Int, o]):
    print("Arg:", arg[])
fn MyFunc[o:MutableOrigin](arg: Pointer[Int, o]):
    print("Mutate arg")
    arg[] += 1
fn as_mut[T:AnyType, o:MutableOrigin](ref[o] arg:T)->Pointer[T,o]:
    return Pointer.address_of(arg)
fn as_immut[T:AnyType, o:ImmutableOrigin](ref[o] arg:T)->Pointer[T,o]:
    return Pointer.address_of(arg)
fn main() raises:
    var x: Int = 0
    MyFunc(as_mut(x))
    MyFunc(as_immut(x))

:arrow_up: Example for mojo 25.1.0

1 Like
8

That’s pretty slick. Thanks for the example!

The as_mut / as_immut functions were the missing puzzle piece for me :+1:

1 Like
10

This is behaving as designed. The use of rebind is necessary when you have additional information known about a type that isn’t obvious from the code.

In this case, mojo won’t let you mutate something with a parametric mutability, because it isn’t valid for all instantiations of the code, e.g., this would be invalid:

fn take_ref[
    is_mutable: Bool, //, origin: Origin[is_mutable]
](y: Pointer[MyThing, origin]):
        y[].thing = String("Can overwrite it")

Mojo wants to make sure - at definition time - that take_ref can work with all instantiations. We try hard to do this because this is good for QoI. In your case, you’re checking for additional information with parameter if: this is cool, but mojo doesn’t automatically refine the type inside the body of that. As such, the use of rebind (like you’re doing) is the right way to go. thanks!

1 Like
11

This topic was automatically closed 7 days after the last reply. New replies are no longer allowed.