Discussion: map methods

[stuartstein777]

Take the following class

public static class C
{
	private static int _c = 0;
	
	// I want this to be a Map
	public static int M(int x, int y)
	{
		return x+y;	
	}
	public static void M2()
	{
		_c = 7;
	}
}

I want M to be a map. That is, if called with inputs x and y then the output will only depend on x and y.

However, someone might come along and change M to be:

public static int M(int x, int y)
{
	return x+y+_c;
}

This still works technically if _c is 0, but if they ever call M2(), the mapping of M() is broken. So I would like this to raise a warning or error.

This I would say should be fine though:

public static int M(int x, int y)
{
	return x+y+5;
}

I'd like a way, if this possible or even makes sense, to mark a method as a map. Either with a keyword, something like

public static map int M(int x, int y) { .. }

Or maybe an attribute, something like

[Map]
public static map int M(int x, int y)

It would then be a compiler warning to change M in such a way that it's output is dependent on anything other than it's inputs (in this case x and y).

Does this make sense?

Is it feasible?

[HaloFour]

Sounds like a good case for a custom analyzer.

[orthoxerox]

Sounds like PureAttribute, except it's not checked at the moment.

[DavidArno]

Sounds like a good case for a custom analyzer.

Another one to add to your collection, @jnm2 😆

I like the idea of a keyword that indicates a method must only use its parameters to determine its result, but pure seems a much better fit than map to me. Also, pure could automatically imply it's static., removing the need to specify the latter. However, as @orthoxerox says, this could more easily be achieved by having the compiler (or "built in" analyzer) check the [Pure] attribute.

[jnm2]

Sounds like a good case for a custom analyzer.

Another one to add to your collection, @jnm2 😆

No kidding! 😆

Definitely agreed about calling it pure because that's the precise term for it. I don't see any reason for it to be static though. Instance methods can be every bit as pure; the instance is merely the first argument.

[HaloFour]

@DavidArno

Agreed, I do believe this falls under the definition of "pure" methods. The attribute already exists and it might be nice if the compiler could check that via a warning wave. But beyond that it's perfect fodder for an analyzer.

It looks like you've already started down the path of testing method purity, but it doesn't look like you're basing any of that on the existing PureAttribute?

[DavidArno]

@HaloFour,

You are correct. I took an alternative approach: static methods must be pure by default and have to be annotated with [HasSideEffects] or [MutatesParameter] to suppress warnings around those two impure activities.

[mattwar]

Yes, this sounds like you want a "pure function" in the parlance of language nerds.

[yaakov-h]

I don't believe PureAttribute is actually suitable here.

My understanding is that PureAttribute signifies that this method does not make any visible mutations.

What OP appears to be asking for is a way to signify that this method does not take any additional inputs than what it was explicitly fed through it's argument list.

Those are two different things.

[jnm2]

My understanding is that PureAttribute signifies that this method does not make any visible mutations.

If that's the case, that means PureAttribute is not talking about method purity per se. Pure functions can't read global state any more than they can write it. (wiki)

[yaakov-h]

Right, looks like another thing the Contracts team only got halfway through, then.

"it does not make any visible state changes... Pure methods do not make any visible state changes." -- PureAttribute