Tell me one thing you like about Haskell here.
I like that order of evaluation is… not as important? Not a thing? Not sure of the details! But I like it. My thinking style is very nonlinear and focused on connections between ideas. Haskell meshes with that pretty well 
. The step by step approach of imperative languages always took a little extra effort for me.
i like algebraic datatypes alot and using them to exactly represent state. ive been using non haskell things (GDScript) and wishing i could just use a sum type to represent states and each state’s specific info, like knockback timers and stuff like that. more languages should have ADTs
One of my favorite things about Haskell’s design is that it encourages you to move side-effects to as small a portion of the code base as possible. After being essentially forced to do so by the compiler, I’ve found that functions which perform no side-effects tend to be much easier to debug and understand. I’ve started applying similar principles of avoiding side effects to my own code in other languages and it tends to work really well 
In particular, since “pure” code (code that doesn’t perform side-effects) always returns the same result for the same inputs, I have a lot more confidence about how things will work and it’s easier to eliminate which parts of my code are likely to have an issue. It also makes it easier to write unit tests, since I don’t need to set up any shared mutable state!
monads are monoids in the category of endofunctors
(i unironically love this meme/fact. I definitely learned category theory for the first time cause of it)
It also exposed me to the existence of category theory, which was cool. Unfortunately, when I tried to learn it I found it rather impenetrable and I still find it a mystery. What kind of resources did you use to learn and understand it?
I have a very particular way of learning math when I get excited - lots of searches, lots of random papers and explainers and articles. I bounced from paper to book to paper until I felt like I had something.
I used to use mathworld, but I don’t really like the redesign? Same with PlanetMath, which got much less usable, even tho the content’s mostly the same. While I don’t like wikipedia (for learning math or much else), I’ll go to a topic and check out the references there.
Not super reproducible, I think! I also go to resources aimed at ppl with a lot of mathematical training, like, I had a semester of topology and a semester of intro to groups/rings/fields and a semester of this and a semester of that. For ppl without that kind of training, I’m not sure where to point, tho there’s probably good resources out there! Best I understand it, category theory doesn’t require that kind of background, it’s just the background I have.
Coming back to haskell, there’s a bit of haskell in this article: https://pages.cs.wisc.edu/~jcyphert/categoryTheoryNotes/basics/3_NaturalTransformations.pdf. Found cause of an article at the Encyclopedia of Mathematics
I am sorry to say that, unfortunately, I find this paper very difficult to understand. I kind of understand the first two paragraphs, but I feel thoroughly lost by the third.
I think the problem here is that I don’t really understand what the author means when they use some terminology that they appear to assume the reader already knows such as:
I’ve tried looking up some information about what some of these terms mean exactly, but I end up with stuff like this…
A category C is the following data:
a class of objects Ob(C);
for every objects X,Y \in Ob(C), the class Hom_c(X,Y) = Hom(X,Y) of morphisms (or arrows) from X,Y (for f \in Hom(X,Y), one may write f : X \to Y);
For any objects X,Y,Z \in Ob(C), a composition map Hom(Y, Z) \times Hom(X,Y) \to Hom(X,Z), (f, g) \mapsto f \circ g, which satisfy the following axioms:
The composition is associative, i.e., (f \circ g) \circ h = f \circ (g \circ h);
For each X \in Ob(C), there is a morphism 1_X \in Hom(X, X), called the unit morphism, such that 1_X \circ f = f and g \circ 1_X = g for any f, g for which compositions make sense.
…which is also very hard for me to understand. Perhaps I also need to bounce between papers until I find a foothold in it somewhere.
Totally! It assumes math knowledge - if I follewd it it was cause of the training.
For example, from the perspective of trying to understand a lot of this stuff, homomorphism, morphism, function, and map basically mean the same thing. Why not call them all functions? Because there’s small (important, but small) differences and math people love their jargon. Like, maybe one of these words refers to a higher order function or a group of functions or a polymorphic function but we don’t need a million words for 'em.
If I thought about it carefully enough there’s probably a super straightforward Haskell way to think about it. Like, I think this definition would imply that booleans (y’know, True and False) + all the functions of type Bool → Bool would form a category.
Or like, all the Ints + all the functions of type Int → Int would form their own category.
We could have a category of all haskell objects + all possible haskell functions. Something like that? And we define some properties that the functions have to have.
(edit: I think the “unit morphism” for the category of booleans would look like this:
unit_morphism :: Bool → Bool
unit_morphism x = x
It’d just be an identity function.)
A category is a group of stuff and a bunch of functions between the members of the category. Those functions have to follow some rules. It should be easier to explain! I feel like there has to be a way to cut through the noise.
I think so too. Heck, we have videos about quantum physics that are quite good and quantum physics is wild. There just seems to be a dearth of educational materials for people who want to start learning for category theory.
Anyway, if you don’t mind humoring my questions, when you say that a category could contain the booleans True and False and all of the functions of type Bool -> Bool, why those things specifically? Why not just the booleans True and False? Why not the booleans True and False, all of the functions of type Bool -> Bool, and all of the functions of type Bool -> Bool -> Bool? And so on?
It seems to be that True and False ought to be in a separate category from Bool -> Bool, since they are different things. Indeed, in Haskell, the Kind of a boolean is * and the kind of a function is * -> *. But maybe category theory doesn’t care about that? Does category theory expect you to form arbitrary groupings of things?
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:
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:
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.
I’m much better at explaining things interactively, I think, on a call or w/e. And this isn’t something I’ve taught before. Gonna keep looking for a better explanation.
Thanks for writing that up! To check my understanding, it sounds like you’re saying that in Category Theory:
A category can contain an arbitrary number of objects. It can contain a finite or infinite number of objects.
The category must also include every possible function that lets you transform from any object in the category to another object in the same category, including the identity function.
Every function in a category must be associative.
Does this sound correct?
Sounds good to me! Gonna reread that definition to check, but that’s how I currently understand it.
Category theorists probably won’t call the functions ‘functions’, usually, they’ll call them ‘morphisms’ or ‘maps’ or ‘arrows’. That’s cause ‘function’ has a pretty specific set-theoretic definition in math. But basically, they’re functions.
I made a diagram!
(forgot to put etc. in Z, but Z is all strings)
Once we’ve got the basic definition down, we can talk about things like functors and monoids and monads, but I’d have to do more digging on that first before I could talk about it cogently.
@LCOLONQ suggested to me that Basic Category Theory for Computer Scientists by Benjamin Pierce and Category Theory in Context by Emily Riehl are good resources for learning category theory. And the latter is free! So I’m going to see if I can read it and try to understand a little bit more.
This topic was automatically closed 30 days after the last reply. New replies are no longer allowed.
