Negate #Available Statement

Negate #available statement

In Swift 5.6, you can now do the following:

if #unavailable(iOS 15) {
    // Under iOS 15
} else {
    // iOS 15+
}

Or just the following depending on your case:

if #unavailable(iOS 15) {
    // Under iOS 15
}

This is part of SE-0290: Negative availability.

Negating Objective-C's @available keyword

The idea of @available is that you want to use API that is only available on certain systems. For other systems, the functionality is either missing in your app or you offer alternative functionality. The correct way to use it for cases where you don't need any code beyond a certain OS version, only below, is

if (@available(iOS 10.0, *)) {
    // Happens automatically on on iOS 10 and beyond
} else {
    someOtherCode();
}

The reason for that is that the compiler sometimes has to perform some extra magic to code guarded by @available and therefore it needs to clearly recognize when this is the case. So in fact it explicitly searches for

if (@available(...)) {

with only variations in spaces and line breaks allowed. Yes, you may ague that a single not (!) is really anything but complicated yet where would you then draw the line? What about:

if ((todayIsTuesday() && @available(iOS 9.0, *)) 
    || (self.theWeatherIsNice && !@available(iOS 11.0, *)) {

Thus only a simple statements are allowed that only force the compiler to divide code into two sections and where always only one section will run for sure: One for the listed OSes and one for the rest. Of course, "the rest" can then be subdivided again, else if is allowed. Only the else section can be auto-generated if missing, so when you write this:

if (@available(...)) {
    someCode();
} // There is no else

The compiler is also happy as that is the same as

if (@available(...)) {
     someCode();
} else {
    // Nothing to do here
}

How to negate a php if or statement

First, && is priority over || (like * and +). So you can remove 1 parenthesis pair:

if ( isAdmin() || isSupporter() && hasRight("XXX") )

A simple negation is to add parenthesis and negate the complete expression.

if ( !( isAdmin() || isSupporter() && hasRight("XXX") ))

Negation of a logical expression means, to negate all elements, and exchange && and ||. For priority reasons, you have to add parenthesis (like here) or you can remove them.

if ( !isAdmin() && ( !isSupporter() || !hasRight("XXX") )

Swift how to check if API is NOT available

if you need to support earlier versions than iOS 11 then use #available inside the function draw(rect:) and use else part to apply logic on earlier versions

override func draw(_ rect: CGRect) {
    if #available(iOS 11, *) {} else {
      let maskPath = UIBezierPath(roundedRect: self.contentView.bounds, byRoundingCorners: [.topLeft, .topRight], cornerRadii: CGSize(width: 20.0, height: 20.0))
      let shapeLayer = CAShapeLayer()
      shapeLayer.frame = self.bounds
      shapeLayer.path = maskPath.cgPath
      view.layer.mask = shapeLayer
    }
 }

update Swift 5.6: use #unavailable

override func draw(_ rect: CGRect) {
        if #unavailable(iOS 11, *) {
          let maskPath = UIBezierPath(roundedRect: self.contentView.bounds, byRoundingCorners: [.topLeft, .topRight], cornerRadii: CGSize(width: 20.0, height: 20.0))
          let shapeLayer = CAShapeLayer()
          shapeLayer.frame = self.bounds
          shapeLayer.path = maskPath.cgPath
          view.layer.mask = shapeLayer
        }
     }

How to negate a value with if/else logic in python?

Let's summarize:

1. The condition if value: (and also while value:) tests, whether the value evaluates to boolean true. Many call such values "truthy" or "truish".

   The negated condition if not value: tests the opposite, i.e. whether the value evaluates to boolean false. Such values are called "falsy".

   Truthy is everything not falsy; typical falsy values are:

   • constants defined to be false: None and False.
   • zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
   • empty sequences and collections: '', (), [], {}, set(), range(0)

   (quoted from the docs, click for more details)

2. Any value can be converted to boolean True or False with bool(value). In other words: truthy just means that bool(value) evalues to True.

3. The remaining question is how to test for a constant True ( or False or None) and not just any truthy (or falsy) value. The answer is:

    if value is True: # or False/None
        ...
   

---

The function you were asking for is:

def overriden(value, override):
    return value if override is None else override

How do I negate a condition in PowerShell?

You almost had it with Not. It should be:

if (-Not (Test-Path C:\Code)) {
    write "it doesn't exist!"
} 

You can also use !: if (!(Test-Path C:\Code)){}

Just for fun, you could also use bitwise exclusive or, though it's not the most readable/understandable method.

if ((test-path C:\code) -bxor 1) {write "it doesn't exist!"}

Negate condition of an if-statement

In Scala, you can check if two operands are equal (==) or not (!=) and it returns true if the condition is met, false if not (else).

if(x!=0) {
    // if x is not equal to 0
} else {
    // if x is equal to 0
}

By itself, ! is called the Logical NOT Operator.

Use it to reverse the logical state of its operand.

If a condition is true then Logical NOT operator will make it false.

if(!(condition)) {
    // condition not met
} else {
    // condition met
}

Where !(condition) can be

• any (logical) expression
  
  • eg: x==0
    
    • -> !(x==0)
• any (boolean like) value
  
  • eg: someStr.isEmpty
    
    • -> !someStr.isEmpty
      
      • no need redundant parentheses

Negating expression in if statement inside macro gives odd results

This is the unexpected consequence of the by-design simple stupidity of the preprocessor's macro substitution engine. An expression supplied to the macro is not evaluated as it would be with a function, the text is inserted directly during substitution.

Given

#define ASSERT(x, msg) {if(!x) { std::cout << "Assertion Failed: " << msg << "\n"; __debugbreak(); } }

the line

ASSERT(eol != std::string::npos, "Newline not present!");

will be transformed into

{if(!eol != std::string::npos) { std::cout << "Assertion Failed: " << "Newline not present!" << "\n"; __debugbreak(); } }

and the ! is only applied to the eol, changing the expected behaviour of the macro to something nonsensical.

Adding the extra brackets recommended in the comments

#define ASSERT(x, msg) {if(!(x)) { std::cout << "Assertion Failed: " << msg << "\n"; __debugbreak(); } }

results in

{if(!(eol != std::string::npos)) { std::cout << "Assertion Failed: " << "Newline not present!" << "\n"; __debugbreak(); } }

and now the expression is being evaluated before applying the ! and tested.

Because macros are "evil", and since the macro makes no use of any special, position dependent debugging macros like __FILE__ or __LINE__, this is a case where I would replace the macro with a function and count on the compiler's optimizations to inline it.

---

Related Topics