Bools: Add Links and Clean Up Concept Doc (exercism#2533)

* Added concept links and additional information  to bools concept.

* Edited intro to refer to bool type not boolean.

* Removed built-in types requirements and added basics and comparison operators.

* [CI] Format code

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: 2 people

concepts/bools/about.md

@@ -1,4 +1,4 @@
-Python represents True and False values with the [boolean][boolean] type. There are only two [boolean][boolean] values: _True_ and _False_. These values can be assigned to a variable and combined with [boolean operators][boolean-operators] (`and`, `or`, `not`):
+Python represents True and False values with the [bool][bool] type. There are only two boolean values: `True` and `False`. These values can be assigned to a variable and combined with the [boolean operators][boolean-operators] (`and`, `or`, `not`):
 
 ```python
 true_variable = True and True
@@ -16,54 +16,103 @@ false_variable = not True
 Each of the operators has a different precedence, where `not` is evaluated before `and` and `or`. Brackets can be used to evaluate one part of the expression before the others:
 
 ```python
-not True and True # => False
-not (True and False) # => True
+>>>not True and True
+False
+
+>>>not (True and False)
+True
 ```
 
+All `boolean operators` are considered lower precedence than Pythons [`comparison operators`][comparisons], such as `==`, `>`, `<`, `is` and `is not`.
+
 ## Type Coercion and Truthiness
 
-The [`bool` function][bool-function] converts any type to a Boolean value. By default all values return `True` unless defined to return `False`.
+The bool function ([`bool()`][bool-function]) converts any object to a Boolean value. By default all objects return `True` unless defined to return `False`.
 
-Some built-ins already defined to be considered `False`:
+A few `built-ins` are always considered `False` by definition:
 
-- constants like `None` and `False`
-- zero of any _numeric type_
-- empty _sequences_ and _collections_
+- the constants `None` and `False`
+- zero of any _numeric type_ (`int`, `float`, `complex`, `decimal`, or `fraction`)
+- empty _sequences_ and _collections_ (`str`, `list`, `set`, `tuple`, `dict`, `range(0)`)
 
 ```python
-bool(1) # => True
-bool(0) # => False
+>>>bool(None)
+False
+
+>>>bool(1)
+True
+>>>bool(0)
+False
+
+>>>bool([1,2,3])
+True
+>>>bool([])
+False
+
+>>>bool({"Pig" : 1, "Cow": 3})
+True
+>>>bool({})
+False
 ```
 
-When a value is used in a boolean context, it is used as a _truthy_ or _falsey_ value by transparently using the `bool` function.
+When a object is used in a _boolean context_, it is evaluated transparently as _truthy_ or _falsey_ using `bool()`:
 
 ```python
 a = "is this true?"
+b = []
+
+# This will print "True", as a non-empty string is considered a "truthy" value
 if a:
   print("True")
-# => This will print "True", as a non-empty string is a truthy value
+
+# This will print "False", as an empty list is considered a "falsey" value
+if not b:
+   print("False")
 ```
 
-Classes may define how they are evaluated in truthy situations if they override and implement a `__bool__` method.
+Classes may define how they are evaluated in truthy situations if they override and implement a `__bool__()` method, and/or a `__len__()` method.
 
 ## How Booleans work under the hood
 
-The Boolean type is a _sub-type_ of the _int_ type. `True` is numerically equal to `1`. `False` is numerically equal to `0`. This is observable when comparing them:
+The `bool` type is implemented as a _sub-type_ of _int_. That means that `True` is _numerically equal_ to `1` and `False` is _numerically equal_ to `0`. This is observable when comparing them using an _equality operator_:
 
 ```python
-1 == True # => True
-0 == False # => True
+>>>1 == True
+True
+
+>>>0 == False
+True
 ```
 
-However, they are still different as noted when checking for a Boolean identity:
+However, `bools` are **still different** from `ints`, as noted when compairing using the _identity operator_:
 
 ```python
-1 is True # => False
-0 is False # => False
+>>>1 is True
+False
+
+>>>0 is False
+False
 ```
 
-> Note: in python >= 3.8, using a literal value on the left side of `is` will raise a warning.
+> Note: in python >= 3.8, using a literal (such as 1, '', [], or {}) on the left side of `is` will raise a warning.
+
+It is considered a [Python anti-pattern][comparing to true in the wrong way] to use the equality operator to comaire a booleand variable to `True` or `False`. Instead, the identity operator `is` should be used:
+
+```python
+
+flag = True
+
+# Not "Pythonic"
+if flag == True:
+    print("This works, but it's not considered Pythonic.")
+
+# A better way
+if flag:
+    print("Pythonistas prefer this pattern as more Pythonic.")
+```
 
 [bool-function]: https://docs.python.org/3/library/functions.html#bool
-[boolean]: https://docs.python.org/3/library/stdtypes.html#truth
+[bool]: https://docs.python.org/3/library/stdtypes.html#truth
 [boolean-operators]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
+[comparisons]: https://docs.python.org/3/library/stdtypes.html#comparisons
+[comparing to true in the wrong way]: https://docs.quantifiedcode.com/python-anti-patterns/readability/comparison_to_true.html

concepts/bools/links.json

@@ -19,6 +19,10 @@
     "url": "https://problemsolvingwithpython.com/04-Data-Types-and-Variables/04.02-Boolean-Data-Type/",
     "description": "Problem Solving with Python - Boolean Data Type"
   },
+  {
+    "url": "https://docs.python.org/3/library/stdtypes.html#comparisons",
+    "description": "Comparisons in Python"
+  },
   {
     "url": "https://docs.quantifiedcode.com/python-anti-patterns/readability/comparison_to_true.html",
     "description": "Python Anti-Patterns  Comparing things to True in the Wrong Way"

exercises/concept/bools/.docs/introduction.md

@@ -1,4 +1,4 @@
-Python represents true and false values with the boolean type. There are only two values: `True` and `False`. These values can be bound to a variable:
+Python represents true and false values with the `bool` type. There are only two values: `True` and `False`. These values can be bound to a variable:
 
 ```python
 true_variable = True

exercises/concept/bools/.meta/design.md

@@ -25,11 +25,12 @@ The goal of this exercise is to teach the student how [`bool`](https://github.co
 
 ## Prerequisites
 
-- `builtin-types`
+- `basics`
 - `comparison-operators`
 
 ## Resources
 
 - [Boolean Operations — and, or, not](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)
 - [Built-in Functions - bool](https://docs.python.org/3/library/functions.html#bool)
 - [Truth Value Testing](https://docs.python.org/3/library/stdtypes.html#truth)
+- [Comparisons](https://docs.python.org/3/library/stdtypes.html#comparisons)