Good questions, and I think answering them’ll help me understand the idea, too! I may have misread or misinterpreted the definition or done the translation to Haskell wrong. I might still be doing that in this post.
Category theory is ultimately interested in the connections between objects and the functions that connect them. If I have a collection of objects, I also want to bring along the information of how they’re related to each other.
But a category is an incredibly general idea. When we look at this definition and say “1. a class of objects Ob(C);” that’s a super permissive requirement. The objects inside a category could have some sort of structure or definition of their own, and typically do. For example, a list of integers could absolutely be an object that’s contained in a larger category.
Category theory is ultimately interested in functions/mappings  the connections between objects in a category. We have an incredible amount of freedom to define what objects we put in our category, but when we do so we also have to define the functions between those objects.
Coming back to the Bool example, what I posted forms a category (I think), but that category doesn’t actually model the behavior of booleans very well! So your questions make sense. I’m gonna try to think of a better example.
(All the examples that immediately come to mind are math examples, trying to think of a Haskell one.)
(My haskell knowledge is limited, struggling.)
Like, I saw “the monoid of booleans with ‘and’ is a one object category”, and that makes sense, but I have no idea how to explain it.
I’m gonna come up with a very, very arbitrary category, that should demonstrate how general the idea is. And since my haskell knowledge is limited, I’m sure I’ll make mistakes on the haskell side of things, I’ll ask for your patience/help with that.

I’m gonna make a category, StrangeListThing. The category will have 3 objects.
Object X: "The collection of every list of integers."
Object Y: "All lists of Doubles"
Object Z: "All lists of characters. (that is, all strings)."
Each of these objects is itself a collection of stuff! That’s ok, objects in a category can be like that, and objects in categories often are big things.
Next up, part 2:
 We have these objects, but we need the mappings/functions/morphisms between them. So if we take X (all lists of Ints) and Y (all lists of Doubles), we have to think about what kind of functions there are between those 2 objects.
A function between X and Y could be old fashioned C style typecasting, “give me the double version of this int”. It takes every integer in X and turns it into a double in Y. Let’s call it typecast.
 pseudocode
typecast X =
for every list x in X
typecast_list x = all the integers in the list are converted to their equivalent doubles
For example, typecast_list [1,2] = [1.0, 2,0].
We could have a different mapping from X to Y, call it zero_out
pseudocode again
zero_out X =
for every list x in X
zero_out_list x = [0.0]
That is, zero_out turns every list in X into just [0.0] in Y. That’s also a function/mapping/morphism from X to Y!
There’s an infinite amount of these functions/mappings/morphisms from X to Y. From a categorical perspective, the category wants to keep track of all of them.
Ok, that brings us to:
 The objects and functions/mappings between them have to follow some rules.
Let’s say we have a function from Y (all the lists of doubles) to Z (all the lists of characters/ all the strings). One of the morphisms from Y to Z might look like this
 pseudocode
basic_cipher Y =
for every list y in Y
basic_cipher_of_y y =
round each element of the list down (i.e. 3.5 rounds to 3.0)
map anything between 0 and 25 to the corresponding letter
map anything above 25 to 'z'
map anything below 0 to 'a'
so basic_cipher_of_y [1.0,2.0,3.0] = "abc"
.
There’s plenty (infinitely many) functions between Y and Z, too.
Category theory requires that these functions play together the way we expect them to. for example:
basic_cipher . typecast X
exists and works the way we expect it to. Like, basic_cipher_y . typecast_list [1,2,3] = "abc"
Also, the mappings/functions between objects of the category have to be associative.
Associativity:
If f :: X > Y
g :: Y> Z
h :: Z>X
are mappings/functions between objects in our category, then
(h . g ) . f = h . (g . f)
There has to be an identity function:
identity X =
for every list x in X
identity x = x
Part 3 is some basic, like, “functions/mappings between objects in a category work the way we expect them to” requirements.
So my category is X, Y, and Z, along with all the possible functions between these three objects. that is
Category StrangeListThing:
X (all lists of integers)
Y (all lists of doubles)
Z (all lists of characters/all strings)
All mappings from X > X
All mappings from X > Y
" " " X > Z
" " " Y > X
" " " Y > Y
" " " Y > Z
" " " Z > X
" " " Z > Y
All mappings from Z > Z
I’m running out of steam, but perhaps that makes a bit more sense? I can already see some nuances and details that are wrong or incomplete, but I feel like I’m working my way towards a simpler explanation.