Whipping out the “monoid in the category of endofunctors” line doesn’t help unless you have explained what those words actually mean - I programmed using monads for a number of years without understanding that catchphrase. I’d also say that OP’s slides probably need at least a lot of talking around to be useful. The slides talk about monad flattening List(Maybe(T)) to List(T), but monadic join is M x M -> M, so that seems off?

Thanks for the links! What I liked about the “Category Theory in 10 minutes” is that it helped me get an idea of what category theory is about and introduce some of the lingo that otherwise takes a long time to acquire (it’s only 22 pages long). As a point of comparison, The Category Theory For Programmers book is 515 pages long, the Seven Sketches in Compositionality book is 243 and the slide deck you shared is 209 – I’d like to see more short or medium-form introductions to category theory, so that it’s easier to dive into it.

I caution you against taking the page count of any slide deck too seriously: often it’s because of little highlights and not-quite-animations. Ken’s talk is only 25 minutes long.

Interesting, especially since many of the points and ways to phrase concepts aren’t just the same thing one keeps reading about all the time. But this confused me even more when it came to Endofunctors. How is “Int -> Int” and “Int -> String” an Endofunctor. Aren’t “String” and “Int” two categories?

Well, you can choose to define a category with the elements of Int as the objects, but I don’t think that’s what’s meant here. I agree that the slides are very confusing. I think the strange notation Int => String here denotes an example mapping from the object Int to the object String (supposedly in some category with types as the objects…). I think that slide doesn’t contain any useful information.

Functors in most programming languages are all endofunctors because most programming languages are in the category of Types

(slide 17)

For example, in Haskell all types and functions are in the category “Hask”, where the objects are Haskell types and the morphisms are functions, identity is the id function and composition is function composition using the . operator. (see here)

This looks interesting. The slides are pretty information dense. Is there a talk/video to go along with them ?

Not for that talk, but I think this Ken Scambler talk from LambdaJam 2015 is much better, and I think this slide deck is the one Ken uses, or is very close to it.

Whipping out the “monoid in the category of endofunctors” line doesn’t help unless you have explained what those words actually mean - I programmed using monads for a number of years without understanding that catchphrase. I’d also say that OP’s slides probably need at least a lot of talking around to be useful. The slides talk about monad flattening

`List(Maybe(T))`

to`List(T)`

, but monadic join isM x M -> M, so that seems off?Thanks for the links! What I liked about the “Category Theory in 10 minutes” is that it helped me get an idea of what category theory is about and introduce some of the lingo that otherwise takes a long time to acquire (it’s only 22 pages long). As a point of comparison, The Category Theory For Programmers book is 515 pages long, the Seven Sketches in Compositionality book is 243 and the slide deck you shared is 209 – I’d like to see more short or medium-form introductions to category theory, so that it’s easier to dive into it.

I caution you against taking the page count of any slide deck too seriously: often it’s because of little highlights and not-quite-animations. Ken’s talk is only 25 minutes long.

Interesting, especially since many of the points and ways to phrase concepts aren’t just the same thing one keeps reading about all the time. But this confused me even more when it came to Endofunctors. How is “Int -> Int” and “Int -> String” an Endofunctor. Aren’t “String” and “Int” two categories?

Well, you can choose to define a category with the elements of

`Int`

as the objects, but I don’t think that’s what’s meant here. I agree that the slides are very confusing. I think the strange notation`Int => String`

here denotes an example mapping from the object`Int`

to the object`String`

(supposedly in some category with types as the objects…). I think that slide doesn’t contain any useful information.(slide 17)

For example, in Haskell all types and functions are in the category “Hask”, where the objects are Haskell types and the morphisms are functions, identity is the

`id`

function and composition is function composition using the`.`

operator. (see here)Hope that makes sense :)

And Hask is only a category if you wave your hands a bit and ignore

`seq`

and bottom. But it’s good enough as an intuition pump.