Boolean data type

Language-specific implementations

ALGOL and the built-in BOOLEAN type

One of the earliest programming languages to provide an explicit BOOLEAN data type is ALGOL 60 (1960) with values true and false and logical operators denoted by symbols '${\displaystyle \wedge }$' (and), '${\displaystyle \vee }$' (or), '${\displaystyle \supset }$' (implies), '${\displaystyle \equiv }$' (equivalence), and '${\displaystyle \mathrm{\neg }}$' (not). Due to input device and character set limits on many computers of the time, however, most compilers used alternative representations for many of the operators, such as AND or 'AND'.

This approach with BOOLEAN as a built-in (either primitive or otherwise predefined) data type was adopted by many later programming languages, such as Simula 67 (1967), ALGOL 68 (1970), Pascal (1970), Ada (1980), Java (1995), and C# (2000), among others.

C, C++, D, Objective-C, AWK

Initial implementations of the language C (1972) provided no Boolean type, and to this day Boolean values are commonly represented by integers (ints) in C programs. The comparison operators (>, ==, etc.) are defined to return a signed integer (int) result, either 0 (for false) or 1 (for true). Logical operators (&&, ||, !, etc.) and condition-testing statements (if, while) assume that zero (and hence a NULL pointer or a null string terminator '\0' also) is false and all other values are true.

After enumerated types (enums) were added to the American National Standards Institute version of C, ANSI C (1989), many C programmers got used to defining their own Boolean types as such, for readability reasons. However, enumerated types are equivalent to integers according to the language standards; so the effective identity between Booleans and integers is still valid for C programs.

Standard C (since C99) provides a Boolean type, called _Bool. Since C23, the Boolean is now a core data type called bool, with values true and false (previously these were provided by macros from the header stdbool.h, which is now obsolete). The language guarantees that any two true values will compare equal (which was impossible to achieve before the introduction of the type). Boolean values still behave as integers, can be stored in integer variables, and used anywhere integers would be valid, including in indexing, arithmetic, parsing, and formatting. This approach (Boolean values are just integers) has been retained in all later versions of C. Note, that this does not mean that any integer value can be stored in a Boolean variable.

C++ has had the Boolean data type bool since C++98, but with automatic conversions from scalar and pointer values that are very similar to those of C. This approach was adopted also by many later languages, especially by some scripting languages such as AWK.

The D programming language has a proper Boolean data type bool. The bool type is a byte-sized type that can only hold the value true or false. The only operators that can accept operands of type bool are: &, |, ^, &=, |=, ^=, !, &&, || and ?:. A bool value can be implicitly converted to any integral type, with false becoming 0 and true becoming 1. The numeric literals 0 and 1 can be implicitly converted to the bool values false and true, respectively. Casting an expression to bool means testing for 0 or !=0 for arithmetic types, and null or !=null for pointers or references.

Objective-C also has a separate Boolean data type BOOL, with possible values being YES or NO, equivalents of true and false respectively. Also, in Objective-C compilers that support C99, C's _Bool type can be used, since Objective-C is a superset of C.

Forth

Forth (programming language) has no Boolean type, it uses regular integers: value 0 (all bits low) represents false, and -1 (all bits high) represents true. This allows the language to define only one set of logical operators, instead of one for mathematical calculations and one for conditions.

Fortran

The first version of FORTRAN (1957) and its successor FORTRAN II (1958) have no logical values or operations; even the conditional IF statement takes an arithmetic expression and branches to one of three locations according to its sign; see arithmetic IF. FORTRAN IV (1962), however, follows the ALGOL 60 example by providing a Boolean data type (LOGICAL), truth literals (.TRUE. and .FALSE.), logical IF statement, Boolean-valued numeric comparison operators (.EQ., .GT., etc.), and logical operators (.AND., .OR., and .NOT.). In FORMAT statements, a specific format descriptor ('L') is provided for the parsing or formatting of logical values. A common extension prior to FORTRAN 77 was to extend the .EQ. and .NE. operators, or perhaps add a .XOR. operator for comparing Boolean expressions. Fortran 77 added .EQV. and .NEQV. operators to standardize the operations. Fortran 90 added alternative comparison operators <, <=, ==, /=, >, and >=.

Java

In Java, the value of the boolean data type can only be either true or false.

Unity

In Unity, the value of the boolean (also known as the bool) can be either true or false and is used in scripting.

Lisp and Scheme

The language Lisp (1958) never had a built-in Boolean data type. Instead, conditional constructs like cond assume that the logical value false is represented by the empty list (), which is defined to be the same as the special atom nil or NIL; whereas any other s-expression is interpreted as true. For convenience, most modern dialects of Lisp predefine the atom t to have value t, so that t can be used as a mnemonic notation for true.

This approach (any value can be used as a Boolean value) was retained in most Lisp dialects (Common Lisp, Scheme, Emacs Lisp), and similar models were adopted by many scripting languages, even ones having a distinct Boolean type or Boolean values; although which values are interpreted as false and which are true vary from language to language. In Scheme, for example, the false value is an atom distinct from the empty list, so the latter is interpreted as true. Common Lisp, on the other hand, also provides the dedicated boolean type, derived as a specialization of the symbol.

Pascal, Ada, and Haskell

The language Pascal (1970) popularized the concept of programmer-defined enumerated types, previously available with different nomenclature in COBOL, FACT and JOVIAL. A built-in Boolean data type was then provided as a predefined enumerated type with values FALSE and TRUE. By definition, all comparisons, logical operations, and conditional statements applied to and/or yielded Boolean values. Otherwise, the Boolean type had all the facilities which were available for enumerated types in general, such as ordering and use as indices. In contrast, converting between Booleans and integers (or any other types) still required explicit tests or function calls, as in ALGOL 60. This approach (Boolean is an enumerated type) was adopted by most later languages which had enumerated types, such as Modula, Ada, and Haskell.

Perl and Lua

Perl has no Boolean data type. Instead, any value can behave as Boolean in Boolean context (condition of if or while statement, argument of && or ||, etc.). The number 0, the strings "0" and "", the empty list (), and the special value undef evaluate to false. All else evaluates to true.

Lua has a Boolean data type, but non-Boolean values can also behave as Booleans. The non-value nil evaluates to false, whereas every other data type value evaluates to true. This includes the empty string "" and the number 0, which are very often considered false in other languages.

PL/I

PL/I has no Boolean data type. Instead, comparison operators generate BIT(1) values; '0'B represents false and '1'B represents true. The operands of, e.g., &, |, ¬, are converted to bit strings and the operations are performed on each bit. The element-expression of an IF statement is true if any bit is 1.

Python and Ruby

Python, from version 2.3 forward, has a bool type which is a subclass of int, the standard integer type. It has two possible values: True and False, which are special versions of 1 and 0 respectively and behave as such in arithmetic contexts. Also, a numeric value of zero (integer or fractional), the null value (None), the empty string, and empty containers (lists, sets, etc.) are considered Boolean false; all other values are considered Boolean true by default. Classes can define how their instances are treated in a Boolean context through the special method __nonzero__ (Python 2) or __bool__ (Python 3). For containers, __len__ (the special method for determining the length of containers) is used if the explicit Boolean conversion method is not defined.

In Ruby, in contrast, only nil (Ruby's null value) and a special false object are false; all else (including the integer 0 and empty arrays) is true.

Rexx

Rexx has no Boolean data type. Instead, comparison operators generate 0 or 1; 0 represents false and 1 represents true. The operands of, e.g., &, |, ¬, must be 0 or 1.

ooRexx

ooRexx provides TRUE and FALSE constants in the Environment directory, with values 1 and 0. Normal style is .TRUE and .FALSE rather than, e.g., .environment["TRUE"], .environment["FALSE"].

SQL

Booleans appear in SQL when a condition is needed, such as WHERE clause, in form of predicate which is produced by using operators such as comparison operators, IN operator, IS (NOT) NULL etc. However, apart from TRUE and FALSE, these operators can also yield a third state, called UNKNOWN, when comparison with NULL is made.

The SQL92 standard introduced IS (NOT) TRUE, IS (NOT) FALSE, and IS (NOT) UNKNOWN operators which evaluate a predicate, which predated the introduction of Boolean type in SQL:1999.

The SQL:1999 standard introduced a BOOLEAN data type as an optional feature (T031). When restricted by a NOT NULL constraint, a SQL BOOLEAN behaves like Booleans in other languages, which can store only TRUE and FALSE values. However, if it is nullable, which is the default like all other SQL data types, it can have the special null value also. Although the SQL standard defines three literals for the BOOLEAN type – TRUE, FALSE, and UNKNOWN — it also says that the NULL BOOLEAN and UNKNOWN "may be used interchangeably to mean exactly the same thing". This has caused some controversy because the identification subjects UNKNOWN to the equality comparison rules for NULL. More precisely UNKNOWN = UNKNOWN is not TRUE but UNKNOWN/NULL. As of 2012 few major SQL systems implement the T031 feature. Firebird and PostgreSQL are notable exceptions, although PostgreSQL implements no UNKNOWN literal; NULL can be used instead.

The treatment of Boolean values differs between SQL systems.

For example, in Microsoft SQL Server, Boolean value is not supported at all, neither as a standalone data type nor representable as an integer. It shows the error message "An expression of non-Boolean type specified in a context where a condition is expected" if a column is directly used in the WHERE clause, e.g. SELECT a FROM t WHERE a, while a statement such as SELECT column IS NOT NULL FROM t yields a syntax error. The BIT data type, which can only store integers 0 and 1 apart from NULL, is commonly used as a workaround to store Boolean values, but workarounds need to be used such as UPDATE t SET flag = IIF(col IS NOT NULL, 1, 0) WHERE flag = 0 to convert between the integer and Boolean expression.

Microsoft Access, which uses the Access Database Engine (ACE/JET), also does not have a Boolean data type. Similar to MS SQL Server, it uses a BIT data type. In Access it is known as a Yes/No data type which can have two values; Yes (True) or No (False). The BIT data type in Access can also be represented numerically: True is −1 and False is 0. This differs from MS SQL Server in two ways, even though both are Microsoft products:

1. Access represents TRUE as −1, while it is 1 in SQL Server
2. Access does not support the Null tri-state, supported by SQL Server

PostgreSQL has a distinct BOOLEAN type as in the standard, which allows predicates to be stored directly into a BOOLEAN column, and allows using a BOOLEAN column directly as a predicate in a WHERE clause.

In MySQL, BOOLEAN is treated as an alias of TINYINT(1); TRUE is the same as integer 1 and FALSE is the same as integer 0. Any non-zero integer is true in conditions.

Tableau

Tableau Software has a BOOLEAN data type. The literal of a Boolean value is True or False.

The Tableau INT() function converts a Boolean to a number, returning 1 for True and 0 for False.

Tcl

Tcl has no separate Boolean type. Like in C, the integers 0 (false) and 1 (true—in fact any nonzero integer) are used.

Examples of coding:

<span id="mwAmc"></span><span class="w" id="mwAmg"> </span><span class="k" id="mwAmk">set</span><span class="w" id="mwAmo"> </span>v<span class="w" id="mwAms"> </span><span class="mi" id="mwAmw">1</span> <span class="w" id="mwAm0"> </span><span class="k" id="mwAm4">if</span><span class="w" id="mwAm8"> </span><span class="k" id="mwAnA">{</span><span class="w" id="mwAnE"> </span><span class="nv" id="mwAnI">$v</span><span class="w" id="mwAnM"> </span><span class="k" id="mwAnQ">}</span><span class="w" id="mwAnU"> </span><span class="k" id="mwAnY">{</span><span class="w" id="mwAnc"> </span><span class="nb" id="mwAng">puts</span><span class="w" id="mwAnk"> </span><span class="s2" id="mwAno">"V is 1 or true"</span><span class="w" id="mwAns"> </span><span class="k" id="mwAnw">}</span>

The above will show V is 1 or true since the expression evaluates to 1.

<span id="mwAoE"></span><span class="w" id="mwAoI"> </span><span class="k" id="mwAoM">set</span><span class="w" id="mwAoQ"> </span>v<span class="w" id="mwAoU"> </span><span class="s2" id="mwAoY">""</span> <span class="w" id="mwAoc"> </span><span class="k" id="mwAog">if</span><span class="w" id="mwAok"> </span><span class="k" id="mwAoo">{</span><span class="w" id="mwAos"> </span><span class="nv" id="mwAow">$v</span><span class="w" id="mwAo0"> </span><span class="k" id="mwAo4">}</span><span class="w" id="mwAo8"> </span>....

The above will render an error, as variable v cannot be evaluated as 0 or 1.

Truthy

In some programming languages, any expression can be evaluated in a context that expects a Boolean data type. Typically (though this varies by programming language) expressions like the number zero, the empty string, empty lists, and null are treated as false, and strings with content (like "abc"), other numbers, and objects evaluate to true. Sometimes these classes of expressions are called falsy and truthy. For example, in Lisp, nil, the empty list, is treated as false, and all other values are treated as true. In C, the number 0 or 0.0 is false, and all other values are treated as true.

In JavaScript, the empty string (""), null, undefined, NaN, +0, −0 and false are sometimes called falsy (of which the complement is truthy) to distinguish between strictly type-checked and coerced Booleans (see also: JavaScript syntax#Type conversion). As opposed to Python, empty containers (arrays, maps, sets) are considered truthy. Languages such as PHP also use this approach.