order-independent parameters when referencing each other

[anthonyquizon]

Eg. A function like this doesn't compile:

fn Module(comptime T: type) type {                                                                                                                                                                                 
    const ListType = ArrayList(T);                                                                                                                                                                                 
                                                                                                                                                                                                                   
    return struct {                                                                                                                                                                                                
        pub fn reduce(
            f: fn(T, @typeOf(init)) @typeOf(init), 
            init: var, 
            list: ListType
        ) @typeOf(init)  {                                                                                                            
        //  ...                                                                                                                                                                                      
        }                                                                                                                                                                                                          
    };                                                                                                                                                                                                             
}     

Where init is ordered before f but is referenced by f with @typeOf.

However, if init is placed at the start of the function, it is able to be referenced

        // ...
        pub fn reduce(
            init: var, 
            f: fn(T, @typeOf(init)) @typeOf(init), 
            list: ListType
        ) @typeOf(init) {                                                                                                            
        //  ...                                                                                                                                                                                      
        }       

I would have thought that @typeOf should be able to reference an argument regardless of order.

[wooster0]

Yes, I think it'd be great if parameters could just be order-independent like top-level declarations. I think it'd make things like #4437 easier too.

I just think that implementing this may or may not be a requirement for if we want to really allow people to design their APIs the way they want. Having to have parameters be in a certain order just for technical reasons rather than actually thinking that's a good order is not something that's very good I think.