Boolean values: Difference between revisions

[[Category:Simple]]

 

;Task:

*   [[Logical operations]]

<br><br>

=={{header|360 Assembly}}==

The are no TRUE or FALSE constants in 360 Assembly; but an often used convention is :

=={{header|8051 Assembly}}==

A single bit represents true or false. By convention, 0 (cleared) is false, 1 (set) is true.

In the following, "bit" represents the direct address of any of the 256 directly accessible bits.

 

=={{header|ACL2}}==

Same as [[Common Lisp|Boolean Values#Common Lisp]].

 

=={{header|Ada}}==

[[Ada]] has a predefined discrete type with the specification:

with Boolean lattice and relational operations defined on it. See [http://www.adaic.org/standards/1zrm/html/RM-A-1.html RM A.1].

=={{header|ALGOL 68}}==

{{trans|python}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - note: null char is missing, AND the C generated is won't compile, so some conversions are missing from RS}}

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:

[]BOOL ft = (f, t);

STRING or = " or ";

print(("string: """, string , """ => ", string /= "", or, UPB string /= 0, new line));

print((new line))

 

{{out}}

</pre>

Note: The '''string''' '''repr'''[esentation] of '''false''' and '''true''' are defined by the variables ''flop'' and ''flip'' respectively.

=={{header|ALGOL W}}==

The boolean type is called logical in Algol W - the values are represented by the keywords true and false. Numbers, strings etc. cannot be used where logical values are required.

=={{header|APL}}==

0 and 1 are used for boolean types in APL (as in J below).

1 ^ 1

1

1 ^ 0

0

=={{header|AppleScript}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

When an expression is required to evaluate to true or false (such as an <code>IF</code>-statement), a blank or zero result is considered false and all other results are considered true. Operators such as <code>NOT</code>/<code>AND</code>/<code>OR</code>/<code>></code>/<code>=</code>/<code><</code> 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.

 

=={{header|AWK}}==

 

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:

 

# Do not put quotes round the numeric values, or the tests will fail

a = 1 # True

if (b != 0) { print "eighth test b is true" } # This should not print

 

=={{header|Axe}}==

In Axe, there are no keywords for true and false. Any expression that evaluates to zero is considered false, and any expression that evaluates to non-zero is considered true. Unlike other languages, there is no canonical value for true (e.g. 1).

=={{header|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.

 

20 LET B%=NOT(A%)

30 PRINT "THIS VERSION OF BASIC USES"

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"

 

a = TRUE

b = FALSE

IF 0 THEN PRINT "TRUE" : ELSE PRINT "FALSE"

IF 1 THEN PRINT "TRUE"

 

{{out}}

TRUE</pre>

 

' BASIC256 used numbers to represent true and false

' values. Zero is false and anything else is true.

print false

print true

 

REM FALSE and TRUE equate to 0 and -1 (&FFFFFFFF) respectively:

PRINT FALSE

 

=={{header|bc}}==

POSIX bc doesn't define Boolean values (i.e. it's up to the programmer which values represent false and true).

 

In GNU bc, 0 is false and any other value is true (but the result of a boolean expression will always be 1 if it is true).

=={{header|Befunge}}==

Zero is false, non-zero is true. This is only used by the horizontal and vertical switch operators (<code>_</code> and <code>|</code>).

 

=={{header|Bracmat}}==

Bracmat operates with success and failure instead of true and false. Success and failure play the same role as true and false in conditional tests, but they are not values like true and false. Instead, success and failure are properties of expressions in addition to values. The simplest failing expression is the atomic expression <code>~</code>. The simplest succeeding atomic expression is the empty string <code>""</code> (or <code>()</code>). A slightly more complex failing expression is <code>1+1:3</code>, which postulates that <code>3</code> matches the result of adding <code>1</code> and <code>1</code>, while <code>1+1:2</code> of course succeeds.

=={{header|Brainf***}}==

Zero is false, non-zero is true. This is only used by the loop brackets (<code>[</code> and <code>]</code>).

=={{header|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:

* in C99, the boolean type <code>bool</code> (defined in header <tt><stdbool.h></tt>), where <code>true</code> gives true and <code>false</code> gives false

* in C99, any [[Complex numbers|complex number]] type, where 0 (0 real and 0 imaginary) gives false, anything else gives true

 

=={{header|C++}}==

In C++, there are the constants <code>true</code> and <code>false</code> to represent those values. However, there are numerous implicit conversions to <code>bool</code>, therefore in conditions (and other contexts expecting boolean values), any of the following can be used:

* 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 <code>bool</code> or to a built-in type which itself can be converted to <code>bool</code> (i.e. any of the above). The C++ standard library contains one such implicit conversion: the implicit conversion of a stream <code>s</code> to <code>bool</code> gives <code>!s.fail()</code>

=={{header|Clean}}==

 

The standard library defines a data type <code>Bool</code>, which has exactly two members:

 

 

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 (“<code>|</code>”) and <code>if</code> syntaxes use Bool.

 

As with any other Clean data type, there are no automatic conversions of other types to Bool.

=={{header|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.

=={{header|CMake}}==

0 OFF no False n Princess-NOTFOUND)

if(var)

message(STATUS "${var} is false.")

endif()

 

<pre>-- 1 is true.

 

Scripts that want <code>if(TRUE)</code> should require CMake 2.8; do refer to [http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0012 cmake --help-policy CMP0012].

=={{header|COBOL}}==

===Booleans===

Booleans are defined as any data item having a <code>PICTURE</code> made up of ones.

 

The boolean literals <code>B"1"</code> and <code>B"0"</code> 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:

88 X-Is-One VALUE 1.

88 X-Is-Even VALUE 0 2 4 6 8.

 

Conditions can be <code>SET</code> to <code>TRUE</code> or <code>FALSE</code>. Setting a condition to <code>TRUE</code> will move the (first) value in the <code>VALUE</code> clause to the parent data item. In COBOL 2002, an optional <code>FALSE</code> clause was added which allowed the condition to be <code>SET</code> to <code>FALSE</code> and consequently set the parent data item to the specified value in the clause. A <code>FALSE</code> clause can only have one value. An example of conditions in action:

 

DATA DIVISION.

DISPLAY "Foo is zero."

END-IF

 

{{out}}

Foo is not zero, it is 1.

</pre>

=={{header|CoffeeScript}}==

CoffeeScript is largely based on JavaScript, but that may only serve to confuse you. Your best bet is to learn all the cases:

 

h1 = {foo: "bar"}

h2 = {foo: "bar"}

false and true

]

=={{header|Common Lisp}}==

The only value in Common Lisp that is false is the symbol <code>nil</code>; all other values are true. The symbol <code>t</code> is the canonical true value.

 

For more information, follow the links from [http://www.lispworks.com/documentation/HyperSpec/Body/t_ban.htm CLHS: Type BOOLEAN].

=={{header|Component Pascal}}==

VAR

b,c: BOOLEAN;

c := FALSE;

...

 

=={{header|D}}==

In D, there are constants <code>false</code> and <code>true</code> to represent their respective values (that also implicitly convert to 0 and 1).

* Any class reference type, using the "is" operator, the null reference gives false and any other reference gives true;

* Any user-defined type with an implicit conversion operator (opCast) either to bool or to a built-in type which itself can be converted to bool.

=={{header|Delphi}}==

=={{header|DWScript}}==

The standard <code>Boolean</code> type has two values: <code>True</code> and <code>False</code>, with <code>Ord(False) = 0</code> and <code>Ord(True) = 1</code>.

 

=={{header|Dylan}}==

For the purpose of conditional statements, all objects other than <tt>#f</tt> evaluate to true.

 

=={{header|E}}==

 

E defines two basic objects <code>true</code> and <code>false</code>, and the <code>boolean</code> [http://wiki.erights.org/wiki/Guard guard] which accepts them. All builtin operations which take booleans (e.g. the <code>if</code> control structure) coerce the input to boolean.

 

# value: "a"

 

 

? if (90) { "a" } else { "b" }

 

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.

 

> to __conformTo(guard) {

> if (guard == boolean) { return true }

> }

> if (bowlian) { "a" } else { "b" }

 

=={{header|EchoLisp}}==

"All that which is not false is true" - Attribué à L. Wittgenstein - The only false value is the boolean #f. '''All''' other objects, including the empty list or null or 0 ..- evaluate to #t = true.

(not #t) → #f

(not #f) → #t

(not null) → #f

(not 0) → #f

 

 

 

=={{header|EGL}}==

A boolean can be converted to a string ("true" or "false") using StrLib.booleanAsString(boolean);

 

myBool boolean = 0;

SysLib.writeStdout("myBool: " + StrLib.booleanAsString(myBool));

myInt = true;

SysLib.writeStdout("myInt: " + StrLib.booleanAsString(myInt));

 

{{out}}

myInt: true

</pre>

=={{header|Elena}}==

ELENA uses the system'BaseBoolValue class, which has two singleton sub-classes: system'true and system'false. E.g. an expression like 5 == 5 returns system'true.

There is a Boolean variable : system'Boolean.

=={{header|Elixir}}==

Elixir utilizes Erlang's definition of boolean types; they're defined as the atoms <tt>:true</tt> and <tt>:false</tt>. No other type is equal to true or false.

iex(1)> true === :true

true

iex(3)> true === 1

false

 

nil (also defined as an atom, <tt>:nil</tt>) is not equal to false.

iex(4)> nil === :nil

true

iex(5)> nil === false

false

=={{header|Elm}}==

--True and False directly represent Boolean values in Elm

--For eg to show yes for true and no for false

display expr=

div [] [ text ( toString expr ++ "-->" ++ toString(evaluate expr) ) ]

=={{header|Emacs Lisp}}==

Symbol <code>nil</code> is false and symbol <code>t</code> is true. Both are self-evaluating, being variables whose value is their own symbol. See [http://www.gnu.org/software/emacs/manual/html_node/elisp/nil-and-t.html the elisp manual] for more.

 

In an <code>if</code> and similar, <code>nil</code> is false and anything else is true. To make that clear docstrings etc say "non-nil" for true. (See last item in [http://www.gnu.org/software/emacs/manual/html_node/elisp/Documentation-Tips.html elisp manual documentation tips].)

 

=={{header|Erlang}}==

Erlang doesn't technically define boolean types. Instead, the atoms <tt>true</tt> and <tt>false</tt> 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.

 

true

2> 1 < 1.

false

3> 0 == false.

=={{header|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 :

 

 

Copy this until C4. Now as values are filled in from A1-A4 and B1-B4, C1-C4 gets updated.

 

0 1 FALSE

1 0 FALSE

=={{header|F_Sharp|F#}}==

The type bool is an abbreviation for the .NET framework type <code>System.Boolean</code>.

Instances of this type have values of either <code>true</code> or <code>false</code>.

=={{header|Factor}}==

In Factor any value except <code>f</code> is true, with <code>t</code> being the canonical true value.

=={{header|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.

=={{header|Fantom}}==

 

Conditional statements must return a <code>sys::Bool</code>, and the only two values are <code>true</code> and <code>false</code>.

=={{header|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.

=={{header|Fortran}}==

Fortran started off in 1957 with only floating-point and fixed-point variables, so any calculations in the style of Boolean arithmetic would be done with integer values such as zero and not-zero, using multiplication and addition for '''and''' and '''or'''.

Fortran 66 introduced a '''logical''' data type which can be set to either '''.true.''' or '''.false.''' or be generated via logical expressions such as <=, etc. Such variables cannot be used in normal arithmetic with operators such as +-*/ but only with logical operators such as .OR. and so on. If via the EQUIVALENCE statement their numerical values (or, bit patterns) are inspected as say an integer, the values may well not be as anticipated and differ between computers and compilers. For instance, on the Burroughs 6700 an '''integer''' variable equivalenced to a '''logical''' variable would appear as '''.true.''' if odd, '''.false.''' if even.

 

LOGICAL*1 LIVE

REAL*8 VALUE

END TYPE MIXED

LOGICAL*1 LIVE(100)

REAL*8 VALUE(100)

END TYPE MIXED

Except that now only hundred-element variables of type MIXED can be declared. Either way, the record size needed for a disc file holding such items will need careful thought.

 

 

 

 

 

 

 

 

 

 

=={{header|Futhark}}==

 

Futhark has a <code>bool</code> type, with the two values <code>True</code> and <code>False</code>. They are used for branching.

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=65324112fde86d51937b9cfcca0c51f9 Click this link to run this code]'''

Dim bX As Boolean

 

Print bX

 

Output:

<pre>

True

</pre>

=={{header|GAP}}==

# true

 

 

fail = fail;

=={{header|Go}}==

Go defines a built-in data type <code>bool</code>, which has exactly two values, represented by the keywords <code>true</code> and <code>false</code>. 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 <tt>if i != 0 {</tt> if you wish to interpret it as boolean.

The template package however, uses a different rule for <tt>if</tt> 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.

 

=={{header|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".

=={{header|Haskell}}==

 

The Haskell standard [http://haskell.org/haskellwiki/Prelude Prelude] defines a data type <code>Bool</code>, which has exactly two members:

 

 

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. <code>False == False</code>, <code>succ False == True</code>, <code>(maxBound :: Bool) == True</code>, etc.), the built-in guard (“<code>|</code>”) and <code>if</code> syntaxes use Bool.

 

As with any other Haskell data type, there are no automatic conversions of other types to Bool.

=={{header|HicEst}}==

Zero is false, non-zero is true. Numbers also work in place of boolean expressions following this rule.

=={{header|HolyC}}==

In HolyC, there are the reserved keywords `TRUE` and `FALSE`. Variables to hold these values are declared as `Bool`.

* Any floating point type, where again, 0 gives false and everything else gives true.

* Any pointer type, where the null pointer gives false and any other pointer gives true.

=={{header|i}}==

Any non-zero number is true in 'i'.

 

 

=={{header|Idris}}==

Data type Prelude.Bool.Bool : Type

Boolean Data Type

 

True : Bool

=={{header|Inform 6}}==

Inform 6 has the constants <code>true</code> and <code>false</code>, which are identical to <code>1</code> and <code>0</code> 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.

=={{header|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:

And truth states can be used in conditions by adding an explicit comparison:

 

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:

if 123 is greater than 100, decide yes;

otherwise decide no.

let B be whether or not the CPU is working correctly;

[...or use as a condition]

 

=={{header|J}}==

 

 

This approach also works well with [[wp:Bayes'_theorem|Bayes' theorem]], as false matches 0% probability and true matches 100% probability.

=={{header|Java}}==

 

=={{header|JavaScript}}==

 

(source: [http://www.ecma-international.org/publications/standards/Ecma-262.htm ECMAScript Language Reference])

 

=={{header|jq}}==

 

Other objects do not represent boolean values and cannot be used in conditional expressions, for example:

println("true")

end

However, integers can be converted to boolean types with the <code>bool()</code> function (which treats nonzero values as <code>true</code>)

5-element Bool Array:

true

false

true

=={{header|KonsolScript}}==

The Boolean type has two values: <code>true</code> and <code>false</code>

=={{header|Kotlin}}==

Booleans in Kotlin are given by the literals true and false, case sensitive, which are the only instances of the class Boolean.

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Boolean_values.png}}

 

=={{header|Lasso}}==

Comparisons are evaluated in Lasso as either true of false, so "1 == 2" will evaluate as true, and "1 == 1" will evaluate as true.

A variable can also be assigned a boolean type, and as such then holds either true of false states.

 

// => false

 

 

$x = false

 

In a conditional, if the result is the integer 0, it is also evaluated as boolean false.

If the conditional results in an integer greater than zero, it is evaluated as boolean true.

 

// size is 0

#x->size ? 'yes' | 'no'

local(x = '123fsfsd')

// size is 8

 

{{out}}

<pre>no

yes</pre>

 

=={{header|LFE}}==

> 'true

true

> (or 'false 'true)

true

=={{header|Lingo}}==

Lingo has the constants TRUE and FALSE. In numerical context they have the values 1 and 0. In boolean context any nonzero integer evaluates to TRUE.

-- 1

put FALSE

-- 0

if 23 then put "Hello"

=={{header|Little}}==

For conditionals, numeric variables (including poly variables

 

 

int b = 1;

int c;

if (!defined(c)) {puts("fourth test is true");} // This should print

if (str1) {puts("fifth test str1 is true");} // This should print

=={{header|LiveCode}}==

true and the string "true" are both logical true, similarly for false and "false" being logical false.

=={{header|Logo}}==

Logo has predefined symbols for true and false (<code>"true</code> and <code>"false</code>), which are the values returned by predicates and required by logical operators and conditionals.

print 1 > 0 ; true

if "true [print "yes] ; yes

Unlike other lispy languages, there are no other implicit conversions.

You must test explicitly for zero or empty collections.

if empty? [] [print "empty] ; empty list

=={{header|Lua}}==

All values in Lua other than <code>false</code> or <code>nil</code> are considered <code>true</code>:

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

 

Module CheckBoolean {

A=True

loop

}

}

Wait 100

}

CheckBoolean

 

 

=={{header|Maple}}==

The keywords "true" and "false" are the default boolean values.

Expressions under assumptions may be evaluated logically using the <code>is</code> command.

Types may be tested, resulting in boolean values, using the <code>type</code> command.

True and False are the default boolean values.

=={{header|MATLAB}}==

The keywords "true" and "false" are the default boolean values.

Sample Usage: (islogical() is a function that returns a boolean "1" if the input is a boolean, "0" otherwise)

 

 

ans =

ans =

 

=={{header|Maxima}}==

/* true */

 

 

not false;

=={{header|Metafont}}==

Metafont has the type <tt>boolean</tt>; a boolean variable can be <tt>true</tt> or <tt>false</tt>.

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.

 

=={{header|Mirah}}==

import java.util.HashMap

 

#puts 'FALSE is false' if !FALSE # ==> FALSE does not exist

 

=={{header|Modula-2}}==

 

IMPORT InOut;

done := A > B

UNTIL done

=={{header|Modula-3}}==

Similar to [[Ada]], Modula-3 has a built-in <tt>BOOLEAN</tt> type defined as

=={{header|Monte}}==

 

Much like [[E]], Monte has built-in objects <tt>true</tt> and <tt>false</tt>, and a boolean [http://wiki.erights.org/wiki/Guard guard].

 

def example(input :boolean):

if input:

return "Input was true!"

return "Input was false."

=={{header|MUMPS}}==

 

Newer implementations of the language may also support !! (exclusve or).

There is one unary boolean operator: ' (not).</p>

 

=={{header|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.

=={{header|NetRexx}}==

NetRexx inherits boolean functionality directly from the [[Java]] virtual machine with the exception that the <code>true</code> and <code>false</code> keywords are not defined to the language.

Defining <code>true</code> and <code>false</code> variables can lead to name collisions during compilation so a simple expedient is to define boolean functions <code>isTrue</code>

and <code>isFalse</code> to return the appropriate values.

options replace format comments java crossref savelog symbols nobinary

 

method isFalse public static returns boolean

return \isTrue

 

{{out}}

0 is false

</pre>

=={{header|Nim}}==

if false: echo "no"

 

# Other objects never represent true or false:

=={{header|Oberon-2}}==

VAR

a,b,c: BOOLEAN;

b := FALSE;

c := 1 > 2;

=={{header|Objeck}}==

Objeck has a <tt>Bool</tt> type that is set to either <tt>true</tt> or <tt>false</tt>. By default boolean types are initialized to <tt>false</tt>. The boolean type also allows methods to be invoked, which perform simple conversions or print given values.

 

=={{header|Objective-C}}==

Objective-C follows pretty much the same rules as C. In addition to C, Objective-C has a <code>BOOL</code> boolean type, with values <code>YES</code> for true and <code>NO</code> for false. Objective-C also adds several special types of pointers; for pointers to objects (values of type <code>id</code>), the <code>nil</code> pointer is false, everything else is true; for pointers to classes (values of type <code>Class</code>), the <code>Nil</code> pointer is false, everything else is true.

=={{header|OCaml}}==

 

OCaml defines a built-in data type <code>bool</code>, which has exactly two members, represented by the keywords <code>true</code> and <code>false</code>:

 

 

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 <code>false = false</code>, <code>false < true</code>, etc.), <code>bool</code> is also used in the guards in pattern matching (“<code>when</code>”) and <code>if</code> and <code>while</code> syntaxes.

 

As with any other OCaml data type, there are no automatic conversions of other types to <code>bool</code>.

=={{header|Octave}}==

Octave uses <tt>true</tt> (1) and <tt>false</tt> (0). The class of a variable holding a boolean value is ''logical'', which however can be casted to a numeric class, so that <code>r = true; r * 2</code> gives 2 as result. Any non-zero value is interpreted as true, and 0 as false.

=={{header|Oforth}}==

Oforth uses <tt>true</tt> (1) and <tt>false</tt> (0)

 

Any non-zero value is interpreted as true, and 0 as false.

=={{header|Ol}}==

 

 

p.s. Empty lists - '() - in conditionals is True.

=={{header|ooRexx}}==

 

<tt>.true</tt> or <tt>1</tt> are true, <tt>.false</tt> or <tt>0</tt> are false

=={{header|Order}}==

Order supplies the keywords <code>8true</code> and <code>8false</code>. 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).

=={{header|Oz}}==

<tt>true</tt> and <tt>false</tt> are the only boolean values. No other values are automatically converted to bool.

=={{header|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 (but note that some functions like <code>ispower</code> are not boolean!).

* A vector (t_VEC), column vector (t_COL), or matrix (t_MAT) is false if and only if all of its components are 0. Note that <code>[]</code> is thus false.

* t_QUAD, t_POLMOD, t_RFRAC

=={{header|Pascal}}==

 

 

=={{header|Perl}}==

 

or

 

my $true_or_false;

else {

$true_or_false = 'false';

The values in Perl that are false are: <tt>0</tt> (as a number (including <tt>0.0</tt>), or as the string <tt>'0'</tt>, but '''not''' the string <tt>'0.0'</tt>), the empty string <tt><nowiki>''</nowiki></tt>, the empty list <tt>()</tt>, and <tt>undef</tt>. Everything else is true. See [http://perldoc.perl.org/perlsyn.html#Truth-and-Falsehood perlsyn].

 

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:

 

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)

 

=== Objects ===

=== There are no keywords for true and false ===

 

 

=== Special cases ===

 

As a special case, literal <tt>1</tt>s and <tt>0</tt>s will never cause a "Useless use of a constant in void context" warning. Another special case worth pointing out here is that the string <tt>'0 but true'</tt> won't provoke a warning if it's used as a number.

=={{header|Phix}}==

Zero is false, any other number is true. Attempting to use a string or sequence as a boolean is assumed to be a programming logic blunder and causes a fatal run-time error.

 

A boolean test is inverted by preceding it with the keyword <code>not</code>. The null character ('\0') is considered false, all other characters are deemed true.

The builtin constants TRUE/FALSE and their aliases True/true/False/false may also be used.

 

=={{header|PHP}}==

The values in PHP that are false are: <tt>FALSE</tt>, <tt>NULL</tt>, the number <tt>0</tt> (as an integer <tt>0</tt>, float <tt>0.0</tt>, or string <tt>'0'</tt>, but '''not''' the string <tt>"0.0"</tt>), the empty string <tt>""</tt>, the empty array <tt>array()</tt>, and "SimpleXML objects created from empty tags"(?).

Everything else is true. The keyword <tt>TRUE</tt> exists.

[http://www.php.net/manual/en/language.types.boolean.php#language.types.boolean.casting]

 

=={{header|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.

value is available in the given context. Note that 'NIL' and 'T' are written in

uppercase letters (PicoLisp is case-sensitive).

=={{header|Pike}}==

> 0;

(3) Result: 0

(9) Result: 1

>

=={{header|PL/I}}==

True is <code>'1'b</code> and false is <code>'0'b</code>.

x='1'b; /* True */

Using the macro facility one can define reasonable symbols for true and false

tf: proc options(main);

%Dcl true char; %true='''1''b';

Else

Put Skip List('false was recognized');

{{out}}

<pre>That's true

false was recognized</pre>

 

 

 

 

 

=={{header|PostScript}}==

 

Predefined constants are:

=={{header|PowerShell}}==

Two automatic variables exist for this purpose:

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 array with more than one item evaluates to '''true'''

* a reference to any object evaluates to '''true''', <code>$null</code> evaluates to '''false'''

=={{header|Python}}==

Python has a boolean data type with the only two possible values denoted by <code>True</code> and <code>False</code>.

 

'''Some examples:'''

True

>>> not True

False

>>> bool("False")

=={{header|R}}==

Similarly to Octave, R uses <tt>TRUE</tt> and <tt>FALSE</tt>, 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.

=={{header|Racket}}==

 

Racket has the standard Scheme Boolean values <tt>#t</tt> and <tt>#f</tt>, and will also accept <tt>#true</tt> and <tt>#false</tt>. This is a literal syntax, so it can be used anywhere including in quoted positions. There are also bindings for <tt>true</tt> and <tt>false</tt> (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,

 

['bloggle 'pear]

 

... evaluates to <tt>'pear</tt>, because <tt>'bloggle</tt> is not false.

 

=={{header|Raven}}==

Raven considers 0 as <code>FALSE</code>, -1 as <code>TRUE</code>

FALSE print

2 1 > print # TRUE (-1)

3 2 < print # FALSE (0)

=={{header|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:

 

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.

 

=={{header|Retro}}==

Zero is false and non-zero is true. Comparison functions return '''-1''' for true and '''0''' for false.

=={{header|REXX}}==

The REXX language enforces the values for &nbsp; ''true'' &nbsp; and &nbsp; ''false'', &nbsp; only the two values are valid:

 

===simplistic===

 

===spruced up===

Some programmers like to "spruce up" such a simple assignment:

 

===more exactitudeness===

 

===oblique===

[The parentheses aren't necessary in all of the above versions.]

<br><br>Some REXX interpreters allow the &nbsp; ''NOT'' &nbsp; (<code>¬</code>) character for negation:

 

===esoteric===

false = 'war' = 'peace'

false = 'freedom' = 'slavery'

Of course, in Orwellian terms, the above &nbsp; '''false''' &nbsp; statements are &nbsp; '''true''', &nbsp; but REXX isn't an Eric Arthur Blair reader.

<br><br>

=={{header|Ring}}==

x = True

y = False

see "x or y : " + (x or y) + nl

see "not x : " + (not x) + nl

 

=={{header|Ruby}}==

<code>false</code>, <code>nil</code> and <code>true</code> are singleton instances of classes <code>FalseClass</code>, <code>NilClass</code> and <code>TrueClass</code> respectively.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_expressions.html#UF]

 

=={{header|Rust}}==

 

=={{header|Sather}}==

The BOOL type can be <code>true</code> or <code>false</code>. 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:

 

i:INT := 1;

v := 1; -- wrong

-- BUT

v := 1.bool; -- ok

In this case, <code>0.bool</code> is false, and <code>n.bool</code> with n not equal to 0 is true.

 

=={{header|Scala}}==

Booleans in Scala are given by the literals <code>true</code> and <code>false</code>, case sensitive, which are the only instances of the class <code>Boolean</code>.

=={{header|Scheme}}==

The only value in Scheme that is false is <tt>#f</tt>.

 

Everything else (including the empty list, unlike Lisp) is true. The constant <tt>#t</tt> represents the canonical true value.

=={{header|Seed7}}==

Seed7 defines the type <tt>boolean</tt>. The only values of <tt>boolean</tt> are <tt>TRUE</tt> and <tt>FALSE</tt>. There are no automatic conversions from any other types into <tt>boolean</tt>, and it is a compile-time error to use any type other than <tt>boolean</tt> in a place that expects a <tt>boolean</tt> (e.g. if-statement condition, while-statement condition, operand of a logical operator, etc.).

=={{header|Self}}==

 

 

=={{header|Sidef}}==

Sidef defines the ''true'' and ''false'' boolean values, which are part of the ''Bool'' type.

 

In conditional expressions, anything that evaluates to zero or nothing is considered ''false'', including empty arrays and empty hashes.

say "true"

} else {

say "false";

{{out}}

<pre>false</pre>

=={{header|Slate}}==

Use <tt>True</tt> or <tt>False</tt>.

=={{header|Smalltalk}}==

=={{header|SNUSP}}==

Zero is false and non-zero is true, as used by the sole skip-if-zero operator ('''?''').

=={{header|SPL}}==

In SPL zero is false, any other value is true.

=={{header|Standard ML}}==

 

Standard ML defines a top-level data type <code>bool</code>, which has exactly two members, <code>true</code> and <code>false</code>:

 

 

In addition to all the functionality of any other Standard ML algebraic data type (e.g. [[pattern matching]], equality <code>false = false</code>), <code>bool</code> is also used in <code>if</code> and <code>while</code> syntaxes.

 

As with any other Standard ML data type, there are no automatic conversions of other types to bool.

=={{header|Stata}}==

Stata uses the values 0 for "false" and 1 for "true". In expressions involving boolean operators, any nonzero numeric value (including missing values) is considered true.

=={{header|Swift}}==

Swift defines a built-in data type <code>Bool</code>, which has two values, represented by the keywords <code>true</code> and <code>false</code>. There is no conversion between booleans and other data types. Conditionals require a type that conforms to the <code>BooleanType</code> protocol, which provides a conversion to <code>Bool</code> for that type; types that conform include <code>Bool</code> and some other types.

=={{header|Tcl}}==

;True values:

Any of these values may be abbreviated, and mixed-case spellings are also acceptable. [http://www.tcl.tk/man/tcl8.5/TclLib/GetInt.htm]

Any other value gives an error. In an interactive tclsh session:

 

Test for the boolean value of a string can be stuff like

which will test for "no" or "NO" or "0" or "False" or ...

=={{header|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.

=={{header|UNIX Shell}}==

 

In the following example, after running the test command, the then syntactical component runs the optional branch if an exitcode is of zero determined:

 

echo 'Looking for file' # This is the evaluation block

test -e foobar.fil # The exit code from this statement determines whether the branch runs

echo 'I am going to delete it'

rm foobar.fil

 

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.

{{works with|ksh}}

 

=={{header|Ursa}}==

Ursa has the boolean data type which can be declared using the declare (or decl) function.

Boolean values can be set to either true or false, or the result of an expression.

# same as

set bool (= 2 2)

or

# same as

set bool (not (= 2 2))

=={{header|Vim Script}}==

A non-zero <code>Number</code> is true, 0 is false.

 

Since a <code>String</code> is converted automatically to a <code>Number</code> when necessary, the following will print "false" because "foo" is converted to 0:

echo "true"

else

echo "false"

 

=={{header|WDTE}}==

WDTE has a built-in boolean type, the two values of which are exposed by the <code>std</code> package's <code>true</code> and <code>false</code> functions. In general, however, built-in conditional functionality, such as <code>switch</code> expressions, considers any value that is not <code>true</code> to be <code>false</code>.

 

let ex => switch 'this is irrelevant for this example' {

false => 'This is, obviously, not returned.';

true => 'This is returned.';

};

 

The above prints "This is returned."

 

=={{header|XLISP}}==

Boolean "false" may be represented by <tt>#F</tt>, <tt>#!FALSE</tt>, <tt>NIL</tt>, or the empty list; any other value is counted as true in conditional expressions, but it is also possible to represent the Boolean value "true" using your choice of the symbols <tt>#T</tt>, <tt>#!TRUE</tt>, and <tt>T</tt>. All these symbols are case-insensitive. Note that <tt>T</tt>, unlike the others, is a variable: it is bound by default to the constant <tt>#T</tt>, but you can (although you shouldn't) assign it any other value including "false" (by doing something like <tt>(setq t nil)</tt>). Boolean values are printed as <tt>#T</tt> and <tt>()</tt>.

=={{header|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.

=={{header|XSLT}}==

True and false are returned by built-in XPath functions.

</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.

 

=={{header|zkl}}==

b:=False;

{{out}}

<pre>

name numObjects oID otype properties size type typeID vaultPath

</pre>

=={{header|zonnon}}==

 

var

c := 1 > 2;

...

{{omit from|ML/I}}