Boolean values
You are encouraged to solve this task according to the task description, using any language you may know.
Show how to represent the boolean states "true" and "false" in a language. If other objects represent "true" or "false" in conditionals, note it.
- Cf.
ACL2
Same as Common Lisp.
Ada
Ada has a predefined discrete type with the specification: <lang Ada> type Boolean is (False, True);</lang> with Boolean lattice and relational operations defined on it. See RM A.1.
AutoHotkey
When an expression is required to evaluate to true or false (such as an IF-statement), a blank or zero result is considered false and all other results are considered true. Operators such as NOT/AND/OR/>/=/< automatically produce a true or false value: they yield 1 for true and 0 for false. A variable can be used to hold a false value simply by making it blank or assigning 0 to it. The words 'true' and 'false' are built-in variables containing 1 and 0. They can be used to make a script more readable.
ALGOL 68
ALGOL 68 Enforces strong typing and so has few default coercions. The appropriate operators must be used to convert to and from bool[ean] and the following code demonstrates principle conversions: <lang algol68>BOOL f = FALSE, t = TRUE; []BOOL ft = (f, t); STRING or = " or "; FOR key TO UPB ft DO
BOOL val = ft[key];
UNION(VOID, INT) void = (val|666|EMPTY);
REF STRING ref = (val|HEAP STRING|NIL);
INT int = ABS val;
REAL real = ABS val;
COMPL compl = ABS val;
BITS bits = BIN ABS val; # or bitspack(val); #
BYTES bytes = bytes pack((val|"?"|null char)*bytes width);
CHAR char = (val|"?"|null char);
STRING string = (val|"?"|"");
print((((val | "TRUE" | "FALSE" ), ": ", val, or, (val|flip|flop), new line)));
print((" void: ", " => ", (void|(VOID):FALSE|TRUE), new line));
print((" ref: ", " => ", ref ISNT REF STRING(NIL), new line));
print((" int: ", int , " => ", int /= 0, new line));
print((" real: ", real , " => ", real /= 0, new line));
print((" compl: ", compl , " => ", compl /= 0, new line));
print((" bits: ", bits , " => ", ABS bits /= 0, or, bits /= 2r0, or,
bits width ELEM bits, or, []BOOL(bits)[bits width], new line));
print((" bytes: """, STRING(bytes) , """ => ", 1 ELEM bytes /= null char, or,
STRING(bytes) /= null char*bytes width, or,
STRING(bytes)[1] /= null char, new line));
print((" char: """, char , """ => ", ABS char /= 0 , or, char /= null char, new line));
print(("string: """, string , """ => ", string /= "", or, UPB string /= 0, new line));
print((new line))
OD</lang> Output:
FALSE: F or F void: => F ref: => F int: +0 => F real: +0.00000000000000e +0 => F compl: +0.00000000000000e +0+0.00000000000000e +0 => F bits: FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF => F or F or F or F bytes: "" => F or F or F char: "" => F or F string: "" => F or F TRUE: T or T void: => T ref: => T int: +1 => T real: +1.00000000000000e +0 => T compl: +1.00000000000000e +0+0.00000000000000e +0 => T bits: FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFT => T or T or T or T bytes: "????????????????????????????????" => T or T or T char: "?" => T or T string: "?" => T or T
Note: The string repr[esentation] of false and true are defined by the variables flop and flip respectively.
Applesoft BASIC
IF statement condition treats any non-zero numeric value as true. Comparison operators evaluate to 1 (true) or 0 (false). Examples:<lang ApplesoftBASIC>? 2 = 3 ? 2 = 2 IF 7 THEN ?"HELLO"</lang>
Output:
0 1 HELLO
AWK
There is no keyword for true or false in awk. In awk, any nonzero numeric value or any nonempty string value is true. Any other value (zero or the null string "") is false. Values containing only zeros may produce true or false depending on whether they are obtained from the datasource or by assignment, and different results may be obtained according to which version of awk is being used.
- Reference: AWK Truth values
In the following example we use zero for false, and one for true to assign boolean values. However, this is just a convention, so other values may also have been used:
<lang awk>BEGIN {
# Do not put quotes round the numeric values, or the tests will fail a = 1 # True b = 0 # False
# Boolean evaluations
if (a) { print "first test a is true" } # This should print
if (b) { print "second test b is true" } # This should not print
if (!a) { print "third test a is false" } # This should not print
if (!b) { print "forth test b is false" } # This should print
# Boolean evaluation using comparison against zero
if (a == 0) { print "fifth test a is false" } # This should not print
if (b == 0) { print "sixth test b is false" } # This should print
if (a != 0) { print "seventh test a is true" } # This should print
if (b != 0) { print "eighth test b is true" } # This should not print
}</lang>
AppleScript
AppleScript has built-in boolean keywords true and false. Numbers do not work in place of boolean expressions.
BASIC
Most BASICs have no keywords for true and false. Boolean expressions evaluate to 0 when false, and a non-zero value (traditional versions of basic use a value of one, although some variants use a value of negative one) when true. Numbers also work in place of boolean expressions following those rules.
<lang basic>10 LET A%=0 20 LET B%=NOT(A%) 30 PRINT "THIS VERSION OF BASIC USES" 40 PRINT B%; " AS ITS TRUE VALUE" 50 IF A% THEN PRINT "TEST ONE DOES NOT PRINT" 60 IF B% THEN PRINT "TEST TWO DOES PRINT" 70 IF A%=0 THEN PRINT "TEST THREE (FALSE BY COMPARISON) DOES PRINT" 80 IF B%=0 THEN PRINT "TEST FOUR (FALSE BY COMPARISON) DOES NOT PRINT" 90 IF A%<>0 THEN PRINT "TEST FIVE (TRUE BY COMPARISON) DOES NOT PRINT" 100 IF B%<>0 THEN PRINT "TEST SIX (TRUE BY COMPARISON) DOES PRINT" 110 END</lang>
BASIC256
<lang basic256> ' BASIC256 used numbers to represent true and false ' values. Zero is false and anything else is true. ' The built in constants true and false exist ' and represent one and zero respectively.
print false print true </lang>
BBC BASIC
<lang bbcbasic> REM BBC BASIC uses integers to represent Booleans; the keywords
REM FALSE and TRUE equate to 0 and -1 (&FFFFFFFF) respectively:
PRINT FALSE
PRINT TRUE</lang>
Befunge
Zero is false, non-zero is true. This is only used by the horizontal and vertical switch operators (_ and |).
Brainf***
Zero is false, non-zero is true. This is only used by the loop brackets ([ and ]).
C
In C, a value which is equal to 0 is false, while a value which is not equal to 0 is true. Relational and logical operators evaluate to 0 for false and 1 for true. Any of the following can be used:
- any integer type, where 0 gives false, and any other value gives true (note that in C, character types are also integer types, therefore this also applies to characters: the
'\0'character is false) - any floating point type, where again, 0 gives false and everything else gives true
- any enumeration type, again 0 gives false, anything else true
- any pointer type, where the null pointer gives false and any other pointer gives true
- in C99, the boolean type
bool(defined in header <stdbool.h>), wheretruegives true andfalsegives false - in C99, any complex number type, where 0 (0 real and 0 imaginary) gives false, anything else gives true
C++
In C++, there are the constants true and false to represent those values. However, there are numerous implicit conversions to bool, therefore in conditions (and other contexts expecting boolean values), any of the following can be used:
- any integer type, where 0 converts to false, and any other value converts to true (note that in C++, character types are also integer types, therefore this also applies to characters: the
'\0'character is false) - any floating point type, where again, 0 gives false and everything else gives true
- any enumeration type, again 0 gives false, anything else true
- any pointer type, where the null pointer gives false and any other pointer gives true
- any user-defined type with an implicit conversion operator either to
boolor to a built-in type which itself can be converted tobool(i.e. any of the above). The C++ standard library contains one such implicit conversion: the implicit conversion of a streamstoboolgives!s.fail()
C#
In C#, there are the reserved keywords true and false. Variables to hold these values are declared as either bool or Boolean. These types are identical, as bool is just shortand for Boolean. The collection type BitArray returns its values as Boolean, packing 8 values into each byte (In contrast, the Boolean type uses the entire byte for one value).
Unlike C/C++, there is no conversion in C# between other types and Boolean.
Clean
The standard library defines a data type Bool, which has exactly two members:
<lang clean>::Bool = False | True</lang>
In addition to all the functionality of any other Clean algebraic data type (e.g. pattern matching), and the specified derived typeclass instances, the built-in guard (“|”) and if syntaxes use Bool.
As with any other Clean data type, there are no automatic conversions of other types to Bool.
Clojure
The boolean constants are true and false. In a conditional context, the only false values are false and nil -- every other value is true.
CMake
<lang cmake>foreach(var 1 42 ON yes True y Princess
0 OFF no False n Princess-NOTFOUND)
if(var)
message(STATUS "${var} is true.")
else()
message(STATUS "${var} is false.")
endif()
endforeach(var)</lang>
-- 1 is true. -- 42 is true. -- ON is true. -- yes is true. -- True is true. -- y is true. -- Princess is true. -- 0 is false. -- OFF is false. -- no is false. -- False is false. -- n is false. -- Princess-NOTFOUND is false.
The strings "0", "OFF", "NO", "FALSE" and "N" (ignoring case) are false. Any string ending with "-NOTFOUND" (ignoring case) is false. All other strings are true.
Scripts that want if(TRUE) should require CMake 2.8; do refer to cmake --help-policy CMP0012.
COBOL
Booleans
Booleans are defined as any data item having a PICTURE made up of ones.
<lang cobol> 01 some-bool PIC 1 BIT.</lang>
The boolean literals B"1" and B"0" represent true and false, respectively.
Conditions
Prior to COBOL 2002, there was no boolean data type, only condition names which could be used in conditional expressions. Condition names are subordinate to another data item, have the level-number 88, and are defined with the value(s) which their parent data item must have for them to be set to true. They can be defined like so: <lang cobol> 01 X PIC 9.
88 X-Is-One VALUE 1.
88 X-Is-Even VALUE 0 2 4 6 8.
88 X-Larger-Than-5 VALUE 6 THRU 9.</lang>
Conditions can be SET to TRUE or FALSE. Setting a condition to TRUE will move the (first) value in the VALUE clause to the parent data item. In COBOL 2002, an optional FALSE clause was added which allowed the condition to be SET to FALSE and consequently set the parent data item to the specified value in the clause. A FALSE clause can only have one value. An example of conditions in action:
<lang cobol> PROGRAM-ID. Condition-Example.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Foo PIC 9 VALUE 5.
88 Is-Not-Zero VALUE 1 THRU 9
WHEN SET TO FALSE IS 0.
PROCEDURE DIVISION.
Main.
PERFORM Is-Foo-Zero
SET Is-Not-Zero TO FALSE
PERFORM Is-Foo-Zero
SET Is-Not-Zero TO TRUE
PERFORM Is-Foo-Zero
GOBACK
.
Is-Foo-Zero.
IF Is-Not-Zero
DISPLAY "Foo is not zero, it is " Foo "."
ELSE
DISPLAY "Foo is zero."
END-IF
.</lang>
- Output:
Foo is not zero, it is 5. Foo is zero. Foo is not zero, it is 1.
CoffeeScript
CoffeeScript is largely based on JavaScript, but that may only serve to confuse you. Your best bet is to learn all the cases:
<lang coffeescript> h1 = {foo: "bar"} h2 = {foo: "bar"}
true_expressions = [
true
1
h1? # because h1 is defined above
not false
!false
[]
{}
1 + 1 == 2
1 == 1 # simple value equality
true or false
]
false_expressions = [
false not true undeclared_variable? 0 null undefined h1 == h2 # despite having same key/values 1 == "1" # different types false and true
] </lang>
Common Lisp
The only value in Common Lisp that is false is the symbol nil; all other values are true. The symbol t is the canonical true value.
Considered as variables, nil and t are bound to themselves ("self-evaluating"). nil, as well as being false, is used as the empty list; i.e. an empty list is false.
For more information, follow the links from CLHS: Type BOOLEAN.
Component Pascal
<lang oberon2> VAR
b,c: BOOLEAN;
</lang> ... <lang oberon2>
b := TRUE; c := FALSE;
</lang> ...
D
In D, there are constants true and false to represent their respective values. Implicit conversions are listed below:
- any integer type, where 0 converts to false, and any other value converts to true
- any floating point type, where again, 0 gives false and everything else gives true
- any enumeration type, again 0 gives false, anything else true
- any pointer type, where the null pointer gives false and any other pointer gives true
- any reference type, where the null reference gives false and any other reference gives true
- any user-defined type with an implicit conversion operator either to bool or to a built-in type which itself can be converted to bool
Delphi
Delphi (like Pascal) has standard ordinal Boolean type with two values: True and False, Ord(False) = 0, Ord(True) = 1
Delphi also defines BOOL, ByteBool, WordBool and LongBool types (to simplify C functions' import). For these types zero value is False and any nonzero value is True.
DWScript
The standard Boolean type has two values: True and False, with Ord(False) = 0 and Ord(True) = 1.
Dylan
<lang Dylan>#t // <boolean> true
- f // <boolean> false</lang>
For the purpose of conditional statements, all objects other than #f evaluate to true.
E
E defines two basic objects true and false, and the boolean guard which accepts them. All builtin operations which take booleans (e.g. the if control structure) coerce the input to boolean.
<lang e>? if (true) { "a" } else { "b" }
- value: "a"
? if (false) { "a" } else { "b" }
- value: "b"
? if (90) { "a" } else { "b" }
- problem: the int 90 doesn't coerce to a boolean</lang>
No objects in the standard library coerce to boolean, but user-written objects may choose to do so; they can then be used in place of booleans.
<lang e>? def bowlian { > to __conformTo(guard) { > if (guard == boolean) { return true } > } > } > if (bowlian) { "a" } else { "b" }
- value: "a"</lang>
Emacs Lisp
Symbol nil is false and symbol t is true. Both are self-evaluating, being variables whose value is their own symbol. See the elisp manual for more.
In an if and similar, nil is false and anything else is true. To make that clear docstrings etc say "non-nil" for true. (See last item in elisp manual documentation tips.)
Erlang
Erlang doesn't technically define boolean types. Instead, the atoms true and false are used. However, they are integrated well enough into the language there should be no problem with that as long as you don't expect false and true to mean anything but literal false and true.
<lang erlang>1> 1 < 2. true 2> 1 < 1. false 3> 0 == false. false</lang>
EGL
In EGL boolean is a primitive type, however it acts the same as an integer (type int). A boolean and an int accept integer values aswel as true and false keywords (which represent resp. 1 and 0). A boolean is always true except when it has value 0 (or keyword false). A boolean can be converted to a string ("true" or "false") using StrLib.booleanAsString(boolean);
<lang EGL> myBool boolean = 0; SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool)); myBool = 1; SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool)); myBool = 2; SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool)); myBool = false; SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool)); myBool = true; SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool)); myInt int = 0; SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt)); myInt = 1; SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt)); myInt = 2; SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt)); myInt = false; SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt)); myInt = true; SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt)); </lang> Output
myBool: false myBool: true myBool: true myBool: false myBool: true myInt: false myInt: true myInt: true myInt: false myInt: true
Excel
The Logical category of functions includes the constants TRUE() and FALSE() which are displayed without the parantheses in cells. There are logical functions such as AND and OR too. For an AND truth table of two variables, take 3 cells, say A1,B1 and C1. In C1 type in :
<lang excel> =AND(A1;B1) </lang>
Copy this until C4. Now as values are filled in from A1-A4 and B1-B4, C1-C4 gets updated.
<lang> 0 0 FALSE 0 1 FALSE 1 0 FALSE 1 1 TRUE </lang>
F#
The type bool is an abbreviation for the .NET framework type System.Boolean. <lang fsharp>type bool = System.Boolean</lang> Instances of this type have values of either true or false.
Factor
In Factor any value except f is true, with t being the canonical true value.
FALSE
Zero is false and non-zero is true. This is used by the if and while operators (? and #). Comparators (= and <) yield -1 for true and 0 for false.
Fantom
Conditional statements must return a sys::Bool, and the only two values are true and false.
Forth
In conditionals, zero is false, non-zero is true. There are predefined constants for the canonical forms. For FORTH-83 or later, FALSE is zero and TRUE is -1 (all bits set). For earlier FORTH standards, FALSE is zero and TRUE is 1. <lang forth>TRUE . \ -1 FALSE . \ 0</lang>
Fortran
Fortran has a logical data type which can be set to either .true. or .false..
GAP
<lang gap>1 < 2;
- true
2 < 1;
- false
- GAP has also the value fail, which cannot be used as a boolean but may be used i$
1 = fail;
- false
fail = fail;
- true</lang>
Go
Go defines a built-in data type bool, which has exactly two values, represented by the keywords true and false. There is no conversion between booleans and other data types. Conditionals require a boolean value, so if i is a numeric type, for example, you must spell out if i != 0 { if you wish to interpret it as boolean.
The template package however, uses a different rule for if actions. There, it is testing if a "pipeline" is "empty" where the empty values are false, 0, any nil pointer or interface value, and any array, slice, map, or string of length zero.
Groovy
Groovy has a boolean "primitive" type and a Boolean "object wrapper" type directly derived from Java. See the Java solution to this task for more details.
Unlike Java, any null reference converts to a boolean "false", while any non-null object reference converts to a boolean "true"... EXCEPT if that object has a specific defined conversion to boolean "false". For example, for any numeric type, any zero value representation converts to "false" and any non-zero value converts to "true". For any collection type, non-empty converts to "true" and empty converts to "false".
Haskell
The Haskell standard Prelude defines a data type Bool, which has exactly two members:
<lang haskell>data Bool = False | True deriving (Eq, Ord, Enum, Read, Show, Bounded)</lang>
In addition to all the functionality of any other Haskell algebraic data type (e.g. pattern matching), and the specified derived typeclass instances (e.g. False == False, succ False == True, (maxBound :: Bool) == True, etc.), the built-in guard (“|”) and if syntaxes use Bool.
As with any other Haskell data type, there are no automatic conversions of other types to Bool.
HicEst
Zero is false, non-zero is true. Numbers also work in place of boolean expressions following this rule.
Icon and Unicon
Icon and Unicon do not use Boolean values for flow control. Rather they use success (returning a result, any result even a null) or failure (a signal) for this purpose. Built-in controls support not, and (&), and or (|). For an example of how this works, see Short Circuit Evaluation. Icon and Unicon do support bit operations on integers which could be used to record Boolean state. See also Logical Operations for an example of how and when Boolean values might be implemented.
Inform 6
Inform 6 has the constants true and false, which are identical to 1 and 0 respectively. One of these values will always be yielded by a condition operator (an operator that yields a boolean value). In addition, any non-zero value is considered to be true.
Inform 7
The Boolean type is called "truth state" and has the values "true" and "false".
However, Inform 7 distinguishes between Boolean values and conditions. Comparison expressions do not return truth states, and truth state expressions cannot be used directly in conditional statements. There is a conversion from condition to truth state: <lang inform7>let B be whether or not 123 is greater than 100;</lang> And truth states can be used in conditions by adding an explicit comparison: <lang inform7>if B is true, say "123 is greater than 100."</lang>
Phrases (functions) cannot be defined to return a truth state directly. Instead, they are defined using "to decide whether" (or "to decide if") and can then be used as conditions: <lang inform7>To decide whether the CPU is working correctly: if 123 is greater than 100, decide yes; otherwise decide no.
When play begins: [convert to truth state...] let B be whether or not the CPU is working correctly; [...or use as a condition] if the CPU is working correctly, say "Whew."</lang>
J
False is 0, true is 1. This is an advantage.
Java
Java has true and false keywords, representing the only values of type boolean. There are also object wrappers Boolean.TRUE and Boolean.FALSE, of type Boolean which may be un-boxed into booleans (auto-unboxed in Java 1.5+). There are no automatic conversions from any other types into boolean, and it is a compile-time error to use any type other than boolean or Boolean in a place that expects a boolean (e.g. if-statement condition, while-statement condition, operand of a logical operator, etc.).
JavaScript
The Boolean type has two values: true and false
The following table shows the result of type conversions to boolean:
- Undefined: any undefined value is converted to
false - Null:
false - Number: the numbers
0,-0,NaNarefalse; otherwisetrue - String: the empty (zero-length) string is
false; otherwisetrue - Object: any object is converted to
true
(source: ECMAScript Language Reference)
Julia
Conditional expressions only accept literal boolean values `true` and `false` <lang julia>julia> t = true true
julia> typeof(t) Bool julia> if 1
println("true")
end
ERROR: type: non-boolean (Int64) used in boolean context</lang> The `bool()` function can be used to convert to boolean <lang julia>julia> bool
- methods for generic function bool
bool(x::Bool) at bool.jl:9 bool(x::Number) at bool.jl:10 bool(x::AbstractArray{Bool,N}) at abstractarray.jl:219 bool(x::AbstractArray{T,N}) at abstractarray.jl:220 julia> bool(-2:2) 5-element Bool Array:
true true false true true</lang>
KonsolScript
The Boolean type has two values: true and false
The following table shows the result of type conversions to boolean:
- Number: the number
0isfalse; otherwisetrue - String: the empty (zero-length) string is
false; otherwisetrue
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LFE
<lang lisp> > 'true true > 'false false > (or 'false 'false) false > (or 'false 'true) true </lang>
Liberty BASIC
IF-statement, loop condition treats any non-zero integer as true. Comparison operators evaluate to 1 (true) or 0 (false).
Logo
Logo has predefined symbols for true and false ("true and "false), which are the values returned by predicates and required by logical operators and conditionals. <lang logo>print 1 < 0 ; false print 1 > 0 ; true if "true [print "yes] ; yes if not "false [print "no] ; no</lang> Unlike other lispy languages, there are no other implicit conversions. You must test explicitly for zero or empty collections. <lang logo>if equal? 0 ln 1 [print "zero] if empty? [] [print "empty] ; empty list if empty? "|| [print "empty] ; empty word</lang>
Lua
All values in Lua other than false or nil are considered true:
<lang lua>if 0 then print "0" end -- This prints
if "" then print"empty string" end -- This prints
if {} then print"empty table" end -- This prints
if nil then print"this won't print" end
if true then print"true" end
if false then print"false" end -- This does not print</lang>
Mathematica
True and False are the default boolean values. To make any expression a boolean use the Boole[] function.
MATLAB
The keywords "true" and "false" are the default boolean values. But, many functions prefer to return boolean "1" or "0" instead of "true" or "false". It is very important to note that having a function return a numerical 1 or 0 is not the same as a boolean "1" or "0". To make a number or array of numbers a boolean use the logical() function. logical() will convert any non-zero number to a boolean "1" and any zero entries a boolean "0".
Sample Usage: (islogical() is a function that returns a boolean "1" if the input is a boolean, "0" otherwise)
<lang MATLAB>>> islogical(true)
ans =
1
>> islogical(false)
ans =
1
>> islogical(logical(1))
ans =
1
>> islogical(logical(0))
ans =
1
>> islogical(1)
ans =
0
>> islogical(0)
ans =
0</lang>
Maxima
<lang maxima>is(1 < 2); /* true */
is(2 < 1); /* false */
not true; /* false */
not false; /* true */</lang>
Metafont
Metafont has the type boolean; a boolean variable can be true or false. Using non boolean values (or expressions that do not evaluate to a boolean value) results in a recoverable error; by default, any non-boolean value is interpreted as false.
Mirah
<lang mirah>import java.util.ArrayList import java.util.HashMap
- booleans
puts 'true is true' if true puts 'false is false' if (!false)
- lists treated as booleans
x = ArrayList.new puts "empty array is true" if x x.add("an element") puts "full array is true" if x puts "isEmpty() is false" if !x.isEmpty()
- maps treated as booleans
map = HashMap.new puts "empty map is true" if map map.put('a', '1') puts "full map is true" if map puts "size() is 0 is false" if !(map.size() == 0)
- these things do not compile
- value = nil # ==> cannot assign nil to Boolean value
- puts 'nil is false' if false == nil # ==> cannot compare boolean to nil
- puts '0 is false' if (0 == false) # ==> cannot compare int to false
- puts 'TRUE is true' if TRUE # ==> TRUE does not exist
- puts 'FALSE is false' if !FALSE # ==> FALSE does not exist
</lang>
Modula-2
<lang modula2>MODULE boo;
IMPORT InOut;
VAR result, done : BOOLEAN;
A, B : INTEGER;
BEGIN
result := (1 = 2);
result := NOT result;
done := FALSE;
REPEAT
InOut.ReadInt (A);
InOut.ReadInt (B);
done := A > B
UNTIL done
END boo.</lang>
Modula-3
Similar to Ada, Modula-3 has a built-in BOOLEAN type defined as <lang modula3>TYPE BOOLEAN = {FALSE, TRUE}</lang>
MUMPS
M[UMPS] has no data types per se, however, any value can be coerced to a specific interpretation by applying certain operators.
Internally, the language treats any "zero" value as a "false", and any "non-zero"
value as a "true".
Values like 1, 2, 13245.08763, .1, "0.00001234ABC" and "1234ABC" are "true".
Values like 0, -3, "", " 123" (note the leading space in this one),
"+++++567", "abc", "abc1245" are "false".
When a boolean operator is applied to an operand, the value of that operand is coerced to a logical value, that is: if the value starts out with a sequence of digits that look like a non-zero number, the value is "true" (1), and otherwise that value is "false" (0).
There are two standardized binary boolean operators: & (and) and ! (or). Newer implementations of the language may also support !! (exclusve or). There is one unary boolean operator: ' (not).
Nemerle
In Nemerle, boolean values are held in variables of type bool, and can be either true or false. Comparison expressions evaluate to boolean values as well.
NetRexx
NetRexx inherits boolean functionality directly from the Java virtual machine with the exception that the true and false keywords are not defined to the language.
Defining true and false variables can lead to name collisions during compilation so a simple expedient is to define boolean functions isTrue
and isFalse to return the appropriate values.
<lang NetRexx>/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
bval = [1, 0, 5, 'a', 1 == 1, 1 \= 1, isTrue, isFalse]
loop b_ = 0 for bval.length
select case bval[b_] when isTrue then say bval[b_] 'is true' when isFalse then say bval[b_] 'is false' otherwise say bval[b_] 'is not boolean' end end b_
method isTrue public static returns boolean
return (1 == 1)
method isFalse public static returns boolean
return \isTrue
</lang> Output:
1 is true 0 is false 5 is not boolean a is not boolean 1 is true 0 is false 1 is true 0 is false
Objective-C
Objective-C follows pretty much the same rules as C. In addition to C, Objective-C has a BOOL boolean type, with values YES for true and NO for false. Objective-C also adds several special types of pointers; for pointers to objects (values of type id), the nil pointer is false, everything else is true; for pointers to classes (values of type Class), the Nil pointer is false, everything else is true.
Objeck
Objeck has a Bool type that is set to either true or false. By default boolean types are initialized to false. The boolean type also allows methods to be invoked, which perform simple conversions or print given values.
OCaml
OCaml defines a built-in data type bool, which has exactly two members, represented by the keywords true and false:
<lang ocaml>type bool = false | true</lang>
In addition to all the functionality of any other OCaml algebraic data type (e.g. pattern matching), and the functionality of any other OCaml data type (e.g. comparisons false = false, false < true, etc.), bool is also used in the guards in pattern matching (“when”) and if and while syntaxes.
As with any other OCaml data type, there are no automatic conversions of other types to bool.
Octave
Octave uses true (1) and false (0). The class of a variable holding a boolean value is logical, which however can be casted to a numeric class, so that r = true; r * 2 gives 2 as result. Any non-zero value is interpreted as true, and 0 as false.
ooRexx
.true or 1 are true, .false or 0 are false
Order
Order supplies the keywords 8true and 8false. Other types are not supposed to automatically convert to any boolean value (in practice some may do so due to implementation quirks, but this is not reliable).
Oz
true and false are the only boolean values. No other values are automatically converted to bool.
PARI/GP
Generally, false is 0 and true is nonzero. Certain other values also behave as false, like the vector [0]. Built-in boolean functions use 0 and 1.
Pascal
In all flavors of pascal there is no such foolishness as numbers of empty strings or pointers ( initialized or otherwise ) being evaluated as boolean. There is the boolean type as defined by the RTL statements such as: <lang pascal> var
pInt : ^integer ; ValidP : boolean ;
</lang>
<lang pascal> if pInt then ... </lang>
or
<lang pascal> if pInt^ then ... </lang>
Will always be a syntax error. The following correct evaluations of variables are allowed:
<lang pascal> if not(pInt = nil) then ValidP := true ; </lang>
or
<lang pascal> if ( ValidP ) and (pInt^ <> 0) then ... </lang>
Perl
<lang perl>my $x = 0.0; my $true_or_false = $x ? 'true' : 'false'; # false</lang> or <lang perl>my $x = 1; # true
my $true_or_false;
if ($x) {
$true_or_false = 'true';
} else {
$true_or_false = 'false';
}</lang> The values in Perl that are false are: 0 (as a number (including 0.0), or as the string '0', but not the string '0.0'), the empty string '', the empty list (), and undef. Everything else is true. See perlsyn.
Short circuit evaluations
Boolean comparison of zero against itself gives a value of one, but Perl uses short circuit evaluations, so any true or false value may be returned from a boolean expression:
<lang perl>print (7 && 2); # 2, rather than 1(true) print (2 && 7); # 7, rather than 1(true) print (7 xor 2); # empty string, rather than 0(false) print ('apples' && 'pears'); # pears, rather than 1(true) print ('apples' xor 'pears'); # empty string, rather than 0(false)</lang>
Objects
Objects may break these rules at will via overloading.
There are no keywords for true and false
Perl has no builtin "true" or "false" keywords. This is a caveat, because true and false are bareword strings and evaluate to true:
<lang perl># This does not work
- true and false are not special so will be treated as bareword strings
if (true) { print "true is true\n" }; # This prints if (false) { print "false is true\n" }; # So does this if (spongebob) { print "spongebob is true\n" }; # A bareword string</lang>
Special cases
As a special case, literal 1s and 0s will never cause a "Useless use of a constant in void context" warning. Another special case worth pointing out here is that the string '0 but true' won't provoke a warning if it's used as a number.
Perl 6
Perl 6 provides an enumeration Bool with two values, True and False. Values of enumerations can be used as ordinary values or as mixins:
<lang perl6>my Bool $crashed = False; my $val = 0 but True;</lang>
For a discussion of Boolean context (i.e. how Perl decides whether something is true or false), see Synopsis 2.
PHP
The values in PHP that are false are: FALSE, NULL, the number 0 (as an integer 0, float 0.0, or string '0', but not the string "0.0"), the empty string "", the empty array array(), and "SimpleXML objects created from empty tags"(?).
Everything else is true. The keyword TRUE exists. [1]
PicoLisp
Like in all Lisps, the symbol 'NIL' denotes "false", any other value "true". PicoLisp also uses NIL as the empty list, so the empty list is false.
Some functions return the symbol 'T' for "true" if no other useful (non-NIL) value is available in the given context. Note that 'NIL' and 'T' are written in uppercase letters (PicoLisp is case-sensitive).
Pike
<lang pike> > 0; (3) Result: 0 > false; (4) Result: 0 > 0; (6) Result: 0 > !true; (7) Result: 0 > true; (8) Result: 1 > 1; (9) Result: 1 > </lang>
PL/I
<lang PL/I> true is '1'b and false is '0'b </lang>
PowerBASIC
In addition to what's noted above under BASIC, PowerBASIC for Windows and PowerBASIC Console Compiler have the ISTRUE and ISFALSE functions. According to the help file, they "return the logical truth or falsity of a given expression". (PowerBASIC lacks a boolean data type, so the usual practice is to use integers in PB/DOS, and longs in PB/CC and PB/Win.)
<lang powerbasic>DIM x AS LONG x = ISTRUE(1 = 1) ' returns -1 x = ISTRUE(1 = 0) ' returns 0 x = ISFALSE(1 = 1) ' returns 0 x = ISFALSE(1 = 0) ' returns -1</lang>
PostScript
Predefined constants are:
<lang> true false </lang>
PowerShell
Two automatic variables exist for this purpose: <lang powershell>$true $false</lang> However, nearly everything can be converted to a boolean value, as detailed in the following list:
- any non-zero number evaluates to true, zero evaluates to false
- any non-empty string evaluates to true, an empty string evaluates to false
- an empty array evaluates to false
- an array containing exactly one item evaluates to whatever the only item evaluates to
- any array with more than one item evaluates to true
- a reference to any object evaluates to true,
$nullevaluates to false
PureBasic
PureBasic does not have a Boolean variable type. An integer type is typically used instead. Boolean values are only supported as part of a loop's condition (While/Wend, Repeat/Until) or in a conditional (If/Endif). In these cases if the result of a variable or a numeric expression is zero it is evaluated as False, otherwise it is evaluated as True. A string variable assigned a null string would be evaluated as False.
Python
Python has a boolean data type with the only two possible values denoted by True and False.
The boolean type is a member of the numeric family of types, and when used in a numeric, but not boolean context, True has the value one and False the value zero. Conversely, when numbers are used in a boolean context, zero is False and anything other than zero is True.
In a boolean context, Python extends what is meant by true and false by accepting empty collection types, such as an empty dict or an empty list as being False, and non-empty collection types as being True, so in an if statement one might branch on a list which would be the same as testing if the list had any contents.
A user-created class that defines a .__nonzero__() method to return False, or whose .__len__() method returns 0 will be treated as False, otherwise the class/instance is treated as True.
None is also False in a boolean context.
Some examples: <lang python>>>> True True >>> not True False >>> # As numbers >>> False + 0 0 >>> True + 0 1 >>> False + 0j 0j >>> True * 3.141 3.141 >>> # Numbers as booleans >>> not 0 True >>> not not 0 False >>> not 1234 False >>> bool(0.0) False >>> bool(0j) False >>> bool(1+2j) True >>> # Collections as booleans >>> bool([]) False >>> bool([None]) True >>> 'I contain something' if (None,) else 'I am empty' 'I contain something' >>> bool({}) False >>> bool("") False >>> bool("False") True</lang>
R
Similarly to Octave, R uses TRUE and FALSE, kept in variable of class logical, which is silently casted to 1 (TRUE) or 0 (FALSE) if used as numeric value. The opposite is also true: the value 0 can be used as FALSE, and non-zero numbers as TRUE.
The values T and F are given the values TRUE and FALSE respectively (for compatibility with S-Plus), though these may be changed to other values by the user.
Racket
Racket has the standard Scheme Boolean values #t and #f, and will also accept #true and #false. This is a literal syntax, so it can be used anywhere including in quoted positions. There are also bindings for true and false (but of course when these are quoted, the result is plain symbols). Like other Scheme descendants, many conditional constructs treat any non-false value as "truthy." So, for instance,
<lang Racket>(cond ([(< 4 3) 'apple]
['bloggle 'pear]
[else 'nectarine])</lang>
... evaluates to 'pear, because 'bloggle is not false.
Raven
Raven considers 0 as FALSE, -1 as TRUE <lang Raven>TRUE print FALSE print 2 1 > print # TRUE (-1) 3 2 < print # FALSE (0) 42 FALSE != # TRUE (-1)</lang>
REBOL
REBOL uses values of type logic! to represent boolean values. A boolean value can be 'true' or 'false', which also happen to be understood as predefined constants. Other constants are also provided to improve program readability:
| True | False |
|---|---|
| true | false |
| yes | no |
| on | off |
| any [block! series! date! number! string! ...] | none |
As the last true value implies, pretty much any other type will evaluate to true. This is important to remember if you're used to a language where the value "0" is considered to be false -- in REBOL, it's true.
Retro
Zero is false and non-zero is true. Comparison functions return -1 for true and 0 for false.
REXX
The REXX language enforces the values for true & false, only the two values are valid:
- 0 (zero) [for false]
- 1 (one) [for true ]
The following aren't true or false:
- 0.
- 0.0
- 00
- 1.
- 1.0
- 001
- +1
- 2
- (a null value, that is, length=0)
- any value with a blank before/in/after the value.
simple version
<lang rexx> true = 1 false = 0</lang>
spruced up version
Some programmers line to "spruce up" such a simple assignment: <lang rexx>true = (1=1) false = (1=0)</lang>
more exactingness
<lang rexx>true = (1==1) false = (1==0)</lang>
oblique
<lang rexx>true = (1==1)
false = \true</lang>
[The parenthesis aren't necessary in the above versions.]
Some REXX interpreters allow the NOT (¬) character for negation:
<lang rexx>false = ¬true</lang>
esoteric
<lang rexx>true = 1984 = 1984 false = 'war' = 'peace' false = 'freedom' = 'slavery' false = 'ignorance' = 'strength'</lang> Of course, in Orwellian terms, the above false statements are true, but REXX isn't an Eric Arthur Blair reader.
Ruby
The only values in Ruby that are false are: false and nil. They have synonyms FALSE and NIL.
Everything else is true. Constants true (and TRUE) exist. Note for Python and Perl users: unlike Python, in Ruby, the number 0, the empty string, the empty array, and the empty hash, etc. are all true; you can instead use the zero? method to test for 0, and the .empty? method to test for an empty sequence.
false, nil and true are singleton instances of classes FalseClass, NilClass and TrueClass respectively.
[2]
Run BASIC
Basically 0 is false and 1 is true <lang runbasic>if 1 then print "1 is true" if not(0) then print "0 is false" if 1 < 2 then print "1 < 2 TRUE" if 2 > 1 then print "2 > 1 TRUE" if not(2 < 1) then print "2 not < 1" if not(1 = 0) then print "1 not = 0"</lang>
Sather
The BOOL type can be true or false. Sather never implicitly does casting of a type in another, so numeric value or other types cannot be used (implicitly) as boolean value; nonetheless an explicit "cast" can be done:
<lang sather>v:BOOL := true; -- ok i:INT := 1; v := 1; -- wrong if i then ... end; -- wrong: if requires a bool! -- BUT v := 1.bool; -- ok if i.bool then ... end; -- ok</lang>
In this case, 0.bool is false, and n.bool with n not equal to 0 is true.
Scala
Booleans in Scala are given by the literals true and false, case sensitive, which are the only instances of the class Boolean.
Scheme
The only value in Scheme that is false is #f.
Everything else (including the empty list, unlike Lisp) is true. The constant #t represents the canonical true value.
Seed7
Seed7 defines the type boolean. The only values of boolean are TRUE and FALSE. There are no automatic conversions from any other types into boolean, and it is a compile-time error to use any type other than boolean in a place that expects a boolean (e.g. if-statement condition, while-statement condition, operand of a logical operator, etc.).
Slate
Use True or False.
Smalltalk
Smalltalk uses the Boolean class, which has two subclasses (True and False). true and false are singleton instances of those classes. E.g. an expression like 5 = 5 returns true.
SNUSP
Zero is false and non-zero is true, as used by the sole skip-if-zero operator (?). <lang snusp>$!/?\=false= + =true=#
\-/</lang>
Standard ML
Standard ML defines a top-level data type bool, which has exactly two members, true and false:
<lang sml>datatype bool = false | true</lang>
In addition to all the functionality of any other Standard ML algebraic data type (e.g. pattern matching, equality false = false), bool is also used in if and while syntaxes.
As with any other Standard ML data type, there are no automatic conversions of other types to bool.
Tcl
- True values
- 1 (or other non-zero number, e.g., 42), true, yes, on
- False values
- 0 (or other zero number, e.g., 0.0), false, no, off
Any of these values may be abbreviated, and mixed-case spellings are also acceptable. [3] Any other value gives an error. In an interactive tclsh session: <lang tcl>% if {""} then {puts true} else {puts false} expected boolean value but got ""</lang>
Test for the boolean value of a string can be stuff like <lang tcl>if {[string is false -strict $string]} ...</lang> which will test for "no" or "NO" or "0" or "False" or ...
TI-89 BASIC
There are boolean literals true and false. No other values may be used where a boolean is expected.
Trith
The boolean constants are true and false. In a conditional context, the only false values are false and nil -- every other value is true.
UNIX Shell
The traditional Bourne shell does not provide a reserved keyword for true or false.
Truth is determined by exit codes rather than values
The evaluation of true and false within the shell is different to the evaluation of truth from within a high level language. Within the shell, a truth is based on the exitcode of the last command in the evaluation block:
- An exitcode of zero is considered to be a true condition
- An exitcode of nonzero is considered to be a false condition
In the following example, after running the test command, the then syntactical component runs the optional branch if an exitcode is of zero determined:
<lang sh>if
echo 'Looking for file' # This is the evaluation block test -e foobar.fil # The exit code from this statement determines whether the branch runs
then
echo 'The file exists' # This is the optional branch echo 'I am going to delete it' rm foobar.fil
fi</lang>
In some later shells, the values true and false are defined, respectively, as a return code of 0 and a return code of greater-than zero. While there are built-in functions for each of these values, booleans are most commonly the result of a test or a process termination.
<lang Bash>true && echo "true" || echo "false"</lang>
Visual Basic
VB has the Boolean data type and the constants True and False, in addition to what's listed under BASIC, above. When used outside of a boolean context, True and False return values depending on their context -- -1 and 0 in a numeric context, "True" and "False" if used as strings.
<lang vb>Dim x As Boolean x = IIf(Int(Rnd * 2), True, False) MsgBox x</lang>
XPL0
An integer value equal to 0 is false, and a value not equal to 0 is true. Relational operations evaluate to 0 for false and -1 for true. The command word 'true' equals -1, and 'false' equals 0.
XSLT
<lang xml><xsl:if test="true() or false()">
True and false are returned by built-in XPath functions.
</xsl:if> <xsl:if test="@myAttribute='true'">
Node attributes set to "true" or "false" are just strings. Use string comparison to convert them to booleans.
</xsl:if> <xsl:if test="@myAttribute or not($nodeSet)">
Test an attribute for its presence (empty or not), or whether a node set is empty.
</xsl:if></lang>
- Programming Tasks
- Basic language learning
- ACL2
- Ada
- AutoHotkey
- ALGOL 68
- Applesoft BASIC
- AWK
- AppleScript
- BASIC
- BASIC256
- BBC BASIC
- Befunge
- Brainf***
- C
- C++
- C sharp
- Clean
- Clojure
- CMake
- COBOL
- CoffeeScript
- Common Lisp
- Component Pascal
- D
- Delphi
- DWScript
- Dylan
- E
- Emacs Lisp
- Erlang
- EGL
- Excel
- F Sharp
- Factor
- FALSE
- Fantom
- Forth
- Fortran
- GAP
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Inform 6
- Inform 7
- J
- Java
- JavaScript
- Julia
- KonsolScript
- LabVIEW
- LFE
- Liberty BASIC
- Logo
- Lua
- Mathematica
- MATLAB
- Maxima
- Metafont
- Mirah
- Modula-2
- Modula-3
- MUMPS
- Nemerle
- NetRexx
- Objective-C
- Objeck
- OCaml
- Octave
- OoRexx
- Order
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- PL/I
- PowerBASIC
- PostScript
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raven
- REBOL
- Retro
- REXX
- Ruby
- Run BASIC
- Sather
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- SNUSP
- Standard ML
- Tcl
- TI-89 BASIC
- Trith
- UNIX Shell
- Visual Basic
- XPL0
- XSLT
- ML/I/Omit