Value replacement expression; generalized form of ??

[dylanrafael05]

Preamble

Very simple idea, and I have no idea for a good syntax but consider the following case:

// someValue is a parameter in a method and is of type int
someValue = (someValue == -1 ? 100 : someValue);

Although this can be condensed using:

// someValue is a parameter in a method and is now of type (int?)
someValue ??= 100;

The type of the variable has now been changed, meaning direct access to the value of someValue has now been removed.

Proposal

In order to mitigate this, a "value substitution operator" could be implemented:

// someValue is a parameter in a method and is of type int

someValue = (someValue !! -1 ? 100);
// Value replacement syntax; parens are not required.
// (a !! b ? c) evaluates to (a == b ? c : a)

When replacing the default value of a type, b may be ommitted:

// someValue = (someValue !! default ? 100);
someValue = (some !! ? 100);

Example code

public float SafeFloatDivide(float num, float den) 
{
    den = (den !! ? 0.01f);
    return num / den;
}

public string EmptyCheck(string str) 
{
    return str !! "" ? "(empty)";
}

Could this be useful / common enough to be considered?
I believe this pattern is especially common when a default parameter is of a value type and the desired default value is not constant.

[HaloFour]

IMO the ternary conditional operator is sufficiently terse in these cases.

[dylanrafael05]

I find this much more difficult to read or understand. Can you provide some real world cases to help gauge this?

Typing on mobile, excuse spelling errors
I came up with this idea while working with a method that found an item within an indexable type.

public object ItemAt
(
   CustomCollection collect,
   CustomPath path,
   int? end = null
) {
   int endReal = end ?? collect.Length;
   //...
}

Boxing the default parameter "end" felt clunky, since now there's a new int? in memory that needs to be cleaned up. Although it is possible to create an overloaded method without the end parameter that does this calculation, the amount of extra code needed (a new method, a method body, and other boilerplate) seems unnecessary, and such a solution may even be impossible, especially if the desired default value depends on code executed within the function. Various other proposals (none of which I can find at the moment) suggest that a good solution to this would be the allowance of non-constant default parameters, and while that would be a better solution, the creation of a terse operator to handle value substitution allows for basically the same thing:

public object ItemAt
(
   CustomCollection collect,
   CustomPath path,
   int end = -1
) {
   end = (end !! -1 ? collect.Length);
   //...
}

... provided that there is some value of the argument that can be interpreted as invalid. This operator can also be used to streamline simple, ternary-like operations, since it abstracts away the need to repeat the variable name twice. For example: str !! "foo" : "bar" displays only the necessary information to deduce that the value of str is being replaced with "bar" if it is "foo", while str == "foo" ? bar : str reads more as an if statement using str in the conditional. While this is only a small difference, I believe the frequency at which such a pattern appears warrants a more concise way to denote value replacement, even if the difference is small.

[HaloFour]

Boxing the default parameter "end" felt clunky, since now there's a new int? in memory that needs to be cleaned up.

Nullable value types are not reference types, there is no "boxing" or "cleaning up" involved.

I find the following much more readable:

public object ItemAt
(
   CustomCollection collect,
   CustomPath path,
   int end = -1
) {
   if (end == -1) end = collect.Length;
   // ...
}

Although I'd probably prefer to go with an overload here.

[theunrepentantgeek]

Although it is possible to create an overloaded method without the end parameter that does this calculation, the amount of extra code needed (a new method, a method body, and other boilerplate) seems unnecessary,

The overhead doesn't seem very high for me - and it gives you considerable flexibility over what exactly happens:

public object ItemAt(
   CustomCollection collect,
   CustomPath path,
   int end) 
{
   //...
}

public object ItemAt(
   CustomCollection collect,
   CustomPath path) => ItemAt(collect, path, collect.Length)

[dylanrafael05]

Both valid answers, marking this post as answered and will not update in the future

[Tinister]

A generalized form of ?? might work in situations where you don't want to create a new variable. e.g. str.Substring(0, str.IndexOf(':') ?? str.Length)