? operator without else-part

Basically, you're trying to use the conditional operator for something that it's not designed for.

It's not meant to optionally take some action... it's meant to evaluate one expression or another, and that be the result of the expression.

If you only want to perform an action when some condition is met, use an if statement - that's precisely what it's there for.

In your example, you could use:

// Renamed someStatement to someCondition for clarity
someBool |= someCondition;

or

someBool = someCondition ? true : someBool;

... in other words "use the existing value unless someCondition is true... but personally, I think the original if statement is clearer.

Some background: we use constructs like this a lot:

sql = "SELECT x FROM table WHERE Y " + (condition ? " AND Column = 1" : "");

We also use constructs like this in Razor views

<div class='someclass @(condition ? "anotherclass" : "")'></div>

The : "" is pretty annoying so we built an extension method

public static T Then<T>(this bool value, T result)
{
    return value ? result : default(T);
}

Usage:

<div class='someclass @condition.Then("anotherclass")'></div>

taken from here

You can do:

someBool = (someStatement) ? true : someBool;

I don't think that gains you a lot of clarity over:

if (someStatement)
{
    someBool = true;
}

But it really seems to be a matter of taste. I wouldn't say either is clearly bad, but the former is uncommon, so I'd probably avoid it.

---

You ask why you can't use the operator like this:

someBool = (someStatement) ? true : ;

This would be a very big language change! Bear in mind that an assignment looks like this:

<location> = <expression>;

The expression is evaluated to give some value, and that value is stored in location. (Depending on whether location is a variable, property, field or indexing expression the "storing" operation could be quite different.)

Here you're proposing that the value of the expression on the right, in addition to its normal values, can be a "no-change" value, which has the special behaviour that when you use it in an assignment statement it causes no store operation to occur. That's different from any other normal value, and potentially surprising. But what would it mean if you used it in other places?

// Does this call DoSomething when cond is false?
// If so, what value is passed to it?
someObject.DoSomething(cond?x:);

// What happens here if cond is false? Does it cancel
// the entire assignment?
int x = 77 + (cond?2:) * 3 - 4;

// If cond is false, are methods F1 and F2 called or not called?
int x = F1() + (cond?2:) + F2();

// What does this do? Does it skip the return if cond is false?
return (cond?2:);

I think you'd find it extremely hard to come up with sensible, intuitive and consistent behaviour for the operator in all these circumstances, and I don't think it would be useful anywhere other than in a simple assignment. It just doesn't fit with the rest of the language - including it would make the language harder to learn, read, understand, implement and explain. It's just not worth it for a tiny bit of conciseness.