Interpretation of Truthy/Falsey

Question

Quite a few code-golf questions require output to be "truthy or falsey". This is possibly confusing as these terms can possibly mean different things to different people, and especially in different languages. How should answers interpret the meaning of these terms?

---

_{I'll provide a few possible answers to this - upvote or downvote according to which you think makes most sense. Or add your own answers.}

Answer 1

Consider the following pseudocode:

if (x) {
    print "x is truthy";
}
else {
    print "x is falsy";
}

If it results in a runtime or a compile-time error then x is neither truthy nor falsy.

Answer 2

Truthy/Falsey should be taken as strictly defined in the given language. For example, in javascript, the following are always falsey:

• undefined
• null
• NaN
• 0
• ""
• false

And other values are always truthy.

Answer 3

Some languages have ambiguity in what is considered truthy/falsey. For example in c, zero vs non-zero is always FALSE vs TRUE from the point of view of conditional operators. But many standard APIs, for example return -1 for FAILURE and >=0 for SUCCESS. So answers may choose (and explicitly state) whatever sets of values they like to represent truthy vs falsey, so long as those sets are mutually exclusive.

Answer 4

Don't forget program exit codes!

If my C or C++ or perl or bash or ... program calls exit(0) this action could be considered truthy, and calling exit with a nonzero value could be considered falsey.

Answer 5

I would partition values into the categories truthy, falsy, and indeterminate according to the following rules:

The following values are considered falsy:

• the zero value of the type of the result, if any
• a NULL pointer
• an array, the product of its dimensions being zero
• a number whose absolute difference to 0 is not larger than 2^-44.
• a string literal parsed as a number yielding such a number
• a string literal which when executed as a program of the language the submission is written in yields a falsy value. This rule cannot be applied more than once transitively.
• an empty string
• the boolean value false (if any)
• a string which, when converted to lower case, is equal to one of false, no, f, or n.
• a function which for any combination of arguments returns a falsy value. This rule cannot be applied more than once transitively.
• of an enumeration type whose values are not associated with numbers the first enumeration value
• of an enumeration type whose values are associated with numbers an enumeration value associated with a falsy value, otherwise the first enumeration value
• a compound type (e.g. a struct) comprising only falsy values
• a union type the last write to which wrote a falsy value
• a pointer to a falsy value

The following values are considered indeterminate:

• a NaN
• a stray pointer
• a trap representation
• an undefined value
• a function which for some combination of arguments returns a falsy value and for others returns a non-falsy value.
• the absence of value, i.e. returning nothing
• the absence of ordinary termination, e.g. termination with an exception or crash or no termination
• a value, reading from which causes an exception, non-termination, or crash

All other values are considered truthy.

Answer 6

I think Truthy/Falsey instead of being language specific is problem (answer) specific. So in a language we can define different truthy/falsey s based on different conditions. For example one can define truthy as 53 and other things regarded as falsey and in the other problem truthy may be defined as an empty list and anything else may be defined as falsey.

In the other word:
An entity (and all other things that are implicitly convertible to value of that entity) can be regarded as truthy and anything else can be regarded as falsey or vice versa. The entity that is regarded as truthy(or falsey) must has only one exactly defined representation.

For example in Octave language one can regard true as truthy and anything other as falsey. Because all numbers other than 0 are implicitly convertible to true those can be regarded as truthy and 0 can be regarded as falsey. Also arrays that contain 0 such as [7 1 0] are implicitly convertible to false and other arrays are convertible to true.

As an example one can define an empty list {} as falsey and all other things as truthy because an empty list has exactly one representation. Also a list of {1,2,33} can be regarded as truthy/falsey and all other things can be regarded as falsey/truthy since {1,2,33} has an exactly one representation. But consider a function that sometimes returns a list and sometimes returns a scalar, so one can't regard a list as truthy because a list doesn't have exactly one representation so {1,2,3} and {1,2} are both lists but have different representations.

Also one can't define all even numbers as true and all odds as false except in those languages that evens are implicitly convertible to true.

Some examples:

 _________________________________
| Truthy         |  Falsey        |
|----------------|----------------|
| 243            | anything else  |
| NaN            | anything else  |
| anything else  | 127            |
| []             | anything else  |
| anything else  | {7,2}          |
| "foo"          | anything else  |
| True           | False          |
| False          | True           |
|________________|________________|

Answer 7

Answers should be able to specify what is truthy and what is falsy

Almost all of the answers here are either ambiguous or put some languages at a disadvantage.

For the top rated answer, there are many languages that don't have conditionals: Bitwise Cyclic Tag, any Turing Machine, etcetera.

For the answers that give values beforehand for what is truthy and what is falsy, what about languages with booleans such as fact or lie and win or lose? You can always fix these exceptions, but there will be more as the development of esolangs (or some practical languages too) will arise to new names for boolean/truthy and falsy values.

This is why I say that the answerer should specify what counts as a truthy value and what counts as a falsy value. This is to prevent an answer wasting too many bytes just because their truthy/falsy value wasn't on the list.

Answer 8

For a different view: Output and implementation are something different. A truthy/falsy value is an output that everybody with basic knowledge of common languages recognizes as truthy/falsy, regardless whether that is evaluated to true/false inside a programming language. It will be one of the following:

Truthy:

1. The string True in any capitalization
2. The string 1
3. A floating point string representation of 1.0e0 -/+ eps(1)
4. In case of functions: a boolean true. integer 1 or float 1.0e0 -/+ eps(1).

Falsy:

1. The string False in any capitalization
2. The string 0
3. A floating point string representation of 0 -/+ eps(0).
4. In case of functions: a boolean false, integer 0 or float 1.0e0 -/+ eps(1).

Both outputs may have leading or trailing spaces and newlines. Iff your language doesn't support any of the above, you should attempt to find the closest alternative. In all cases, all truthy and falsy outputs should be the exact same for your program, regardless of input.

I believe that in practice, these options will be accepted by all programmers to mean truthy or falsy, and eliminate loopholes. For example, cat could be a prime testing program if you define the set of all prime numbers as 'thruthy'.

Besides, if I ask you 'Are there any German spies around here', I want you to reply 'nein', not nine. In other words, a positive integer is not an answer to a true/false question. Neither is returning a set of all German spies, and claiming it's false if the set is empty.

Answer 9

This truthy vs falsey concept is way too ambiguous. Questions should be required to state exactly which values represent TRUE and which represent FALSE.