short-circuiting | 易学教程

short circuit with a return statement

阅读更多关于 short circuit with a return statement

问题 As far as I understand, short-circuiting with the logical AND && operator works like the following: Assuming I have the expressions a and b then a && b is the same as a ? b : a since if a is truthy then the result will be b and if a is falsy then the result will be a (without even trying to resolve b ) That being the case why is the following (demo) code throwing a SyntaxError: var add = function(a,b) { b && return a+b; // if(b) return a+b ... } Is there a way to short circuit with a return

Is Sql Server's ISNULL() function lazy/short-circuited?

阅读更多关于 Is Sql Server's ISNULL() function lazy/short-circuited?

问题 TIs ISNULL() a lazy function? That is, if i code something like the following: SELECT ISNULL(MYFIELD, getMyFunction()) FROM MYTABLE will it always evaluate getMyFunction() or will it only evaluate it in the case where MYFIELD is actually null? 回答1: It's whichever it thinks will work best. Now it's functionally lazy, which is the important thing. E.g. if col1 is a varchar which will always contain a number when col2 is null, then isnull(col2, cast(col1 as int)) Will work. However, it's not

short circuiting and parenthesis

阅读更多关于 short circuiting and parenthesis

问题 Does it matter how I group subexpressions when dealing with a single short-circuiting operator? a && b && c && d a && (b && (c && d)) (a && b) && (c && d) ((a && b) && c) && d Are the above expressions equivalent? 回答1: It is relatively easy to prove the equivalence for two simplified cases of three subexpressions: a && (b && c) --> a && bc // bc is a shorthand for b && c Here, a will be evaluated first. If it is false, short circuiting will prevent the evaluation of bc . If it is true, bc

Does the ternary operator short circuit in a defined way

阅读更多关于 Does the ternary operator short circuit in a defined way

问题 If you have the following: if (x) { y = *x; } else { y = 0; } Then behavior is guaranteed to be defined since we can only dereference x if it is not 0 Can the same be said for: y = (x) ? *x : 0; This seems to work as expected (even compiled with -Wpedantic on g++) Is this guaranteed? 回答1: Yes, only the second or third operand will be evaluated, the draft C++ standard section 5.16 [expr.cond] says: Conditional expressions group right-to-left. The first expression is contextually converted to

How does the compiler evaluate a condition in C

阅读更多关于 How does the compiler evaluate a condition in C

问题 I have a question regarding how the compiler evaluates 'AND' condition in c. Say, I write a statement like if( (today is Thursday) && (Month is July) ) { //do something } Assume today is not Thursday, but the Month is indeed July. Does the compiler check both the conditions, and do 1&0 == 0? Or as soon as it sees that today is not Thursday, it just skips out and doesn't even bother to check the Month condition since it's inconsequential. I'm using the following gcc Using built-in specs.

Verify that an OCaml function is tail-recursive

阅读更多关于 Verify that an OCaml function is tail-recursive

问题 How can I tell if OCaml recognizes a particular function as tail-recursive? In particular, I want to find out if the OCaml compiler recognizes Short-circuited operators and tail recursion Thanks to Jeffrey's answer below, I tried this with the simple function let rec check_all l = match l with | [] -> true | hd :: tl -> hd && check_all tl and indeed, it does optimize to: camlTest__check_all_1008: .cfi_startproc .L102: cmpl $1, %eax je .L100 movl (%eax), %ebx cmpl $1, %ebx je .L101 movl 4(%eax

How to do parallel “either-side” short-circuiting with “and” and “or”

阅读更多关于 How to do parallel “either-side” short-circuiting with “and” and “or”

问题 Does haskell have a parallel "and" method parAnd :: Bool -> Bool -> Bool such that (a `parAnd` b) will spark the evaluation of a and b in parallel and return false as soon as either a or b evaluates to false (and not wait for the other one)? Is there some way to implement such a thing? 回答1: Normally, this is not possible. You can do something like a `par` b `pseq` (a && b) but if b evaluates to False , a is still fully evaluated. However, this is possible with the unambiguous choice operator

Does c# ?? operator short circuit?

阅读更多关于 Does c# ?? operator short circuit?

问题 When using the ?? operator in C#, does it short circuit if the value being tested is not null? Example: string test = null; string test2 = test ?? "Default"; string test3 = test2 ?? test.ToLower(); Does the test3 line succeed or throw a null reference exception? So another way to phrase the question: Will the right hand expression of the ?? operator get evaluated if the left hand is not null? 回答1: Yes, it says so in the C# Language Specification (highlighting by me): A null coalescing

A syntax for custom lazy-evaluation/short-circuiting of function parameters

阅读更多关于 A syntax for custom lazy-evaluation/short-circuiting of function parameters

Oracle defines several structures that make use of what looks like lazy evaluation but what's actually short-circuiting. For example: x := case when 1 = 2 then count_all_prime_numbers_below(100000000) else 2*2 end; The function count_all(...) will never be called. However, what I'm more interested in is the syntax that looks like regular function call: x := coalesce(null, 42, hundreth_digit_of_pi()); Hundreth_digit_of_pi() will not be called since coalesce is not a regular function, but a syntax sugar that looks like one - for regular ones parameters get evaluated when the function is called.

Is there a Python idiom for evaluating a list of functions/expressions with short-circuiting?

阅读更多关于 Is there a Python idiom for evaluating a list of functions/expressions with short-circuiting?

问题 I wrote a simple script to solve a "logic puzzle", the type of puzzle from school where you are given a number of rules and then must be able to find the solution for problems like "There are five musicians named A, B, C, D, and E playing in a concert, each plays one after the other... if A goes before B, and D is not last ... what is the order of who plays when?" etc. To evaluate possible solutions, I wrote each "rule" as a separate function which would evaluate if a possible solution