Category Theory for Programmers: Chapter 4 - Kleisli Categories

PL Virtual Meetup: www.meetup.com...
CtFP Textbook: github.com/hme...
Github Repo: github.com/cod...
PLVM Discord: / discord
PLVM Twitter: / plvirtualmeetup
Follow me on Github: github.com/cod...
Follow me on Twitter: / code_report
Follow me on LinkedIn: / codereport

[@henrykkaufman1488]

Love the Princess Bride intro, Bartosz really looks like Inigo Montoya!

[@StewartMcGinnis]

Even though I've tried reading it in lots of places before, you're walking through the writer category was the first time I really understood it as being "monad-y" and why "monad-y-ness" is useful for programming and not just a coincidental math structure academics managed to fit over programing patterns. Thanks! (For context, I'm a mathematician by schooling and was taught to code in primarily imperative and object oriented style)

[@MCLooyverse]

@14:00, you have functions wrapped in lambdas, but function pointers exist. You should be able to just write `safe_reciprocal` and `safe_root`. If that were necessary, that would be a good time for a macro like #define LAMBDAWRAP(f) [](auto x){ return f(x); }

[@RogasTV]

14:08, I would try „return compose(&safe_reciprocal, &safe_root)(n);”. It should be possible as long as lambdas do not capture anything. I enjoyed this episode. Thanks!

[@Adowrath]

Yeah, it works by just passing the functions without explicitly taking their address too, I don't know why he talked about them not being first-class like that.

[@theondono]

Chapter 4 and I’ve already had to rewatch the Princesa Bride

[@felipenascimento6118]

I'm finding APL to be a very confusing language. I think that using many operators like that creates a scenario where the language requires training to be readable, which for me is undesirable. A good thing of using keywords instead is that one can take a very good guess of what's going on, even if they don't know the language

[@RobotProctor]

Me after watching this video: oh, so a Kleisli category is like a composition of categories together. Wikipedia: a Kleisli category is a category naturally associated to any monad T. It is equivalent to the category of free T-algebras Me: wtf? I'm now questioning everything I just learned.

[@NikolajLepka]

My fave way of doing roots in APL is actually like this (in J notation to avoid unicode): y^%2, or "right arg raised to the reciprocal of 2". It's one fewer symbol, but idk if it's any less fast

[@retagainez]

2:12 The remark on difficulty of unit testing the negate function here is not correct. You don't have to test what a string is when you're unit testing. You would instead test that there is an existence of a string and you can avoid everything except what the function is meant to add. You would instead just unit test some decorator and that it works for any function (which is in a way composing logging with a function). Typically, unit testing should not involve testing the set of all possible values by forcing your implementation to focus on those values (rather you focus on common behaviors), and even less so when dealing with a library (in this case the string data type). What you meant to mention (when you started talking about all combinations of string prefixes concatenated with the hardcoded value) is that is it very difficult to use memoization, as Bartosz states in the lecture, which is different and speaks on performance improvements for repeated iterations that are slow. The same unit testing exists in the purer form of the same function, it's just the unit testing would focus instead on composing strings (which is what you would anyway in the original side-effect function definition.) Even then, regardless of unit testing, integration tests would be useful here, on the logger, to prove that it produces logs for all of your behaviors.

[@tonaxysam]

my name is inigo montoya... you killed my _functor_ prepare to die

[@foxoninetails_]

17:14 I'm very, very new to APL (just started playing around with it in the past couple of days), but I did manage to find a relatively clean way to compose functions around your method of optional types, by defining safe_compose as a dyadic operator. It also avoids inner assignment by nesting definitions. Is this something that should be avoided for a reason I'm missing, or just something that didn't come to mind? safe_compose ← {⍵⍵ {has_value ⍵: ⍺⍺ value ⍵ ⋄ nullopt} ⍺⍺ ⍵} Or without predefining has_value and value for the sake of conciseness: safe_compose ← {⍵⍵ {⊃⍵:⍺⍺⊃⌽⍵ ⋄ nullopt} ⍺⍺ ⍵} After which it can be used as such: safe_root_reciprocal ← safe_reciprocal safe_compose safe_root