Add the 'bool' type and its values 'False' and 'True', as described in

PEP 285.  Everything described in the PEP is here, and there is even
some documentation.  I had to fix 12 unit tests; all but one of these
were printing Boolean outcomes that changed from 0/1 to False/True.
(The exception is test_unicode.py, which did a type(x) == type(y)
style comparison.  I could've fixed that with a single line using
issubtype(x, type(y)), but instead chose to be explicit about those
places where a bool is expected.

Still to do: perhaps more documentation; change standard library
modules to return False/True from predicates.

Author: gvanrossum

Doc/lib/libfuncs.tex

@@ -77,6 +77,16 @@ \section{Built-in Functions \label{built-in-funcs}}
   to \code{\var{function}(*\var{args}, **\var{keywords})}.
 \end{funcdesc}
 
+\begin{funcdesc}{bool}{x}
+  Convert a value to a Boolean, using the standard truth testing
+  procedure.  If \code{x} is false, this returns \code{False};
+  otherwise it returns \code{True}.  \code{bool} is also a class,
+  which is a subclass of \code{int}.  Class \code{bool} cannot be
+  subclassed further.  Its only instances are \code{False} and
+  \code{True}.
+\indexii{Boolean}{type}
+\end{funcdesc}
+
 \begin{funcdesc}{buffer}{object\optional{, offset\optional{, size}}}
   The \var{object} argument must be an object that supports the buffer
   call interface (such as strings, arrays, and buffers).  A new buffer

Doc/lib/libstdtypes.tex

@@ -2,10 +2,8 @@ \section{Built-in Types \label{types}}
 
 The following sections describe the standard types that are built into
 the interpreter.  These are the numeric types, sequence types, and
-several others, including types themselves.  There is no explicit
-Boolean type; use integers instead.
+several others, including types themselves.
 \indexii{built-in}{types}
-\indexii{Boolean}{type}
 
 Some operations are supported by several object types; in particular,
 all objects can be compared, tested for truth value, and converted to
@@ -30,6 +28,9 @@ \subsection{Truth Value Testing \label{truth}}
 \item	\code{None}
 	\withsubitem{(Built-in object)}{\ttindex{None}}
 
+\item	\code{False}
+	\withsubitem{(Built-in object)}{\ttindex{False}}
+
 \item	zero of any numeric type, for example, \code{0}, \code{0L},
         \code{0.0}, \code{0j}.
 
@@ -50,11 +51,12 @@ \subsection{Truth Value Testing \label{truth}}
 \index{true}
 
 Operations and built-in functions that have a Boolean result always
-return \code{0} for false and \code{1} for true, unless otherwise
-stated.  (Important exception: the Boolean operations
-\samp{or}\opindex{or} and \samp{and}\opindex{and} always return one of
-their operands.)
-
+return \code{0} or \code{False} for false and \code{1} or \code{True}
+for true, unless otherwise stated.  (Important exception: the Boolean
+operations \samp{or}\opindex{or} and \samp{and}\opindex{and} always
+return one of their operands.)
+\index{False}
+\index{True}
 
 \subsection{Boolean Operations \label{boolean}}
 
@@ -68,7 +70,7 @@ \subsection{Boolean Operations \label{boolean}}
           {if \var{x} is false, then \var{x}, else \var{y}}{(1)}
   \hline
   \lineiii{not \var{x}}
-          {if \var{x} is false, then \code{1}, else \code{0}}{(2)}
+          {if \var{x} is false, then \code{True}, else \code{False}}{(2)}
 \end{tableiii}
 \opindex{and}
 \opindex{or}
@@ -161,15 +163,18 @@ \subsection{Comparisons \label{comparisons}}
 
 \subsection{Numeric Types \label{typesnumeric}}
 
-There are four numeric types: \dfn{plain integers}, \dfn{long integers},
+There are four distinct numeric types: \dfn{plain integers},
+\dfn{long integers}, 
 \dfn{floating point numbers}, and \dfn{complex numbers}.
+In addition, Booleans are a subtype of plain integers.
 Plain integers (also just called \dfn{integers})
 are implemented using \ctype{long} in C, which gives them at least 32
 bits of precision.  Long integers have unlimited precision.  Floating
 point numbers are implemented using \ctype{double} in C.  All bets on
 their precision are off unless you happen to know the machine you are
 working with.
 \obindex{numeric}
+\obindex{Boolean}
 \obindex{integer}
 \obindex{long integer}
 \obindex{floating point}
@@ -1389,6 +1394,22 @@ \subsubsection{The Ellipsis Object \label{bltin-ellipsis-object}}
 
 It is written as \code{Ellipsis}.
 
+\subsubsection{Boolean Values}
+
+Boolean values are the two constant objects \code{False} and
+\code{True}.  They are used to represent truth values (although other
+values can also be considered false or true).  In numeric contexts
+(for example when used as the argument to an arithmetic operator),
+they behave like the integers 0 and 1, respectively.  The built-in
+function \function{bool()} can be used to cast any value to a Boolean,
+if the value can be interpreted as a truth value (see section Truth
+Value Testing above).
+
+They are written as \code{False} and \code{True}, respectively.
+\index{False}
+\index{True}
+\indexii{Boolean}{values}
+
 
 \subsubsection{Internal Objects \label{typesinternal}}
 

Doc/ref/ref3.tex

@@ -162,7 +162,7 @@ \section{The standard type hierarchy\label{types}}
 These represent elements from the mathematical set of whole numbers.
 \obindex{integer}
 
-There are two types of integers:
+There are three types of integers:
 
 \begin{description}
 
@@ -187,6 +187,17 @@ \section{The standard type hierarchy\label{types}}
 an infinite string of sign bits extending to the left.
 \obindex{long integer}
 
+\item[Booleans]
+These represent the truth values False and True.  The two objects
+representing the values False and True are the only Boolean objects.
+The Boolean type is a subtype of plain integers, and Boolean values
+behave like the values 0 and 1, respectively, in almost all contexts,
+the exception being that when converted to a string, the strings
+\code{"False"} or \code{"True"} are returned, respectively.
+\obindex{Boolean}
+\ttindex{False}
+\ttindex{True}
+
 \end{description} % Integers
 
 The rules for integer representation are intended to give the most
@@ -222,6 +233,7 @@ \section{The standard type hierarchy\label{types}}
 
 \end{description} % Numbers
 
+
 \item[Sequences]
 These represent finite ordered sets indexed by non-negative numbers.
 The built-in function \function{len()}\bifuncindex{len} returns the
@@ -1074,8 +1086,10 @@ \subsection{Basic customization\label{customization}}
 \end{methoddesc}
 
 \begin{methoddesc}[object]{__nonzero__}{self}
-Called to implement truth value testing; should return \code{0} or
-\code{1}.  When this method is not defined, \method{__len__()} is
+Called to implement truth value testing, and the built-in operation
+\code{bool()}; should return \code{False} or \code{True}, or their
+integer equivalents \code{0} or \code{1}.
+When this method is not defined, \method{__len__()} is
 called, if it is defined (see below).  If a class defines neither
 \method{__len__()} nor \method{__nonzero__()}, all its instances are
 considered true.

Include/Python.h

@@ -79,6 +79,7 @@
 
 #include "unicodeobject.h"
 #include "intobject.h"
+#include "boolobject.h"
 #include "longobject.h"
 #include "floatobject.h"
 #ifndef WITHOUT_COMPLEX

Include/intobject.h

@@ -38,21 +38,6 @@ extern DL_IMPORT(PyObject *) PyInt_FromLong(long);
 extern DL_IMPORT(long) PyInt_AsLong(PyObject *);
 extern DL_IMPORT(long) PyInt_GetMax(void);
 
-
-/*
-False and True are special intobjects used by Boolean expressions.
-All values of type Boolean must point to either of these; but in
-contexts where integers are required they are integers (valued 0 and 1).
-Hope these macros don't conflict with other people's.
-
-Don't forget to apply Py_INCREF() when returning True or False!!!
-*/
-
-extern DL_IMPORT(PyIntObject) _Py_ZeroStruct, _Py_TrueStruct; /* Don't use these directly */
-
-#define Py_False ((PyObject *) &_Py_ZeroStruct)
-#define Py_True ((PyObject *) &_Py_TrueStruct)
-
 /* Macro, trading safety for speed */
 #define PyInt_AS_LONG(op) (((PyIntObject *)(op))->ob_ival)
 

Include/object.h

@@ -531,8 +531,8 @@ extern DL_IMPORT(long) _Py_RefTotal;
 #define Py_DECREF(op)							\
        if (--_Py_RefTotal, 0 < (--((op)->ob_refcnt))) ;			\
        else if (0 == (op)->ob_refcnt) _Py_Dealloc( (PyObject*)(op));	\
-       else (void)fprintf( stderr, "%s:%i negative ref count %i\n",	\
-		           __FILE__, __LINE__, (op)->ob_refcnt)
+       else ((void)fprintf( stderr, "%s:%i negative ref count %i\n",	\
+		           __FILE__, __LINE__, (op)->ob_refcnt), abort())
 #else /* !Py_REF_DEBUG */
 
 #ifdef COUNT_ALLOCS

Lib/difflib.py

@@ -976,11 +976,11 @@ def IS_LINE_JUNK(line, pat=re.compile(r"\s*#?\s*$").match):
     Examples:
 
     >>> IS_LINE_JUNK('\n')
-    1
+    True
     >>> IS_LINE_JUNK('  #   \n')
-    1
+    True
     >>> IS_LINE_JUNK('hello\n')
-    0
+    False
     """
 
     return pat(line) is not None
@@ -992,13 +992,13 @@ def IS_CHARACTER_JUNK(ch, ws=" \t"):
     Examples:
 
     >>> IS_CHARACTER_JUNK(' ')
-    1
+    True
     >>> IS_CHARACTER_JUNK('\t')
-    1
+    True
     >>> IS_CHARACTER_JUNK('\n')
-    0
+    False
     >>> IS_CHARACTER_JUNK('x')
-    0
+    False
     """
 
     return ch in ws

Lib/doctest.py

@@ -545,19 +545,19 @@ def is_private(prefix, base):
     does not both begin and end with (at least) two underscores.
 
     >>> is_private("a.b", "my_func")
-    0
+    False
     >>> is_private("____", "_my_func")
-    1
+    True
     >>> is_private("someclass", "__init__")
-    0
+    False
     >>> is_private("sometypo", "__init_")
-    1
+    True
     >>> is_private("x.y.z", "_")
-    1
+    True
     >>> is_private("_x.y.z", "__")
-    0
+    False
     >>> is_private("", "")  # senseless but consistent
-    0
+    False
     """
 
     return base[:1] == "_" and not base[:2] == "__" == base[-2:]

Lib/pickle.py

@@ -101,6 +101,9 @@ def __init__(self, value):
 EMPTY_TUPLE     = ')'
 SETITEMS        = 'u'
 BINFLOAT        = 'G'
+TRUE            = 'Z'
+FALSE           = 'z'
+
 
 __all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$",x)])
 del x
@@ -256,6 +259,13 @@ def save_none(self, object):
         self.write(NONE)
     dispatch[NoneType] = save_none
 
+    def save_bool(self, object):
+        if object:
+            self.write(TRUE)
+        else:
+            self.write(FALSE)
+    dispatch[bool] = save_bool
+
     def save_int(self, object):
         if self.bin:
             # If the int is small enough to fit in a signed 4-byte 2's-comp
@@ -629,6 +639,14 @@ def load_none(self):
         self.append(None)
     dispatch[NONE] = load_none
 
+    def load_false(self):
+        self.append(False)
+    dispatch[FALSE] = load_false
+
+    def load_true(self):
+        self.append(True)
+    dispatch[TRUE] = load_true
+
     def load_int(self):
         data = self.readline()
         try:

Lib/test/output/test_augassign

@@ -4,14 +4,14 @@ test_augassign
 6
 [1, 2, 3, 4, 1, 2, 3, 4]
 [1, 2, 1, 2, 3]
-1
-1
-1
+True
+True
+True
 11
-1
+True
 12
-1
-1
+True
+True
 13
 __add__ called
 __radd__ called

Lib/test/output/test_extcall

@@ -31,7 +31,7 @@ h() argument after ** must be a dictionary
 dir() argument after ** must be a dictionary
 NoneType object argument after ** must be a dictionary
 dir() got multiple values for keyword argument 'b'
-3 512 1
+3 512 True
 3
 3
 za () {} -> za() takes exactly 1 argument (0 given)

Lib/test/output/test_gettext

@@ -23,7 +23,7 @@ trggrkg zrffntr pngnybt yvoenel.
 wink wink
 bacon
 test api 2
-1
+True
 gettext
 albatross
 bacon

Lib/test/output/test_grammar

@@ -60,6 +60,6 @@ classdef
 [3, 4, 5]
 [(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'), (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'), (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'), (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'), (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')]
 [(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'), (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'), (5, 'Banana'), (5, 'Coconut')]
-[0, 0, 0]
+[False, False, False]
 [[1, 2], [3, 4], [5, 6]]
 [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'), ('Macdonalds', 'Cheeseburger')]