{"id":23714,"date":"2023-05-09T02:29:34","date_gmt":"2023-05-09T02:29:34","guid":{"rendered":"https:\/\/www.booksofall.com\/?post_type=product&p=23714"},"modified":"2023-05-09T02:29:53","modified_gmt":"2023-05-09T02:29:53","slug":"category-theory-for-programmers","status":"publish","type":"product","link":"https:\/\/www.booksofall.com\/pt\/category-theory-for-programmers\/","title":{"rendered":"Category Theory for Programmers"},"content":{"rendered":"

Category: The Essence of Composition<\/h2>\n

A category is an embarrassingly simple concept. A category consists of objects\u00a0<\/i>and\u00a0arrows\u00a0<\/i>that go between them. That\u2019s why categories are so easy to represent pictorially. An object can be drawn as a circle or a point, and an arrow\u2026 is an arrow. (Just for variety, I will occasionally draw objects as piggies and arrows as fireworks.) But the essence of a category is\u00a0composition<\/i>. Or, if you prefer, the essence of composition is a category. Arrows compose, so if you have an arrow from object A to object B, and another arrow from object B to object C, then there must be an arrow \u2014 their composition \u2014 that goes from A to C.<\/p>\n

1.1 Arrows as Functions<\/h4>\n

Is this already too much abstract nonsense? Do not despair. Let\u2019s talk concretes. Think of arrows, which are also called\u00a0morphisms<\/i>, as functions. You have a function<\/a> f that takes an argument of type A and returns a B. You have another function g that takes a B and returns a C. You can compose them by passing the result of f to g. You have just defined a new function that takes an A and returns a C.<\/p>\n

\"\"<\/p>\n

In math, such composition is denoted by a small circle between functions: ? \u2218 ? . Notice the right to left order of composition. For some people this is confusing. You may be familiar with the pipe notation in Unix, as in:<\/p>\n

lsof | grep Chrome<\/p>\n

or the chevron >> in F#, which both go from left to right. But in mathematics<\/a> and in Haskell<\/a> functions compose right to left. It helps if you read g\u25e6f as \u201cg after\u00a0<\/i>f.\u201d<\/p>\n

Let\u2019s make this even more explicit by writing some C code<\/a>. We have one function f that takes an argument of type A and returns a value of type B:<\/p>\n

B f(A a);<\/p>\n

and another:<\/p>\n

C g(B b);<\/p>\n

Their composition is:<\/p>\n

C g_after_f(A a)
\n{
\nreturn g(f(a));
\n}<\/p>\n

Here, again, you see right-to-left composition: g(f(a)); this time in C.<\/p>\n

I wish I could tell you that there is a template in the C++ Standard Library<\/a> that takes two functions and returns their composition, but there isn\u2019t one. So let\u2019s try some Haskell for a change. Here\u2019s the declaration of a function from A to B:<\/p>\n

f :: A -> B<\/p>\n

Similarly:<\/p>\n

g :: B -> C<\/p>\n

Their composition is:<\/p>\n

g . f<\/p>\n

Once you see how simple things are in Haskell, the inability to express straightforward functional concepts in C++ is a little embarrassing. In fact, Haskell will let you use Unicode characters so you can write com- position as:<\/p>\n

g<\/span> \u25e6<\/span> f<\/span><\/p>\n

You can even use Unicode double colons and arrows:<\/p>\n

f \u2237 A \u2192 B<\/p>\n

So here\u2019s the first Haskell lesson: Double colon means \u201chas the type of\u2026\u201d A function type is created by inserting an arrow between two types. You compose two functions by inserting a period between them (or a Unicode circle).<\/p>\n","protected":false},"excerpt":{"rendered":"