| 2025-01-31 00:04:43 +0100 | weary-traveler | (~user@user/user363627) user363627 |
| 2025-01-31 00:06:53 +0100 | <glguy> | My favorite Data. misuse is Data.Kind |
| 2025-01-31 00:07:03 +0100 | <tomsmeding> | (re mechanisms to resolve ambiguity: https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/package_qualified_imports.html#exte… ) |
| 2025-01-31 00:09:21 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 00:10:58 +0100 | <dminuoso> | Relatedly https://downloads.haskell.org/ghc/latest/docs/users_guide/packages.html#package-thinning-and-renam… |
| 2025-01-31 00:11:36 +0100 | <dminuoso> | Unsure how controllable that is via cabal-install |
| 2025-01-31 00:12:28 +0100 | <geekosaur> | "mixins" should handle both |
| 2025-01-31 00:12:53 +0100 | eL_Bart0 | (eL_Bart0@dietunichtguten.org) (Ping timeout: 245 seconds) |
| 2025-01-31 00:13:43 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds) |
| 2025-01-31 00:14:40 +0100 | alfiee | (~alfiee@user/alfiee) alfiee |
| 2025-01-31 00:14:57 +0100 | ljdarj | (~Thunderbi@user/ljdarj) (Ping timeout: 248 seconds) |
| 2025-01-31 00:18:50 +0100 | <dminuoso> | A while ago transformers has received these nice diagrams to visualize what the respective transformers do: https://hackage.haskell.org/package/transformers-0.6.1.2/docs/Control-Monad-Trans-Writer-CPS.html |
| 2025-01-31 00:19:06 +0100 | alfiee | (~alfiee@user/alfiee) (Ping timeout: 252 seconds) |
| 2025-01-31 00:19:09 +0100 | <dminuoso> | We're just missing a diagram for Cont. Cant be that hard, right? :-) |
| 2025-01-31 00:19:28 +0100 | <geekosaur> | i,i "Cont be that hard" |
| 2025-01-31 00:19:37 +0100 | <dminuoso> | Heh. |
| 2025-01-31 00:21:02 +0100 | <EvanR> | haskell is famous for laissez faire programming. Terrible I'm outta here |
| 2025-01-31 00:21:02 +0100 | <int-e> | please pass all the details to `const "I don't want to hear it."` |
| 2025-01-31 00:21:15 +0100 | <EvanR> | looking for a language for more bondage and discipline |
| 2025-01-31 00:22:30 +0100 | <geekosaur> | surely there's an appropriate DT language |
| 2025-01-31 00:23:03 +0100 | rstromlund | (~user@user/rstromlund) (Ping timeout: 252 seconds) |
| 2025-01-31 00:24:45 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 00:28:15 +0100 | Smiles | (uid551636@id-551636.lymington.irccloud.com) Smiles |
| 2025-01-31 00:31:37 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds) |
| 2025-01-31 00:31:59 +0100 | haskellbridge | (~hackager@syn-024-093-192-219.res.spectrum.com) (Remote host closed the connection) |
| 2025-01-31 00:32:46 +0100 | haskellbridge | (~hackager@syn-024-093-192-219.res.spectrum.com) hackager |
| 2025-01-31 00:32:46 +0100 | ChanServ | +v haskellbridge |
| 2025-01-31 00:35:39 +0100 | <monochrom> | You know what, I have to understand Reader and Writer first before I understand those two diagrams. |
| 2025-01-31 00:35:57 +0100 | xff0x | (~xff0x@ai096095.d.east.v6connect.net) (Ping timeout: 252 seconds) |
| 2025-01-31 00:36:07 +0100 | <monochrom> | And generally I have to understand bind first. |
| 2025-01-31 00:37:39 +0100 | <monochrom> | But State is missing a diagram and that's a well-known diagram. |
| 2025-01-31 00:38:06 +0100 | xff0x | (~xff0x@2405:6580:b080:900:704:c9bd:a645:9b1d) |
| 2025-01-31 00:38:22 +0100 | <monochrom> | Conjecture: Such a diagram exists iff the monad is of an algebraic effect. Cont is not an algebraic effect. |
| 2025-01-31 00:42:48 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 00:42:51 +0100 | sawilagar | (~sawilagar@user/sawilagar) (Ping timeout: 252 seconds) |
| 2025-01-31 00:44:14 +0100 | joeyadams | (~joeyadams@syn-184-054-105-097.res.spectrum.com) |
| 2025-01-31 00:46:35 +0100 | monochrom | (trebla@216.138.220.146) (Ping timeout: 252 seconds) |
| 2025-01-31 00:47:34 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds) |
| 2025-01-31 00:49:59 +0100 | monochrom | (trebla@216.138.220.146) |
| 2025-01-31 00:52:02 +0100 | <euouae> | <https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State> "A monad is sometimes described as providing a value in a context." -- this is very close to what I was thinking when I said monads are like state machines |
| 2025-01-31 00:54:15 +0100 | <dminuoso> | euouae: Monads are an abstract interface. |
| 2025-01-31 00:54:36 +0100 | <dminuoso> | Comparing them to anything concrete is, at best, just likening it to that specific instance, but that prevents you from seeing what monad is about. |
| 2025-01-31 00:54:52 +0100 | <int-e> | now I want a burrito |
| 2025-01-31 00:55:16 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 00:57:25 +0100 | <dminuoso> | euouae: My best recommendation is to just not worry about what Monad means at all. `IO` is about side effects. `[]` is about lists. `Maybe` is about failure. `Either A` is about exceptions. Each example is trivial to explain to any beginner |
| 2025-01-31 00:58:09 +0100 | <dminuoso> | Monad is just observing that all of these things have some pattern and laws in common. There's not really any inherent meaning to it |
| 2025-01-31 00:58:40 +0100 | <dminuoso> | And if people stop trying to attach meaning to that word `Monad`, they get on learning Haskell much faster. |
| 2025-01-31 00:58:45 +0100 | <monochrom> | I do not mind specific instances that may limit one's imagination because it is part of the learning process. |
| 2025-01-31 00:59:48 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds) |
| 2025-01-31 01:00:31 +0100 | rstromlund | (~user@user/rstromlund) rstromlund |
| 2025-01-31 01:00:41 +0100 | <monochrom> | Consider how "numbers" are taught beginning with natural numbers and, eventually, if you go to math grad school, ending with algebraic number fields. Not the other way round. |
| 2025-01-31 01:01:00 +0100 | <dminuoso> | monochrom: Sure, but that particular wikibooks article is not about promoting any learning process. |
| 2025-01-31 01:01:22 +0100 | <dminuoso> | If Monad tutorials started with just proclamining `Monads are just IO`, this would be a feasible strategy. |
| 2025-01-31 01:01:44 +0100 | <dminuoso> | As you could gradually introduce more instances and different "flavours" |
| 2025-01-31 01:02:54 +0100 | <monochrom> | That one I agree with you. It's the equivalent of a biology tutorial saying "natural selection is described as survival of fittest" |
| 2025-01-31 01:04:03 +0100 | alfiee | (~alfiee@user/alfiee) alfiee |
| 2025-01-31 01:05:18 +0100 | rstromlund | (~user@user/rstromlund) (Ping timeout: 252 seconds) |
| 2025-01-31 01:08:34 +0100 | alfiee | (~alfiee@user/alfiee) (Ping timeout: 260 seconds) |
| 2025-01-31 01:08:58 +0100 | <euouae> | dminuoso: I'm not trying to summarize all monads or anything of the short, just to adopt a mental mode |
| 2025-01-31 01:10:04 +0100 | <dminuoso> | euouae: Fair enough. |
| 2025-01-31 01:10:25 +0100 | <euouae> | obviously it's both tiresome to manually typecheck everything when reading code & provides no intuition. the megaparsec code I saw earlier with a bunch of >>= inside a do was clear in what it was doing: it was combining a bunch of parser combinators, starting from some initial string-to-be-parsed, and outputted either a parsed data structure or parser error |
| 2025-01-31 01:10:34 +0100 | <dminuoso> | The mental model I have settled on over the years is that `Monads` model sequencing. |
| 2025-01-31 01:10:39 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 01:10:43 +0100 | <euouae> | and it sort of occurred to me that a lot of uses of do/>>= are doing basically stuff like that |
| 2025-01-31 01:11:39 +0100 | <dminuoso> | Though Im a flexible, and I have some alternate intuitions that I can switch to depending on the problem. |
| 2025-01-31 01:12:02 +0100 | <euouae> | well sure, adopting just one is good enough for me. I'll adopt more if the need arises |
| 2025-01-31 01:12:10 +0100 | down200 | (~down200@shell.lug.mtu.edu) (Ping timeout: 244 seconds) |
| 2025-01-31 01:12:50 +0100 | <dminuoso> | euouae: [] seems to breaks a state machine viewpoint. |
| 2025-01-31 01:13:12 +0100 | <dminuoso> | The monad instance of [] roughly models non-determinism (with a bit of squinting) |
| 2025-01-31 01:13:19 +0100 | <euouae> | if you can elaborate? |
| 2025-01-31 01:13:27 +0100 | monochrm | (trebla@216.138.220.146) |
| 2025-01-31 01:14:31 +0100 | <dminuoso> | (I say squinting because lists are not sets and have a bit more structure) |
| 2025-01-31 01:15:11 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds) |
| 2025-01-31 01:15:24 +0100 | monochrom | (trebla@216.138.220.146) (Ping timeout: 260 seconds) |
| 2025-01-31 01:15:24 +0100 | monochrm | monochrom |
| 2025-01-31 01:15:52 +0100 | <geekosaur> | so, the list monad models a computation that gives you all possible solutions, whereas a Maybe version of the same computation gives you at most one solution (and can be thought of as "first solution, if any") |
| 2025-01-31 01:17:35 +0100 | down200 | (~down200@shell.lug.mtu.edu) down200 |
| 2025-01-31 01:18:11 +0100 | <dminuoso> | euouae: Say if we imagine a chess computer, we could think of [move1, move2, move3, move4] as not a collection of possibilities, but rather some non-deterministic choice of *one* move. |
| 2025-01-31 01:18:24 +0100 | ec | (~ec@gateway/tor-sasl/ec) ec |
| 2025-01-31 01:18:34 +0100 | <dminuoso> | And >>= lets you take a further non-determistic choice |
| 2025-01-31 01:19:09 +0100 | <euouae> | Here's how lists are state machines: No input variable, only state; its output is the state. They compose funkily, but still. |
| 2025-01-31 01:19:23 +0100 | <geekosaur> | as dminuoso said, it's acting as a "poor man's set" (for technical reasons we can't actually make a Set a Monad); all the answers are equally ranked, their position in the list isn't relevant |
| 2025-01-31 01:19:52 +0100 | <dminuoso> | euouae: But its that *funkily* behavior that is the core essence of that instance. |
| 2025-01-31 01:20:02 +0100 | <euouae> | It is no less a state machine however |
| 2025-01-31 01:20:08 +0100 | <euouae> | a composable state machine, as I said above |
| 2025-01-31 01:20:41 +0100 | <euouae> | anyway, it's been said that everything can be considered a state machine, it's just a mental mode I have... I'm just glad I put it to some test and it didn't immediately collapse |
| 2025-01-31 01:20:44 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) bitdex |
| 2025-01-31 01:21:37 +0100 | <dminuoso> | I mean if you insist on that state machine model, perhaps you could think of it as a non-deterministic state machine (along the lines of an NFA) |
| 2025-01-31 01:22:08 +0100 | <dminuoso> | Im not sure about the exact mental gymnastics required to see the state machine, but thats probably because Im flexed very differently |
| 2025-01-31 01:23:01 +0100 | geekosaur | wonders if it's the same viewpoint used with the comonad |
| 2025-01-31 01:23:07 +0100 | <dminuoso> | euouae: So here's why your state machine logic does not quite work out: |
| 2025-01-31 01:23:18 +0100 | <euouae> | As long as I can squeeze real-world results from my intuition I'm not too bothered by its rough edges |
| 2025-01-31 01:23:24 +0100 | <dminuoso> | euouae: `do x <- [1,2,3]; ...` -> how do you obtain the state? |
| 2025-01-31 01:24:01 +0100 | <dminuoso> | The non-determinism approach has the benefit of accurately modelling non-deterministic algorithms. |
| 2025-01-31 01:24:57 +0100 | <dminuoso> | In the above example, `x` represents some non-deterministic choice of [1,2,3] |
| 2025-01-31 01:25:01 +0100 | <euouae> | In `do x <- [1,2,3];` you're getting a slice of that funky composability |
| 2025-01-31 01:25:24 +0100 | <dminuoso> | euouae: But Im asking about where that state machine is. What's the state here? |
| 2025-01-31 01:25:38 +0100 | <euouae> | now x <- [1,1,1] does not have enough information for you to distinguish one 1 from another 1, even though they're positionally different |
| 2025-01-31 01:26:01 +0100 | <euouae> | I think I imagine state different from State or whatever |
| 2025-01-31 01:26:02 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 01:26:11 +0100 | <euouae> | The state is [1,2,3] |
| 2025-01-31 01:26:41 +0100 | <dminuoso> | euouae: Thats only true in the sense that the program has to store [1,2,3], but that could be said about *any* computation of anything. |
| 2025-01-31 01:27:03 +0100 | <dminuoso> | euouae: If we want to derive meaning of Monad, we must constrain to its interface |
| 2025-01-31 01:27:05 +0100 | <dminuoso> | % :t pure |
| 2025-01-31 01:27:06 +0100 | <yahb2> | pure :: Applicative f => a -> f a |
| 2025-01-31 01:27:11 +0100 | <dminuoso> | % :t (>>=) |
| 2025-01-31 01:27:11 +0100 | <yahb2> | (>>=) :: Monad m => m a -> (a -> m b) -> m b |
| 2025-01-31 01:27:36 +0100 | <dminuoso> | If you cannot put your "state" into relationship with that interface, your intuition has nothing to do with Monad, but with something else. |
| 2025-01-31 01:27:56 +0100 | <dminuoso> | These two functions, *together with some laws* are what Monad is. Nothing more, nothing less. |
| 2025-01-31 01:28:08 +0100 | <euouae> | Like I said, it's matching some usual applications of Monad like the parser combinators |
| 2025-01-31 01:28:25 +0100 | <euouae> | You want to content that it's not matching List. I agree, but at the same time, I am not too afraid to stretch my imagination and pretend it does |
| 2025-01-31 01:28:40 +0100 | <euouae> | As long as I can get somewhere with megaparsec :P |
| 2025-01-31 01:28:49 +0100 | <euouae> | anyway sorry for wasting your time... just thoughts |
| 2025-01-31 01:28:50 +0100 | <dminuoso> | euouae: Your intuitoin is absolutely great for megaparsec. |
| 2025-01-31 01:29:10 +0100 | <dminuoso> | But its not a good general intuition, it just does not work for list. |
| 2025-01-31 01:30:37 +0100 | <dminuoso> | euouae: In fact, megaparsec under the hood could be thought of StateT and ExceptT wired together - thats state looks so fitting, because it *does* use a state monad internally. |
| 2025-01-31 01:30:59 +0100 | <euouae> | What is the role of T in StateT? I haven't quite grasped that |
| 2025-01-31 01:31:02 +0100 | <dminuoso> | (Internally it uses a different representation for performance reasons, miond you) |
| 2025-01-31 01:31:04 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 272 seconds) |
| 2025-01-31 01:31:12 +0100 | <euouae> | I haven't seen any examples either. I know a monad goes there, but State has it to be Identity |
| 2025-01-31 01:31:25 +0100 | <hololeap> | it stands for "transformer" |
| 2025-01-31 01:33:18 +0100 | <dminuoso> | euouae: And perhaps, for IO the state notion is not too shabby either as a first try by the way, if we think of the "real world" being the state. This is an intuition I can easily prove wrong, but I think I would rob you of some valuable learning process as monochrom as pointed out earlier. |
| 2025-01-31 01:33:43 +0100 | <dminuoso> | Given that you could just `launchMissiles` and change the state of the real world with IO. |
| 2025-01-31 01:34:33 +0100 | <hololeap> | I can't remember how to do 'unmtl' in #haskell |
| 2025-01-31 01:34:34 +0100 | <euouae> | I'm not sure what you mean by proving it wrong |
| 2025-01-31 01:34:55 +0100 | <euouae> | Is IO not a state |
| 2025-01-31 01:35:03 +0100 | <dminuoso> | euouae: There's a bunch of things you can do in IO that... isnt quite about changing the real world. |
| 2025-01-31 01:35:22 +0100 | <dminuoso> | Or you would need to do some more gymnastics. |
| 2025-01-31 01:35:25 +0100 | <hololeap> | IO being (State RealWorld a) is more of a mental model |
| 2025-01-31 01:35:44 +0100 | <dminuoso> | euouae: I dont want discredit this particular intuition, because I think it *is* a good starting point |
| 2025-01-31 01:36:12 +0100 | <dminuoso> | Just like we teach newtonian physics in school, despite general relativity being more accurate. |
| 2025-01-31 01:37:03 +0100 | <dminuoso> | euouae: Anyhow. Do try to build the state intuition around `>>=` and `pure` - and then test it in the future. |
| 2025-01-31 01:37:19 +0100 | <euouae> | yup. thank you |
| 2025-01-31 01:37:24 +0100 | <euouae> | but what is transformer? |
| 2025-01-31 01:37:49 +0100 | <dminuoso> | euouae: If we think of Monads not as "state" but as some generalized idea of effects, then transformers lets us combine different effects. |
| 2025-01-31 01:37:53 +0100 | <euouae> | With a State I know I have a 'state processor' and an 'output value' but what is the transformer for? |
| 2025-01-31 01:37:55 +0100 | <dminuoso> | THat may or may not make any sense to you. |
| 2025-01-31 01:38:20 +0100 | <dminuoso> | euouae: StateT allows you to drag some state around, while ExceptT allows you to throw exceptions. |
| 2025-01-31 01:38:33 +0100 | <geekosaur> | so, StateT doesn't just model state; it adds state to something. It transforms something else by adding state to it |
| 2025-01-31 01:38:35 +0100 | <dminuoso> | Them being transformers means you can layer them ontop of each other, giving you a Monad that has both state *and* exceptions. |
| 2025-01-31 01:39:00 +0100 | <dminuoso> | And if you add ListT (which adds non-determinism), you could have non-determinism, state and exceptions |
| 2025-01-31 01:39:17 +0100 | <dminuoso> | ANd you can layer it over IO to have state, non-determinism, exceptions and real world nuclear missile effects. |
| 2025-01-31 01:40:04 +0100 | <dminuoso> | euouae: Lets pick a more concrete examplee: |
| 2025-01-31 01:40:29 +0100 | <dminuoso> | euouae: Your megaparsec parser can run either in pure mode, or it can run together with IO. |
| 2025-01-31 01:40:55 +0100 | <dminuoso> | If you use it together with IO, you can interleave your parser with IO - say print statements or database calls |
| 2025-01-31 01:41:14 +0100 | <dminuoso> | The reason you can do this, is because all this parsing effect is in a transformer ParsecT which you can layer over any other monad. |
| 2025-01-31 01:41:25 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 01:41:46 +0100 | <dminuoso> | If you dont want IO, you can just layer it over `Identity`, which is sort of the "does nothing monad", giving you just the parsing effects. |
| 2025-01-31 01:42:06 +0100 | <dminuoso> | https://hackage.haskell.org/package/megaparsec-9.7.0/docs/Text-Megaparsec.html#t:Parsec |
| 2025-01-31 01:42:13 +0100 | <dminuoso> | type Parsec e s = ParsecT e s Identity |
| 2025-01-31 01:43:15 +0100 | <dminuoso> | You can also use `ParsecT e s IO`, then you can suddenly do `liftIO (putStrLn "Hello world")` in the middle of your parser. Note, that because megaparsec will do backtracking this will have some interesting/strange behavior... which is non-determinism in fact. |
| 2025-01-31 01:43:29 +0100 | <dminuoso> | (Assuming you use `try` of course) |
| 2025-01-31 01:44:15 +0100 | <euouae> | right |
| 2025-01-31 01:44:32 +0100 | <euouae> | I'm going to assume that it'll leak out the details of try |
| 2025-01-31 01:45:16 +0100 | monochrm | (trebla@216.138.220.146) |
| 2025-01-31 01:45:40 +0100 | <euouae> | I think my composable state machine intuition is running into trouble with StateT. Transformers seem like a different beast, I'll have to think about it more. |
| 2025-01-31 01:45:55 +0100 | <euouae> | But your example is very helpful, to keep in mind pure computation / IO stuff inside parsing |
| 2025-01-31 01:46:00 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds) |
| 2025-01-31 01:46:29 +0100 | monochrom | (trebla@216.138.220.146) (Ping timeout: 260 seconds) |
| 2025-01-31 01:46:30 +0100 | monochrm | monochrom |
| 2025-01-31 01:48:52 +0100 | mange | (~user@user/mange) mange |
| 2025-01-31 01:48:53 +0100 | <dminuoso> | euouae: One last thing: That "funky composition" you talked about, that's where the monad lies. :-) |
| 2025-01-31 01:49:18 +0100 | <dminuoso> | Just keep that thought mind for the future |
| 2025-01-31 01:49:55 +0100 | <dminuoso> | % :t join |
| 2025-01-31 01:49:55 +0100 | <yahb2> | <interactive>:1:1: error: [GHC-88464] Variable not in scope: join |
| 2025-01-31 01:50:01 +0100 | <dminuoso> | % import Control.Monad |
| 2025-01-31 01:50:01 +0100 | <yahb2> | <no output> |
| 2025-01-31 01:50:03 +0100 | <dminuoso> | % :t join |
| 2025-01-31 01:50:03 +0100 | <yahb2> | join :: Monad m => m (m a) -> m a |
| 2025-01-31 01:50:58 +0100 | <dminuoso> | euouae: This is an alternate description of (>>=), and it perhaps visualizes nicely that there's a sort of composition idea going on. |
| 2025-01-31 01:51:10 +0100 | <dminuoso> | Anyway. This was just meant as a teaser. |
| 2025-01-31 01:51:47 +0100 | rstromlund | (~user@user/rstromlund) rstromlund |
| 2025-01-31 01:52:28 +0100 | alfiee | (~alfiee@user/alfiee) alfiee |
| 2025-01-31 01:52:40 +0100 | <int-e> | @djinn ((((a -> r) -> r) -> r) -> r) -> (a -> r) -> r |
| 2025-01-31 01:52:41 +0100 | <lambdabot> | f a b = a (\ c -> c b) |
| 2025-01-31 01:53:06 +0100 | acidjnk_new3 | (~acidjnk@p200300d6e7283f4679216c0ad7f4b91d.dip0.t-ipconnect.de) (Ping timeout: 246 seconds) |
| 2025-01-31 01:54:15 +0100 | xff0x | (~xff0x@2405:6580:b080:900:704:c9bd:a645:9b1d) (Ping timeout: 276 seconds) |
| 2025-01-31 01:56:36 +0100 | alfiee | (~alfiee@user/alfiee) (Ping timeout: 246 seconds) |
| 2025-01-31 01:56:40 +0100 | rstromlund | (~user@user/rstromlund) (Ping timeout: 265 seconds) |
| 2025-01-31 01:56:47 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 02:01:09 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 246 seconds) |
| 2025-01-31 02:02:24 +0100 | joeyadams | (~joeyadams@syn-184-054-105-097.res.spectrum.com) (Quit: Leaving) |
| 2025-01-31 02:03:12 +0100 | <hololeap> | @unmtl StateT Int IO String |
| 2025-01-31 02:03:12 +0100 | <lambdabot> | Int -> IO (String, Int) |
| 2025-01-31 02:03:18 +0100 | <hololeap> | nice, there we go |
| 2025-01-31 02:12:12 +0100 | sprotte24 | (~sprotte24@p200300d16f0f520069bfd2b9cee1df34.dip0.t-ipconnect.de) (Quit: Leaving) |
| 2025-01-31 02:12:20 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 02:16:32 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds) |
| 2025-01-31 02:18:49 +0100 | rstromlund | (~user@user/rstromlund) rstromlund |
| 2025-01-31 02:20:44 +0100 | otto_s | (~user@p5b0441ee.dip0.t-ipconnect.de) (Ping timeout: 260 seconds) |
| 2025-01-31 02:22:30 +0100 | otto_s | (~user@p5de2fd05.dip0.t-ipconnect.de) |
| 2025-01-31 02:24:26 +0100 | monochrm | (trebla@216.138.220.146) |
| 2025-01-31 02:25:58 +0100 | monochrom | (trebla@216.138.220.146) (Ping timeout: 252 seconds) |
| 2025-01-31 02:25:58 +0100 | monochrm | monochrom |
| 2025-01-31 02:26:00 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 264 seconds) |
| 2025-01-31 02:27:42 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 02:32:24 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds) |
| 2025-01-31 02:34:34 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 02:37:55 +0100 | xff0x | (~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) |
| 2025-01-31 02:38:26 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2025-01-31 02:38:57 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 246 seconds) |
| 2025-01-31 02:38:58 +0100 | monochrom | (trebla@216.138.220.146) (Ping timeout: 244 seconds) |
| 2025-01-31 02:39:26 +0100 | monochrom | (trebla@216.138.220.146) |
| 2025-01-31 02:41:13 +0100 | alfiee | (~alfiee@user/alfiee) alfiee |
| 2025-01-31 02:44:56 +0100 | Sgeo | (~Sgeo@user/sgeo) Sgeo |
| 2025-01-31 02:45:59 +0100 | alfiee | (~alfiee@user/alfiee) (Ping timeout: 265 seconds) |
| 2025-01-31 02:49:53 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 02:51:25 +0100 | Square2 | (~Square4@user/square) Square |
| 2025-01-31 02:54:28 +0100 | Square | (~Square@user/square) (Ping timeout: 244 seconds) |
| 2025-01-31 02:54:44 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds) |
| 2025-01-31 03:04:16 +0100 | weary-traveler | (~user@user/user363627) (Remote host closed the connection) |
| 2025-01-31 03:05:17 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 03:06:03 +0100 | mikess | (~mikess@user/mikess) mikess |
| 2025-01-31 03:09:17 +0100 | <euouae> | why is `State s a` but `state :: a -> (a, s)`? the order is reversed |
| 2025-01-31 03:09:41 +0100 | <euouae> | sorry, I mean, state :: Monad m => (s -> (a, s)) -> StateT s m a |
| 2025-01-31 03:12:04 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds) |
| 2025-01-31 03:16:04 +0100 | Tuplanolla | (~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Quit: Leaving.) |
| 2025-01-31 03:23:20 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-01-31 03:25:04 +0100 | mikess | (~mikess@user/mikess) (Ping timeout: 272 seconds) |
| 2025-01-31 03:26:30 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2025-01-31 03:29:10 +0100 | Sgeo | (~Sgeo@user/sgeo) Sgeo |
| 2025-01-31 03:29:36 +0100 | alfiee | (~alfiee@user/alfiee) alfiee |
| 2025-01-31 03:31:58 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds) |
| 2025-01-31 03:33:37 +0100 | Tikosh | (~quassel@user/Tikosh) Tikosh |