IRCBrowse

2023/12/06

2023-12-06 00:01:35 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-12-06 00:05:21 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2023-12-06 00:17:23 +0100kmein(~weechat@user/kmein) (Ping timeout: 264 seconds)
2023-12-06 00:27:22 +0100acidjnk_new(~acidjnk@p200300d6e72b9307019ea696578e67a2.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-12-06 00:29:55 +0100tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2023-12-06 00:41:19 +0100talismanick(~user@2601:204:ef00:bb0::f34e) (Remote host closed the connection)
2023-12-06 00:42:22 +0100talismanick(~user@2601:204:ef00:bb0::f34e)
2023-12-06 00:48:29 +0100Sgeo(~Sgeo@user/sgeo)
2023-12-06 00:49:41 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-06 00:52:46 +0100 <darchitect> Rembane: thanks ! I will have a look
2023-12-06 01:02:05 +0100 <Rembane> darchitect: No worries! Also, we're here if you have any questions.
2023-12-06 01:25:48 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-06 01:26:32 +0100Square2(~Square4@user/square)
2023-12-06 01:29:12 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-12-06 01:30:07 +0100Square(~Square@user/square) (Ping timeout: 276 seconds)
2023-12-06 01:43:19 +0100tomith(tomith@user/tomith) (Quit: tomith)
2023-12-06 01:43:50 +0100xff0x(~xff0x@2405:6580:b080:900:7175:c6a6:e4c5:7fc9) (Ping timeout: 256 seconds)
2023-12-06 01:45:19 +0100xff0x(~xff0x@2405:6580:b080:900:f141:53b1:8840:95f3)
2023-12-06 01:48:29 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 256 seconds)
2023-12-06 01:48:41 +0100xff0x(~xff0x@2405:6580:b080:900:f141:53b1:8840:95f3) (Client Quit)
2023-12-06 01:50:07 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 260 seconds)
2023-12-06 01:51:24 +0100xff0x(~xff0x@2405:6580:b080:900:3547:f7c0:e559:ee75)
2023-12-06 01:52:50 +0100dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-12-06 01:55:15 +0100jespada_(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Ping timeout: 260 seconds)
2023-12-06 01:55:15 +0100dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 01:55:23 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-12-06 01:58:07 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-12-06 02:09:23 +0100Pixi`(~Pixi@user/pixi) (Ping timeout: 268 seconds)
2023-12-06 02:20:27 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-12-06 02:22:28 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com) (Quit: myxos)
2023-12-06 02:36:29 +0100 <jackdk> Which "rank 2 functor/traversable/etc" package is most recommended these days? barbies/conkin/hkd/rank2classes/something else I've missed?
2023-12-06 02:36:40 +0100Pixi(~Pixi@user/pixi)
2023-12-06 02:49:12 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com)
2023-12-06 02:52:56 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 252 seconds)
2023-12-06 02:56:08 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04)
2023-12-06 02:57:43 +0100thegeekinside(~thegeekin@189.141.65.247) (Remote host closed the connection)
2023-12-06 03:04:20 +0100pointlessslippe1(~pointless@212.82.82.3) (Ping timeout: 256 seconds)
2023-12-06 03:06:02 +0100pointlessslippe1(~pointless@212.82.82.3)
2023-12-06 03:14:07 +0100talismanick(~user@2601:204:ef00:bb0::f34e) (Ping timeout: 260 seconds)
2023-12-06 03:23:19 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-12-06 03:26:15 +0100thegeekinside(~thegeekin@189.141.65.247)
2023-12-06 03:26:22 +0100Square2(~Square4@user/square) (Ping timeout: 260 seconds)
2023-12-06 03:27:20 +0100dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-12-06 03:28:11 +0100Katarushisu19(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-12-06 03:28:19 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-12-06 03:28:58 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Ping timeout: 255 seconds)
2023-12-06 03:29:48 +0100dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 03:29:59 +0100Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Ping timeout: 264 seconds)
2023-12-06 03:29:59 +0100Katarushisu19Katarushisu1
2023-12-06 03:33:03 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-12-06 03:40:02 +0100xff0x(~xff0x@2405:6580:b080:900:3547:f7c0:e559:ee75) (Ping timeout: 256 seconds)
2023-12-06 03:40:25 +0100ec(~ec@gateway/tor-sasl/ec) (Read error: Connection reset by peer)
2023-12-06 03:40:25 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-12-06 03:40:48 +0100ec(~ec@gateway/tor-sasl/ec)
2023-12-06 03:41:31 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-12-06 03:46:42 +0100benjaminl(~benjaminl@user/benjaminl) (Remote host closed the connection)
2023-12-06 03:47:43 +0100benjaminl(~benjaminl@user/benjaminl)
2023-12-06 03:51:48 +0100docelif^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2023-12-06 04:01:03 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-12-06 04:16:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-12-06 04:18:41 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 245 seconds)
2023-12-06 04:20:47 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2023-12-06 04:23:48 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-12-06 04:31:07 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:97d:c646:7189:b78d) (Remote host closed the connection)
2023-12-06 04:31:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 04:39:10 +0100foul_owl(~kerry@157.97.134.165) (Ping timeout: 255 seconds)
2023-12-06 04:47:23 +0100td_(~td@i5387092A.versanet.de) (Ping timeout: 264 seconds)
2023-12-06 04:49:04 +0100td_(~td@i53870917.versanet.de)
2023-12-06 04:50:46 +0100Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: Ping timeout (120 seconds))
2023-12-06 04:51:06 +0100Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-12-06 04:53:39 +0100foul_owl(~kerry@157.97.134.165)
2023-12-06 04:54:05 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-12-06 04:54:05 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-12-06 04:54:05 +0100finn_elijaFinnElija
2023-12-06 05:08:35 +0100Buliarous(~gypsydang@46.232.210.139)
2023-12-06 05:10:30 +0100ania123(~ania123@94-43-231-47.dsl.utg.ge)
2023-12-06 05:18:35 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-12-06 05:40:08 +0100YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 256 seconds)
2023-12-06 05:44:58 +0100aforemny_(~aforemny@2001:9e8:6cde:cb00:5605:e8df:30a7:a7a3)
2023-12-06 05:46:22 +0100aforemny(~aforemny@2001:9e8:6cfa:3700:318d:661c:fcd5:6731) (Ping timeout: 260 seconds)
2023-12-06 05:47:04 +0100gentauro(~gentauro@user/gentauro) (Ping timeout: 268 seconds)
2023-12-06 06:04:54 +0100ania123(~ania123@94-43-231-47.dsl.utg.ge) (Quit: Client closed)
2023-12-06 06:10:31 +0100thegeekinside(~thegeekin@189.141.65.247) (Ping timeout: 255 seconds)
2023-12-06 06:17:25 +0100kmein(~weechat@user/kmein)
2023-12-06 06:19:08 +0100abrar_(~abrar@pool-108-52-90-30.phlapa.fios.verizon.net) (Ping timeout: 268 seconds)
2023-12-06 06:20:49 +0100abrar_(~abrar@pool-72-78-199-167.phlapa.fios.verizon.net)
2023-12-06 06:29:19 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-12-06 06:29:59 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 06:31:46 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-12-06 06:31:55 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 06:45:36 +0100igemnace(~ian@user/igemnace)
2023-12-06 06:57:43 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 276 seconds)
2023-12-06 06:58:02 +0100newsham(~newsham@2603-800c-2c01-6825-e926-a2cb-be50-5432.res6.spectrum.com)
2023-12-06 06:58:26 +0100euleritian(~euleritia@dynamic-002-247-248-016.2.247.pool.telefonica.de)
2023-12-06 06:59:19 +0100 <newsham> if (in CT) a monoid has one object, and the morphisms are (for instance) integers and composition is (for instance) multiplication, and identity is (eg) "1".  What is the object itself?
2023-12-06 07:00:08 +0100 <EvanR> the set of integers is the one object
2023-12-06 07:00:55 +0100 <EvanR> er
2023-12-06 07:01:00 +0100 <int-e> newsham: If you describe it like that, the object can be totally abstract. Or you can do the arrow-only CT thing where the object is the identity morphism
2023-12-06 07:01:05 +0100 <newsham> why is a morphism "3" an arrow from the set of integers to itself?
2023-12-06 07:01:31 +0100 <int-e> newsham: it becomes a function if you interpret it as (*3)
2023-12-06 07:01:32 +0100 <EvanR> I'm wrong, each arrow is an integer, and the object is whatever, "*"
2023-12-06 07:01:35 +0100 <EvanR> unit
2023-12-06 07:01:57 +0100 <newsham> ok.. i guess thats easier to grok.  morphism is (*3), and composition is just normal func composition
2023-12-06 07:02:03 +0100 <newsham> and object is set of ints.
2023-12-06 07:02:05 +0100 <EvanR> morphisms don't need to be functions
2023-12-06 07:02:18 +0100 <newsham> right, thats why i was trying to not assume the morphism was a func
2023-12-06 07:02:30 +0100 <newsham> but having a hard time grokking what the object was then
2023-12-06 07:02:44 +0100 <EvanR> the more important part there is that there is only one object
2023-12-06 07:02:46 +0100 <int-e> newsham: it could literally be anything
2023-12-06 07:02:55 +0100 <EvanR> it doesn't do anything else
2023-12-06 07:03:05 +0100 <int-e> the only role of the object is to serve as source and target of your morphisms
2023-12-06 07:03:25 +0100 <newsham> i still have a hard time wrapping my head around the construction though..  what justification do i have to say that "3" is a morphism from "abstract thing" to itself?
2023-12-06 07:03:49 +0100 <int-e> you just define the source and target of 3 to be that object
2023-12-06 07:04:01 +0100 <EvanR> you didn't construct it, you just looked at that monoid through ct beer goggles
2023-12-06 07:04:37 +0100 <newsham> when looking at monoid through the goggles, my eyes only see "set of integers" as an object.
2023-12-06 07:04:50 +0100 <int-e> There's really no further required meaning to it. You can compose f and g if the target of g is the source of f.
2023-12-06 07:05:02 +0100 <newsham> but i think the treating numbers as functions and the ojbect as ints and composition as func composition works well enough for me.  its a valid construction
2023-12-06 07:05:16 +0100 <int-e> You take the definition of a category and check all the properties.
2023-12-06 07:05:22 +0100 <EvanR> you could make an inspirational diagram of that category: it would have 1 object and an infinite number of arrows coming out of it and going back in, one for each integer
2023-12-06 07:05:33 +0100 <EvanR> the definition of morphism composition is multiplication of corresponding integers
2023-12-06 07:05:38 +0100 <newsham> it seems really arbitrary to me that I would out of thin air delcare that "3" goes from "a" to "a" without saying what "a" is.  like.. cant i just do that in other contexts where it would lead to nonsense?
2023-12-06 07:05:39 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-12-06 07:06:02 +0100 <EvanR> like when you draw a diagram in geometry, you put a point called A, it's just a point, it's nothing more
2023-12-06 07:06:17 +0100 <EvanR> it serves to end line segments or draw lines through
2023-12-06 07:06:21 +0100 <EvanR> or center a circle
2023-12-06 07:06:28 +0100 <int-e> newsham: welcome to abstract nonsense I suppose
2023-12-06 07:06:58 +0100 <EvanR> we make up meaningless things all the time in haskell
2023-12-06 07:07:07 +0100 <EvanR> data () = (), what is ()? doesn't matter
2023-12-06 07:07:11 +0100 <newsham> well i guess my concrete question here, which i dont have enough depth to know the answer to, is literally "could I do the same construction in another context where it doesnt make sense and result in nonsense"
2023-12-06 07:07:12 +0100 <int-e> > fix id
2023-12-06 07:07:14 +0100 <lambdabot> *Exception: <<loop>>
2023-12-06 07:07:21 +0100 <newsham> I have no problem with unit :)
2023-12-06 07:07:33 +0100 <EvanR> why is unit not objectionable on the same grounds
2023-12-06 07:07:34 +0100 <newsham> I have no problem with bottom (if its in your code, not mine)
2023-12-06 07:07:59 +0100 <int-e> newsham: you can define a structure that has all the operations of a category but violates its laws.
2023-12-06 07:08:01 +0100todi1(~todi@pd9571076.dip0.t-ipconnect.de)
2023-12-06 07:08:05 +0100 <newsham> i'm not against having abstract things..  like I said, it boils down to that one question above.
2023-12-06 07:08:06 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-12-06 07:08:09 +0100todi(~todi@pd9571327.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-12-06 07:08:25 +0100 <int-e> like if you have one object *, integers as morphisms, but you use subtraction for composition
2023-12-06 07:08:27 +0100 <newsham> perhaps i just need to go deeper and revisit my question later.
2023-12-06 07:08:31 +0100ec(~ec@gateway/tor-sasl/ec)
2023-12-06 07:08:31 +0100 <EvanR> you could also look at the category structure (or monoid structure for that matter) as an interface
2023-12-06 07:08:38 +0100 <int-e> which... isn't a monoid.
2023-12-06 07:08:52 +0100zetef(~quassel@95.77.17.251)
2023-12-06 07:09:09 +0100 <int-e> and it turns out that with a single object, categories correspond exactly to usual monoids from abstract algebra.
2023-12-06 07:09:29 +0100 <newsham> yes thats what i'm exploring.
2023-12-06 07:09:54 +0100 <newsham> i mostly get it except this question.  ok..  well, back into the breach. thanks for the conversation
2023-12-06 07:10:06 +0100 <int-e> You just have that extra "object" thing around. Which goes away if you identify objects and their identity morphisms, as already mentioned.
2023-12-06 07:10:31 +0100 <EvanR> conflating different things as being the same should make it more confusing usually xD
2023-12-06 07:10:59 +0100 <int-e> newsham: this is similar to what EvanR said... what's the meaning of "x"? :-)
2023-12-06 07:11:05 +0100 <EvanR> which is why "correspond" is probably easier than "is really" when talking about monoids being categories
2023-12-06 07:12:00 +0100 <int-e> once you've internalized the correspondence the difference vanishes ;-)
2023-12-06 07:12:24 +0100 <EvanR> unless you use homotopy type theory
2023-12-06 07:13:02 +0100 <EvanR> which puts my suggestion of draw diagrams into overdrive
2023-12-06 07:13:04 +0100 <int-e> I ... don't.
2023-12-06 07:13:26 +0100 <int-e> I barely use category theory ;)
2023-12-06 07:15:29 +0100 <EvanR> different points in the space "are equal" if you have a path between them, and if there is only 1 connected component to the space, everything is equal. But there could be non trivial spatial structure, so equivalences aren't equal. In which case you couldn't collapse the entire space into a single point unfortunately for the reductionist!
2023-12-06 07:15:31 +0100acidjnk_new(~acidjnk@p200300d6e72b933411fabc01fd6787da.dip0.t-ipconnect.de)
2023-12-06 07:16:33 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 07:20:39 +0100benjaminl(~benjaminl@user/benjaminl) (Remote host closed the connection)
2023-12-06 07:21:58 +0100benjaminl(~benjaminl@user/benjaminl)
2023-12-06 07:22:44 +0100snek(sid280155@id-280155.lymington.irccloud.com) (Ping timeout: 256 seconds)
2023-12-06 07:23:01 +0100snek(sid280155@id-280155.lymington.irccloud.com)
2023-12-06 07:28:45 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 07:35:35 +0100igemnace(~ian@user/igemnace) (Read error: Connection reset by peer)
2023-12-06 07:36:18 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1)
2023-12-06 07:40:44 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-12-06 07:47:17 +0100trev(~trev@user/trev)
2023-12-06 07:53:17 +0100igemnace(~ian@user/igemnace)
2023-12-06 07:55:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 08:02:59 +0100analoq(~yashi@user/dies) (Ping timeout: 264 seconds)
2023-12-06 08:04:18 +0100analoq(~yashi@user/dies)
2023-12-06 08:05:49 +0100ubert1(~Thunderbi@178.165.165.175.wireless.dyn.drei.com)
2023-12-06 08:05:58 +0100ubert(~Thunderbi@91.141.79.49.wireless.dyn.drei.com) (Ping timeout: 276 seconds)
2023-12-06 08:05:58 +0100ubert1ubert
2023-12-06 08:07:40 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 268 seconds)
2023-12-06 08:11:52 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 08:12:05 +0100ft(~ft@p4fc2a395.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-12-06 08:14:13 +0100ft(~ft@p3e9bc784.dip0.t-ipconnect.de)
2023-12-06 08:15:02 +0100kenran(~user@user/kenran)
2023-12-06 08:19:08 +0100newsham(~newsham@2603-800c-2c01-6825-e926-a2cb-be50-5432.res6.spectrum.com) (Quit: Client closed)
2023-12-06 08:24:13 +0100alp_(~alp@2001:861:e3d6:8f80:4f0:3b3:6172:8f1e)
2023-12-06 08:25:52 +0100docelif^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-12-06 08:27:25 +0100Igloo(~ian@matrix.chaos.earth.li) (Ping timeout: 260 seconds)
2023-12-06 08:30:26 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2023-12-06 08:35:22 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-12-06 08:37:06 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 08:39:16 +0100chele(~chele@user/chele)
2023-12-06 08:42:54 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-06 08:45:08 +0100Igloo(~ian@2001:8b0:645c::210)
2023-12-06 08:51:43 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-12-06 08:59:30 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-12-06 08:59:59 +0100Guest16(~Guest16@136.169.59.60)
2023-12-06 09:00:04 +0100euleritian(~euleritia@dynamic-002-247-248-016.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-12-06 09:00:10 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 255 seconds)
2023-12-06 09:00:22 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 09:02:23 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 264 seconds)
2023-12-06 09:04:20 +0100rosco(~rosco@175.136.158.171)
2023-12-06 09:25:54 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-12-06 09:27:46 +0100benjaminl(~benjaminl@user/benjaminl) (Remote host closed the connection)
2023-12-06 09:28:40 +0100benjaminl(~benjaminl@user/benjaminl)
2023-12-06 09:32:23 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 264 seconds)
2023-12-06 09:34:16 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-12-06 09:39:12 +0100zetef(~quassel@95.77.17.251)
2023-12-06 09:44:56 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-12-06 09:47:43 +0100CiaoSen(~Jura@2a05:5800:281:b200:ca4b:d6ff:fec1:99da)
2023-12-06 09:50:05 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 09:51:40 +0100swamp_(~zmt00@user/zmt00)
2023-12-06 09:52:14 +0100swamp_(~zmt00@user/zmt00) (Max SendQ exceeded)
2023-12-06 09:53:01 +0100swamp_(~zmt00@user/zmt00)
2023-12-06 09:54:31 +0100zmt01(~zmt00@user/zmt00) (Ping timeout: 245 seconds)
2023-12-06 09:58:11 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-06 09:58:40 +0100tessier(~treed@ec2-184-72-149-67.compute-1.amazonaws.com) (Ping timeout: 268 seconds)
2023-12-06 10:01:30 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2023-12-06 10:07:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 10:14:16 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-12-06 10:15:04 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-12-06 10:18:22 +0100notzmv(~zmv@user/notzmv)
2023-12-06 10:18:51 +0100gehmehgeh(~user@user/gehmehgeh)
2023-12-06 10:22:26 +0100aforemny(~aforemny@i59F516FF.versanet.de)
2023-12-06 10:22:27 +0100aforemny_(~aforemny@2001:9e8:6cde:cb00:5605:e8df:30a7:a7a3) (Ping timeout: 256 seconds)
2023-12-06 10:23:23 +0100cfricke(~cfricke@user/cfricke)
2023-12-06 10:26:25 +0100qqq(~qqq@92.43.167.61)
2023-12-06 10:26:39 +0100mmhat(~mmh@p200300f1c726935cee086bfffe095315.dip0.t-ipconnect.de)
2023-12-06 10:27:01 +0100[_][itchyjunk]
2023-12-06 10:27:34 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-12-06 10:28:00 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 256 seconds)
2023-12-06 10:31:13 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 246 seconds)
2023-12-06 10:32:24 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04) (Quit: Konversation terminated!)
2023-12-06 10:36:40 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04)
2023-12-06 10:38:19 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04) (Client Quit)
2023-12-06 10:40:01 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 10:40:01 +0100tessier(~treed@ec2-184-72-149-67.compute-1.amazonaws.com)
2023-12-06 10:43:09 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-12-06 10:44:29 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04)
2023-12-06 10:44:31 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Ping timeout: 245 seconds)
2023-12-06 10:44:31 +0100chele(~chele@user/chele)
2023-12-06 10:46:16 +0100tessier(~treed@ec2-184-72-149-67.compute-1.amazonaws.com) (Ping timeout: 255 seconds)
2023-12-06 10:47:19 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04) (Client Quit)
2023-12-06 10:49:16 +0100zetef(~quassel@95.77.17.251)
2023-12-06 10:51:37 +0100 <phma> I've been working on a library in Haskell and Rust (two implementations in one repo, with a shell script that runs both and compares them). The Rust version starts at 0.1.0 and the Haskell version
2023-12-06 10:52:00 +0100 <phma> starts at 0.1.0.0. How should I handle correspondence between the version numbers?
2023-12-06 10:53:23 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2023-12-06 10:53:48 +0100 <haskellbridge> 06<s​m> why not make them the same ?
2023-12-06 10:54:08 +0100gehmehgeh(~user@user/gehmehgeh)
2023-12-06 10:54:18 +0100 <phma> because they use different formats of version numbers
2023-12-06 10:54:34 +0100 <haskellbridge> 06<s​m> why ?
2023-12-06 10:55:18 +0100 <haskellbridge> 06<s​m> haskell doesn't require a particular number of version number components AFAIK
2023-12-06 10:56:00 +0100 <phma> https://stackoverflow.com/questions/37201431/why-does-haskell-versioning-policy-have-two-places-fo…
2023-12-06 10:56:14 +0100 <c_wraith> haskell doesn't but there is a convention
2023-12-06 10:56:33 +0100 <[exa]> oh whoops I always thought that it's 3 semver numbers + 1 for maintainer uploads
2023-12-06 10:56:35 +0100 <c_wraith> but there's no reason you can't make the haskell version the rust version with a "0." in front of it
2023-12-06 10:56:50 +0100 <haskellbridge> 06<s​m> 0.1 is a perfectly fine haskell package version
2023-12-06 10:56:54 +0100 <phma> https://pvp.haskell.org/
2023-12-06 10:56:57 +0100__monty__(~toonn@user/toonn)
2023-12-06 10:57:08 +0100 <c_wraith> sm: you're sort of missing the point, which is to not be like stack
2023-12-06 10:57:40 +0100haskellbridge06<s​m> gets back to work
2023-12-06 10:58:05 +0100 <c_wraith> phma: why do they start at those?
2023-12-06 10:58:12 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1) (Remote host closed the connection)
2023-12-06 10:58:42 +0100 <c_wraith> phma: why not start at, for instance, 0.1.0 and 0.0.1.0?
2023-12-06 10:58:57 +0100 <phma> c_wraith: I don't know, that's the starting version number when creating a project
2023-12-06 10:59:34 +0100 <phma> I could do that, I suppose, since I haven't tagged anything yet
2023-12-06 10:59:53 +0100 <phma> or used the library in anything else
2023-12-06 11:00:50 +0100 <phma> also, is there a tool that, given two versions of a library, tells what needs to be bumped in the version number?
2023-12-06 11:01:12 +0100 <c_wraith> I think someone has made something like that, but I can't remember any details at all
2023-12-06 11:01:24 +0100 <phma> afk — kitchen time
2023-12-06 11:01:33 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-12-06 11:01:39 +0100danse-nr3(~danse@rm-19-20-84.service.infuturo.it)
2023-12-06 11:03:19 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection)
2023-12-06 11:04:02 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-12-06 11:15:35 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 264 seconds)
2023-12-06 11:16:36 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 245 seconds)
2023-12-06 11:16:39 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-12-06 11:17:26 +0100tessier(~treed@ec2-184-72-149-67.compute-1.amazonaws.com)
2023-12-06 11:17:51 +0100danse-nr3(~danse@rm-19-20-84.service.infuturo.it) (Ping timeout: 256 seconds)
2023-12-06 11:19:40 +0100Lord_of_Life_Lord_of_Life
2023-12-06 11:21:07 +0100danse-nr3(~danse@rm-19-20-84.service.infuturo.it)
2023-12-06 11:22:06 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com) (Remote host closed the connection)
2023-12-06 11:22:45 +0100 <trev> how do I understand this line: `map f >>> foldr (>>>) id`?
2023-12-06 11:23:39 +0100cods(~fred@tuxee.net) (Ping timeout: 256 seconds)
2023-12-06 11:23:43 +0100 <trev> where the inputs are `List -> Int`
2023-12-06 11:23:54 +0100 <danse-nr3> huh i think the parenthesis are useless there
2023-12-06 11:24:06 +0100 <danse-nr3> % :t (>>>)
2023-12-06 11:24:06 +0100 <yahb2> <interactive>:1:1: error: ; • Variable not in scope: >>> ; • Perhaps you meant one of these: ; ‘>>’ (imported from Prelude), ‘>>=’ (imported from Prelude), ; ‘>=>’ (imported...
2023-12-06 11:24:08 +0100Guest16(~Guest16@136.169.59.60) (Ping timeout: 250 seconds)
2023-12-06 11:24:16 +0100 <danse-nr3> @hoogle >>>
2023-12-06 11:24:16 +0100 <lambdabot> Control.Arrow (>>>) :: Category cat => cat a b -> cat b c -> cat a c
2023-12-06 11:24:16 +0100 <lambdabot> Control.Category (>>>) :: Category cat => cat a b -> cat b c -> cat a c
2023-12-06 11:24:16 +0100 <lambdabot> GHC.Desugar (>>>) :: forall arr . Arrow arr => forall a b c . arr a b -> arr b c -> arr a c
2023-12-06 11:24:32 +0100 <[exa]> >>> is the arrow composition, IMO it's valid with the parentheses there
2023-12-06 11:24:58 +0100 <danse-nr3> cool then
2023-12-06 11:25:15 +0100 <trev> can you re-write that without >>>?
2023-12-06 11:25:31 +0100 <trev> cause i don't really understand how the functions are composed
2023-12-06 11:25:46 +0100 <danse-nr3> > 1 (+) 1
2023-12-06 11:25:47 +0100 <lambdabot> error:
2023-12-06 11:25:47 +0100 <lambdabot> • Could not deduce (Num a0)
2023-12-06 11:25:47 +0100 <lambdabot> from the context: (Num a, Num t, Num ((a -> a -> a) -> t -> t1))
2023-12-06 11:26:19 +0100 <danse-nr3> i see
2023-12-06 11:26:49 +0100 <danse-nr3> > import Control.Arrow
2023-12-06 11:26:51 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘import’
2023-12-06 11:26:56 +0100 <[Leary]> % :t \f -> map f >>> foldr (>>>) id
2023-12-06 11:26:56 +0100 <yahb2> \f -> map f >>> foldr (>>>) id :: (a -> b -> b) -> [a] -> b -> b
2023-12-06 11:27:03 +0100 <[Leary]> % :t \f -> foldr (flip (.)) id . map f
2023-12-06 11:27:03 +0100 <yahb2> \f -> foldr (flip (.)) id . map f :: (a -> c -> c) -> [a] -> c -> c
2023-12-06 11:27:18 +0100 <[exa]> +1 [Leary] ^^
2023-12-06 11:27:33 +0100 <danse-nr3> maybe go step by step trev
2023-12-06 11:27:40 +0100 <[exa]> not that it would remove the function composition but it's hard to remove function composition from code that only does function composition right...
2023-12-06 11:27:42 +0100 <danse-nr3> % :t foldr (>>>) id
2023-12-06 11:27:42 +0100 <yahb2> foldr (>>>) id :: Foldable t => t (b -> b) -> b -> b
2023-12-06 11:28:52 +0100 <danse-nr3> % foldr (>>>) id [+1, +2] 0
2023-12-06 11:28:52 +0100 <yahb2> <interactive>:81:17: error: ; A section must be enclosed in parentheses thus: (+ 1) ; ; <interactive>:81:21: error: ; A section must be enclosed in parentheses thus: (+ 2)
2023-12-06 11:29:06 +0100 <danse-nr3> % foldr (>>>) id [(+1), (+2)] 0
2023-12-06 11:29:06 +0100 <yahb2> 3
2023-12-06 11:31:33 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 11:32:32 +0100 <trev> so the foldr is being applied before the `map f` in my example?
2023-12-06 11:34:58 +0100 <danse-nr3> hmm i am not very familiar with arrows but i think we can test with functions to know the answer
2023-12-06 11:34:58 +0100cods(~fred@tuxee.net)
2023-12-06 11:35:24 +0100 <[exa]> trev: it should roughly correspond to: `foldr (>>>) id (map f ( ....something ...))`
2023-12-06 11:35:37 +0100 <[exa]> :t (>>>)
2023-12-06 11:35:37 +0100 <lambdabot> forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
2023-12-06 11:36:01 +0100 <[exa]> (>>>) pipes from left to right, unlike (.)
2023-12-06 11:36:26 +0100 <danse-nr3> :t (<> "1") >>> (<> "2")
2023-12-06 11:36:27 +0100 <lambdabot> [Char] -> [Char]
2023-12-06 11:36:40 +0100 <danse-nr3> ((<> "1") >>> (<> "2")) ""
2023-12-06 11:36:48 +0100 <danse-nr3> % ((<> "1") >>> (<> "2")) ""
2023-12-06 11:36:48 +0100 <yahb2> "12"
2023-12-06 11:36:58 +0100 <trev> so there is no way to explain it by being extra verbose? like using intermediate values or something?
2023-12-06 11:37:27 +0100 <trev> or just in terms of simple things like `map` and `foldr`
2023-12-06 11:37:57 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 268 seconds)
2023-12-06 11:39:47 +0100 <danse-nr3> there are no intermediate values i think. The functions or the two sides of the main >>> are composed as shown above, the other >>> is used to build a function with foldr
2023-12-06 11:40:37 +0100 <danse-nr3> if we consider that >>> is working as the opposite of . , maybe that answers your question about intermediate values
2023-12-06 11:41:11 +0100 <danse-nr3> i guess you can make it clear bu having specific variables with type annotation for each function and then a line with `f >>> g`
2023-12-06 11:41:21 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds)
2023-12-06 11:41:22 +0100 <danse-nr3> *clearer and *by
2023-12-06 11:43:18 +0100danse-nr3(~danse@rm-19-20-84.service.infuturo.it) (Read error: Connection reset by peer)
2023-12-06 11:43:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 11:44:22 +0100danse-nr3(~danse@rm-19-55-63.service.infuturo.it)
2023-12-06 11:46:12 +0100 <phma> c_wraith: I changed it to 0.0.1.0, seems to be no problem
2023-12-06 11:48:30 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Ping timeout: 260 seconds)
2023-12-06 11:48:41 +0100Square2(~Square4@user/square)
2023-12-06 11:54:03 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2023-12-06 11:58:47 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 264 seconds)
2023-12-06 11:59:00 +0100kronicma1(user39425@neotame.csclub.uwaterloo.ca) (Quit: WeeChat 3.8)
2023-12-06 12:08:02 +0100tremon(~tremon@83.80.159.219)
2023-12-06 12:08:27 +0100coot_(~coot@89-69-206-216.dynamic.chello.pl)
2023-12-06 12:08:59 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Ping timeout: 264 seconds)
2023-12-06 12:09:23 +0100coot_coot
2023-12-06 12:16:05 +0100xff0x(~xff0x@2405:6580:b080:900:8e8f:f259:634:292d)
2023-12-06 12:32:40 +0100CiaoSen(~Jura@2a05:5800:281:b200:ca4b:d6ff:fec1:99da) (Ping timeout: 246 seconds)
2023-12-06 12:35:15 +0100rvalue(~rvalue@user/rvalue)
2023-12-06 12:35:38 +0100rito(~ritog@45.112.243.47)
2023-12-06 12:39:05 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-12-06 12:42:06 +0100todi1todi
2023-12-06 12:43:05 +0100sawilagar(~sawilagar@user/sawilagar)
2023-12-06 12:50:43 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 268 seconds)
2023-12-06 12:50:52 +0100duncan(~duncan@nat-server.ehlab.uk) (Quit: WeeChat 3.0)
2023-12-06 12:56:29 +0100Guest|79(~Guest|79@78-73-145-35-no2661.tbcn.telia.com)
2023-12-06 12:56:43 +0100 <Guest|79> damn irc, that was many years ago
2023-12-06 13:01:41 +0100CiaoSen(~Jura@2a05:5800:281:b200:ca4b:d6ff:fec1:99da)
2023-12-06 13:03:33 +0100 <jackdk> still here, still going strong
2023-12-06 13:04:30 +0100 <danse-nr3> "strong"
2023-12-06 13:12:07 +0100lg188(~lg188@82.18.98.230) (Ping timeout: 276 seconds)
2023-12-06 13:19:13 +0100duncan(~duncan@user/duncan)
2023-12-06 13:19:16 +0100xff0x(~xff0x@2405:6580:b080:900:8e8f:f259:634:292d) (Ping timeout: 276 seconds)
2023-12-06 13:20:31 +0100xff0x(~xff0x@ai096045.d.east.v6connect.net)
2023-12-06 13:20:38 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2023-12-06 13:22:35 +0100 <Guest|79> haha well theres 625 people online which is kind of insane to me
2023-12-06 13:23:03 +0100 <trev> "online"
2023-12-06 13:23:05 +0100 <Guest|79> at first before it loaded it said 0 people online which didn't chock me
2023-12-06 13:23:30 +0100 <Guest|79> at least 4
2023-12-06 13:32:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 13:32:31 +0100alp_(~alp@2001:861:e3d6:8f80:4f0:3b3:6172:8f1e) (Ping timeout: 246 seconds)
2023-12-06 13:35:24 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 13:35:47 +0100flounders(~flounders@24.246.176.178)
2023-12-06 13:43:12 +0100Guest|79(~Guest|79@78-73-145-35-no2661.tbcn.telia.com) (Quit: Connection closed)
2023-12-06 13:43:40 +0100danse-nr3(~danse@rm-19-55-63.service.infuturo.it) (Ping timeout: 255 seconds)
2023-12-06 13:44:17 +0100hgolden_(~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection)
2023-12-06 13:46:07 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-12-06 13:54:01 +0100cadro(~cadro@2a10:3781:647:1:5a5d:353f:fca3:987d)
2023-12-06 13:54:09 +0100cadro(~cadro@2a10:3781:647:1:5a5d:353f:fca3:987d) (Client Quit)
2023-12-06 13:57:33 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-12-06 13:59:19 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-12-06 13:59:55 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 14:10:59 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-12-06 14:16:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 14:18:04 +0100edr(~edr@user/edr)
2023-12-06 14:21:33 +0100danse-nr3(~danse@rm-19-55-63.service.infuturo.it)
2023-12-06 14:36:32 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-12-06 14:41:07 +0100mikess(~sam@user/mikess) (Ping timeout: 246 seconds)
2023-12-06 14:43:58 +0100alp_(~alp@2001:861:e3d6:8f80:9cca:35b8:68c7:62cd)
2023-12-06 14:43:58 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-12-06 14:44:08 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 14:45:23 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com)
2023-12-06 14:48:49 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 268 seconds)
2023-12-06 14:49:12 +0100dcoutts_(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Read error: Connection reset by peer)
2023-12-06 14:49:28 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 14:49:40 +0100euleritian(~euleritia@dynamic-002-247-248-090.2.247.pool.telefonica.de)
2023-12-06 14:51:49 +0100duncan(~duncan@user/duncan) (Quit: ZNC 1.8.2 - https://znc.in)
2023-12-06 14:54:16 +0100duncan(~duncan@user/duncan)
2023-12-06 14:55:17 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-06 15:02:41 +0100loonycyborg(~loonycybo@wesnoth/developer/loonycyborg) (Ping timeout: 268 seconds)
2023-12-06 15:17:10 +0100xigua(~xigua@user/xigua) (Remote host closed the connection)
2023-12-06 15:17:44 +0100xigua(~xigua@user/xigua)
2023-12-06 15:18:35 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-12-06 15:18:54 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net)
2023-12-06 15:23:43 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-12-06 15:26:29 +0100thegeekinside(~thegeekin@189.141.65.247)
2023-12-06 15:28:56 +0100CiaoSen(~Jura@2a05:5800:281:b200:ca4b:d6ff:fec1:99da) (Ping timeout: 256 seconds)
2023-12-06 15:31:07 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net) (Ping timeout: 255 seconds)
2023-12-06 15:33:23 +0100igemnace(~ian@user/igemnace) (Read error: Connection reset by peer)
2023-12-06 15:34:11 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 264 seconds)
2023-12-06 15:34:26 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com) (Quit: myxos)
2023-12-06 15:34:53 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com)
2023-12-06 15:41:32 +0100 <dminuoso_> Is there a deeper reason why GHC cannot automatically polymorphize let bindings? I just had a compiler error when something along the lines of `f = showT 'a' <> showT 1 where showT = T.pack . show` failed, and just staring at it it seems so obvious that if a monomorphized binding ends up with multiple types, it could just undo monomorphization.
2023-12-06 15:43:17 +0100 <dminuoso_> or well, when I say "automatically polymorphize" I really mean repolymorphize monomorphized bindings (when necessary)
2023-12-06 15:43:19 +0100danse-nr3(~danse@rm-19-55-63.service.infuturo.it) (Read error: Connection reset by peer)
2023-12-06 15:43:41 +0100danse-nr3(~danse@151.47.16.49)
2023-12-06 15:49:37 +0100sabino(~sabino@user/sabino)
2023-12-06 15:49:52 +0100igemnace(~ian@user/igemnace)
2023-12-06 15:50:20 +0100 <kuribas> dminuoso_: because it's not decidable?
2023-12-06 15:50:41 +0100 <dminuoso_> How is it not decidable?
2023-12-06 15:51:41 +0100 <dminuoso_> If you get any unification error on that binding, allow to polymorphize and try again.
2023-12-06 15:52:38 +0100 <dminuoso_> Include a warning that the binding is polymorphized and a quantified type signature should be included, as to nudge the programmer into avoiding that unnecessary round 1.
2023-12-06 15:56:30 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-12-06 15:56:51 +0100 <ncf> yes let's add more rules and exceptions, the monomorphism restriction isn't surprising enough as it is ;)
2023-12-06 15:57:12 +0100 <dminuoso_> This would, at best, make it less surprising.
2023-12-06 15:57:48 +0100 <dminuoso_> Type unification errors when MMR kicks in are strange and non-obvious. A dedicated warning can directly tell you what's happening.
2023-12-06 15:58:47 +0100raym(~ray@user/raym) (Ping timeout: 264 seconds)
2023-12-06 16:00:21 +0100 <danse-nr3> once a feature gets in, its impact slowly propagates to the code around it. It is unavoidable i guess, to make it work better with the rest
2023-12-06 16:00:41 +0100loonycyborg(loonycybor@wesnoth/developer/loonycyborg)
2023-12-06 16:01:37 +0100 <dminuoso_> `Cannot match Char with Int` vs "Ignoring monomorphism restriction on x (foo.hs:103) would allow compilation to succeed. The inferred type of x is: ..."
2023-12-06 16:01:44 +0100 <dminuoso_> Ultimately this could still be an error.
2023-12-06 16:04:04 +0100 <dminuoso_> But perhaps that would require a bit more sophisticated type error slicing to know which binding to even try to repolymorphize, and perhaps this would dramatically increase type checking time *when* errors occurs since there might be any number of bindings GHC could try to repolymorphize...
2023-12-06 16:04:07 +0100 <dminuoso_> Mmm
2023-12-06 16:04:54 +0100raym(~ray@user/raym)
2023-12-06 16:06:43 +0100darchitect(~darchitec@2a00:23c6:3584:df01:49b7:b837:bf00:38a1) (Quit: WeeChat 4.1.1)
2023-12-06 16:10:33 +0100ricardo1(~ricardo@84.16.179.218) ()
2023-12-06 16:11:27 +0100Hooloovoo(~Hooloovoo@hax0rbana.org) (Ping timeout: 268 seconds)
2023-12-06 16:12:42 +0100zetef(~quassel@95.77.17.251)
2023-12-06 16:12:58 +0100Hooloovoo(~Hooloovoo@hax0rbana.org)
2023-12-06 16:21:09 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-12-06 16:21:43 +0100sefidel(~sefidel@user/sefidel)
2023-12-06 16:24:15 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 16:24:24 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 4.0.5)
2023-12-06 16:24:36 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-12-06 16:32:02 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 16:32:17 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 16:32:30 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 16:40:17 +0100rito(~ritog@45.112.243.47) (Ping timeout: 256 seconds)
2023-12-06 16:40:32 +0100 <glguy> dminuoso_: the monomorphism restriction is a feature, not a limitation. It means things that look like simple values can perform like them. Complex rules for re polymorphism would make it much harder to be confident that you didn't accidentally create a performance mistake and would end up creating extra work where we would need to put even more type signatures on let bindings to avoid this new
2023-12-06 16:40:33 +0100 <glguy> pitfall
2023-12-06 16:40:45 +0100 <kuribas> dminuoso_: If I recall correctly, having polymorphic let with various extensions (GADTs, etc) is undecidable, or just very hard to implement.
2023-12-06 16:41:49 +0100 <glguy> You can already with with the restriction disabled via an extension pragma
2023-12-06 16:42:40 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-12-06 16:42:54 +0100Square2(~Square4@user/square) (Ping timeout: 268 seconds)
2023-12-06 16:46:05 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-12-06 16:47:27 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Remote host closed the connection)
2023-12-06 16:52:53 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 16:53:09 +0100zincy(~tom@2a00:23c8:9705:9501:4425:940f:c2d:62c4)
2023-12-06 16:54:58 +0100 <exarkun> Did Network.Socket.close use to be named Network.Socket.sClose?
2023-12-06 16:56:54 +0100Square(~Square@user/square)
2023-12-06 16:58:47 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 264 seconds)
2023-12-06 17:02:14 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 17:02:46 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-12-06 17:03:05 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 256 seconds)
2023-12-06 17:03:12 +0100 <bwe> dminuoso_: rolling my MaybeeState to grasp monad transformers: https://gist.github.com/benjaminweb/ea91583983f5eceb10549ed25db03ec4/revisions
2023-12-06 17:03:22 +0100mmhat(~mmh@p200300f1c726935cee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 4.1.2)
2023-12-06 17:04:19 +0100 <bwe> dminuoso_: I am stuck at line 350: Found hole: _ :: Maybe a -> MaybeeState s1 a1
2023-12-06 17:04:56 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 17:05:24 +0100euleritian(~euleritia@dynamic-002-247-248-090.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-12-06 17:05:43 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 17:10:12 +0100 <bwe> f :: (a -> MaybeeState s b) -- so the only thing is how to get around the Maybe; fmap or case don't work
2023-12-06 17:12:23 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2023-12-06 17:13:07 +0100gehmehgeh(~user@user/gehmehgeh)
2023-12-06 17:16:03 +0100 <ncf> bwe: you should probably case split on maybee_a and wonder what should happen in each branch
2023-12-06 17:17:15 +0100skiglances around
2023-12-06 17:19:50 +0100 <bwe> ncf: got it; I've compared Monad instances for Maybee and State to realise what I need to do.
2023-12-06 17:20:16 +0100 <bwe> https://gist.github.com/benjaminweb/ea91583983f5eceb10549ed25db03ec4#file-monadt-hs-L345-L352
2023-12-06 17:21:29 +0100ricardo1(~ricardo@84.16.179.218)
2023-12-06 17:22:19 +0100 <ncf> yup :) now check the monad laws
2023-12-06 17:23:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 17:23:36 +0100skiwas just about to say that
2023-12-06 17:24:19 +0100bweis afk, will do later.
2023-12-06 17:26:05 +0100danse-nr3(~danse@151.47.16.49) (Ping timeout: 240 seconds)
2023-12-06 17:28:35 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2023-12-06 17:29:17 +0100gehmehgeh(~user@user/gehmehgeh)
2023-12-06 17:36:15 +0100picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur) (Quit: WeeChat 4.1.1)
2023-12-06 17:36:54 +0100danse-nr3(~danse@151.47.16.49)
2023-12-06 17:37:58 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1)
2023-12-06 17:38:43 +0100picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur)
2023-12-06 17:46:07 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 17:46:49 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-12-06 17:51:14 +0100infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-12-06 17:52:04 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Quit: WeeChat 4.1.1)
2023-12-06 17:53:21 +0100infinity0(~infinity0@pwned.gg)
2023-12-06 17:55:52 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-12-06 18:01:22 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-12-06 18:02:12 +0100mikess(~sam@user/mikess)
2023-12-06 18:02:46 +0100chele(~chele@user/chele) (Quit: Leaving)
2023-12-06 18:02:51 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 18:11:01 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 18:13:11 +0100 <bwe> how do I check them? I'd start with them: https://wiki.haskell.org/Monad_laws
2023-12-06 18:16:41 +0100 <idgaen> by hand, I guess
2023-12-06 18:17:02 +0100 <Rembane> Or using Agda if you like dependently typed programming
2023-12-06 18:17:59 +0100 <danse-nr3> i also saw some rule checking automation. Maybe recently added to quickcheck but not sure, maybe was elsewhere
2023-12-06 18:19:30 +0100 <duncan> It is not as simple as putting the forumlae into haskell code
2023-12-06 18:19:38 +0100 <duncan> but you can do it easier with `join`
2023-12-06 18:19:44 +0100 <duncan> (at least associativity)
2023-12-06 18:20:19 +0100 <duncan> Most of the academic courses I saw which checked them provided students with a simple module which took care of it
2023-12-06 18:20:33 +0100 <ncf> it might also be easier if you straight up define a MaybeT transformer instead of the special case of MaybeT State
2023-12-06 18:20:59 +0100 <duncan> https://blog.ploeh.dk/2022/04/11/monad-laws/
2023-12-06 18:21:20 +0100 <geekosaur> there's a QuickCheck-classes package which has helpers for testing typeclass instances, and QuickCheck-classes-base which uses it to test typeclasses in base (and presumably can be used as examples to test your own)
2023-12-06 18:22:09 +0100 <ncf> nice haiku on that wiki page
2023-12-06 18:22:16 +0100 <ski> bwe : "how do I check them?" -- start from both sides, simplify, see if you get the same thing
2023-12-06 18:22:54 +0100ski's kinda disappointed that wiki page doesn't mention the form of the laws, in terms `join'
2023-12-06 18:22:57 +0100 <duncan> One of the issues I had when I was implementing this stuff in R (don't ask) was lack of good examples even in Haskell
2023-12-06 18:23:32 +0100 <duncan> the blog posts just sort of assume, you can translate the categorical machinery into code
2023-12-06 18:23:52 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-12-06 18:23:55 +0100 <ski> ncf : well, `MaybeeState s' isn't exactly `MaybeT (State s)' (for two reasons)
2023-12-06 18:24:57 +0100 <ski> duncan : hm, would also be interesting to see the laws expressed in terms of LINQ
2023-12-06 18:25:19 +0100 <ncf> ski: up to a trivial isomorphism
2023-12-06 18:25:25 +0100 <duncan> LINQ ~ .net/F#?
2023-12-06 18:26:00 +0100 <duncan> Well, Seemann does all the catamorphism examples in F#/Haskell
2023-12-06 18:27:11 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 18:28:57 +0100 <ski> duncan : yes
2023-12-06 18:29:30 +0100 <ski> ncf : oh, you're right, i'm confusing the order
2023-12-06 18:30:01 +0100rito(~ritog@45.112.243.47)
2023-12-06 18:31:04 +0100 <ski> (still, `MaybeeState s' is failing a law)
2023-12-06 18:39:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 18:46:57 +0100 <ncf> ski: is it?
2023-12-06 18:46:57 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-12-06 18:48:04 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 18:51:17 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1) (Ping timeout: 240 seconds)
2023-12-06 18:51:54 +0100 <ski> yes
2023-12-06 18:52:21 +0100 <ski> (not one of the three main monad laws, though)
2023-12-06 18:54:09 +0100 <ncf> oh yeah <*> has effects backwards
2023-12-06 18:54:39 +0100 <ski> quite
2023-12-06 18:57:42 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 18:58:50 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 19:00:24 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 252 seconds)
2023-12-06 19:00:29 +0100 <bwe> ski: so it's not failing left identity, right identity, nor associativity - is that what you mean?
2023-12-06 19:02:14 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-12-06 19:07:07 +0100 <ski> bwe : well, i didn't check those in detail
2023-12-06 19:07:12 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-12-06 19:07:13 +0100 <ski> (have you tried to check them ?)
2023-12-06 19:07:36 +0100 <bwe> no, I don't know where to start with
2023-12-06 19:07:49 +0100 <bwe> MkMaybeeState g >>= f = MkMaybeeState $ \s0 ->
2023-12-06 19:09:56 +0100mc47(~mc47@xmonad/TheMC47)
2023-12-06 19:10:30 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2023-12-06 19:11:05 +0100 <ski> hm
2023-12-06 19:11:12 +0100euleritian(~euleritia@dynamic-002-247-248-090.2.247.pool.telefonica.de)
2023-12-06 19:12:40 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 19:12:43 +0100alp_(~alp@2001:861:e3d6:8f80:9cca:35b8:68c7:62cd) (Ping timeout: 256 seconds)
2023-12-06 19:12:48 +0100 <ski> bwe : let's say you wanted to check the left neutral element law :
2023-12-06 19:13:01 +0100 <ski> return a >>= amb = amb a
2023-12-06 19:13:28 +0100 <ski> so, you'd start at one end
2023-12-06 19:13:37 +0100 <ski> return a >>= amb
2023-12-06 19:13:50 +0100 <ski> and then unfold/inline your definition `return'
2023-12-06 19:14:08 +0100 <ski> = MkMaybeeState (\z -> (Just a,z)) >>= amb
2023-12-06 19:14:14 +0100 <bwe> MkMaybeeState (\z s> (Just x, z)) >>= amb
2023-12-06 19:14:20 +0100 <bwe> oh :)
2023-12-06 19:14:23 +0100 <ski> yes
2023-12-06 19:14:36 +0100 <ski> and then you'd use your definition of `(>>=)'
2023-12-06 19:15:48 +0100 <ski> = MkMaybeeState $ \s0 -> case (\z -> (Just a,z)) s0 of (Just a,s1) -> let MkMaybeeState f' = amb a in f' s1; (Nothing,s1) -> (Nothing,s1)
2023-12-06 19:16:10 +0100 <ski> and then you can start simplifyig. i suggest starting with the `(\z -> (Just a,z)) s0' part
2023-12-06 19:17:03 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 19:17:51 +0100 <ski> (btw, if you turned on `{-# LANGUAGE BlockArguments #-}', at the top of the file, you could avoid those `$'s)
2023-12-06 19:17:55 +0100 <bwe> my definition excludes the variant Nothing
2023-12-06 19:18:28 +0100 <bwe> but let me work it through first
2023-12-06 19:18:32 +0100 <ski> well, can you do a simplification of the above expression, step by step, repeating each complete expression after each simplification step ?
2023-12-06 19:18:55 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Ping timeout: 255 seconds)
2023-12-06 19:19:17 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-06 19:21:17 +0100 <bwe> (\z -> (Just a,z)) s0 is equivalent to return x
2023-12-06 19:21:33 +0100 <bwe> so I am replacing that
2023-12-06 19:24:40 +0100rito(~ritog@45.112.243.47) (Ping timeout: 255 seconds)
2023-12-06 19:27:33 +0100danse-nr3(~danse@151.47.16.49) (Ping timeout: 268 seconds)
2023-12-06 19:29:23 +0100 <ski> bwe : equivalent to `return a', but yes
2023-12-06 19:29:54 +0100 <ski> (i used `a' and `amb', not `x' and `f', in the original formulation of the law)
2023-12-06 19:30:01 +0100 <bwe> right
2023-12-06 19:30:13 +0100 <ski> (as mnemonics : `a :: a' and `amb :: a -> m b')
2023-12-06 19:30:31 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 255 seconds)
2023-12-06 19:33:01 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 276 seconds)
2023-12-06 19:39:33 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1)
2023-12-06 19:41:09 +0100igemnace(~ian@user/igemnace) (Remote host closed the connection)
2023-12-06 19:41:16 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-12-06 19:41:48 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 19:42:11 +0100danza(~francesco@rm-19-62-121.service.infuturo.it)
2023-12-06 19:46:49 +0100petrolblue(~anon@2a02:908:1065:4340::1c45)
2023-12-06 19:48:10 +0100rito(~ritog@45.112.243.47)
2023-12-06 19:48:48 +0100danza(~francesco@rm-19-62-121.service.infuturo.it) (Ping timeout: 252 seconds)
2023-12-06 19:52:26 +0100benjaminl(~benjaminl@user/benjaminl) (Ping timeout: 256 seconds)
2023-12-06 19:53:15 +0100machinedgod(~machinedg@93-136-134-38.adsl.net.t-com.hr)
2023-12-06 19:55:26 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Remote host closed the connection)
2023-12-06 20:01:25 +0100euleritian(~euleritia@dynamic-002-247-248-090.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-12-06 20:01:43 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-06 20:05:32 +0100YuutaW(~YuutaW@mail.yuuta.moe)
2023-12-06 20:09:20 +0100 <dminuoso_> reallyUnsafeStateCoerce = unsafeCoerce#
2023-12-06 20:09:30 +0100 <dminuoso_> Today is the day I get to use this thing in production code. :)
2023-12-06 20:09:56 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-12-06 20:11:04 +0100 <EvanR> for a minute I thought we were talking about amb i.e. the opposite of unamb
2023-12-06 20:11:24 +0100 <EvanR> doesn't seem to come up much in haskell for some reason
2023-12-06 20:11:55 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 260 seconds)
2023-12-06 20:12:40 +0100pretty_dumm_guy(~trottel@2a02:810b:43bf:aba0:dc82:dff8:b6b:479)
2023-12-06 20:12:43 +0100 <int-e> dminuoso_: what could possibly go wrong?
2023-12-06 20:12:59 +0100gawen(~gawen@user/gawen) (Quit: cya)
2023-12-06 20:14:46 +0100 <dminuoso_> int-e: Pretty much nothing. I just freely coerce between ZeroBitType state tokens.
2023-12-06 20:15:13 +0100 <bwe> ski: do I work on both sides of = ?
2023-12-06 20:15:21 +0100 <dminuoso_> Roughly I have this thing parametric over arbitrary ZeroBitType state tokens (a kind of no-effect/ST/IO polymorphism), and I want to run IO inside (irrespective of whats outside)
2023-12-06 20:15:33 +0100 <int-e> dminuoso_: ah, boring!
2023-12-06 20:15:35 +0100 <int-e> ;)
2023-12-06 20:16:05 +0100cimento(CO2@gateway/vpn/protonvpn/cimento) (Quit: WeeChat 4.1.2)
2023-12-06 20:16:25 +0100 <int-e> (Well, so far. *If* this results in a bug that could become a fascinating anecdote. :) )
2023-12-06 20:16:44 +0100cimento(CO2@gateway/vpn/protonvpn/cimento)
2023-12-06 20:17:45 +0100 <ski> bwe : start from one side, see how far you get. if needed, also start from the other side
2023-12-06 20:18:20 +0100 <bwe> ski: what's my aim? to make both sides stating the same?
2023-12-06 20:18:25 +0100 <ski> yes
2023-12-06 20:18:54 +0100 <bwe> now I have case (return a) s0 of on the right side
2023-12-06 20:24:13 +0100 <ski> unfold/inline `return' ?
2023-12-06 20:24:32 +0100gawen(~gawen@user/gawen)
2023-12-06 20:24:52 +0100 <ski> (also, are you sure you didn't miss some data constructor or field selector ?)
2023-12-06 20:25:52 +0100 <ski> @hoogle Word0
2023-12-06 20:25:52 +0100 <lambdabot> System.Console.Repline Word0 :: WordCompleter m -> CompleterStyle m
2023-12-06 20:25:54 +0100glguy(g@libera/staff/glguy) (Quit: Quit)
2023-12-06 20:26:03 +0100 <ski> @hoogle Int0
2023-12-06 20:26:03 +0100 <lambdabot> GHC.Fingerprint fingerprint0 :: Fingerprint
2023-12-06 20:26:04 +0100 <lambdabot> Fingerprint fingerprint0 :: Fingerprint
2023-12-06 20:26:04 +0100 <lambdabot> Text.Ginger.GVal toInt0 :: GVal m -> Int
2023-12-06 20:27:15 +0100glguy(g@libera/staff/glguy)
2023-12-06 20:27:34 +0100 <bwe> ski: https://gist.github.com/benjaminweb/bcaccecbdde765e05360a452c3d5a074
2023-12-06 20:28:46 +0100 <ski> bwe : you should add the starting points (that i gave), to that sequence of rewritings, as well
2023-12-06 20:29:35 +0100 <EvanR> when you're playing with zero-size types whose only purpose is to affect the type system, and then you unsafeCoerce, what's the point xD
2023-12-06 20:29:40 +0100gawen(~gawen@user/gawen) (Quit: cya)
2023-12-06 20:29:56 +0100glguy(g@libera/staff/glguy) (Client Quit)
2023-12-06 20:29:58 +0100 <EvanR> I guess you can have a small "kernel of trust" module which is proved correct once
2023-12-06 20:30:01 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-12-06 20:30:10 +0100glguy(g@libera/staff/glguy)
2023-12-06 20:30:19 +0100 <ski> also, don't repeat the definition of `(>>=)' (specialized as per your particular call), especially not multiple times .. there's no reason to, here
2023-12-06 20:31:10 +0100 <ski> also, make up your mind. use `return a' or `return x', but not both
2023-12-06 20:31:19 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 240 seconds)
2023-12-06 20:31:51 +0100 <ski> (you say `MkMaybeeState (\z -> (Just x, z)) >>= amb = ...', with `x' there rather than `a', which suggests you started with `return x' (not `return a'), although you didn't show what you started with)
2023-12-06 20:33:23 +0100 <ski> bwe : oh, i see what you're (trying to) do. you went from `(\z -> (Just (a, z))) s0' to `(return a) s0' .. that's the wrong direction ! that's getting further away from computed results, not closer to them !
2023-12-06 20:33:35 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-12-06 20:33:39 +0100bwesighs
2023-12-06 20:34:06 +0100 <[exa]> good evening all, how's your lambdas
2023-12-06 20:34:16 +0100 <ski> also, replacing `amb a' with `MkMaybeeState (\z -> (Just x, z))' is incorrect (since that's `return x', which you can't assume `amb a' to be equal to. `amb' is arbitrary)
2023-12-06 20:35:24 +0100 <bwe> ski: I am taking a break until tomorrow, can't think clearly
2023-12-06 20:35:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 20:35:40 +0100 <ski> as a warm-up for proving laws, i mean
2023-12-06 20:35:54 +0100 <bwe> let me do that tomorrow
2023-12-06 20:36:17 +0100 <bwe> proving means I am simplifying one side step by step so it becomes the other side
2023-12-06 20:36:23 +0100 <ski> (since your `(>>=)' is relatively complicated, so it's easy to get lost in it, or confused about what one's trying to do)
2023-12-06 20:36:41 +0100 <ski> or simplifying both sides, until you've massaged them to look the same
2023-12-06 20:36:44 +0100 <bwe> ski: but anyways, I feel my return is flawed
2023-12-06 20:37:04 +0100 <ski> (there may also be some more creative steps than simplifying. but simpifying is a large part of it)
2023-12-06 20:37:27 +0100 <ski> why do you think so ?
2023-12-06 20:38:32 +0100gawen(~gawen@user/gawen)
2023-12-06 20:39:17 +0100 <[exa]> bwe: are you aiming for the (StateT s Maybe) or (MaybeT (State s)) semantics? (sorry might have missed that in the scrollback)
2023-12-06 20:39:52 +0100 <ski> [exa] : it's un[4~clear (they haven't started thinking about this yet, i think)
2023-12-06 20:40:26 +0100 <monochrom> Is this MaybeT State? You can prove that State satisfies laws, and prove MaybeT M satisfies laws if you know M satisfies laws. This will be much cleaner than confronting MaybeT State as a monolith.
2023-12-06 20:40:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4) (Ping timeout: 276 seconds)
2023-12-06 20:41:19 +0100 <monochrom> As it happens, this goes deeps into why people think verifying 1M LOC is impossible and why they are wrong.
2023-12-06 20:41:50 +0100[exa]. o O ( 1M LOC in Matlab )
2023-12-06 20:42:21 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-12-06 20:42:21 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-12-06 20:42:21 +0100finn_elijaFinnElija
2023-12-06 20:42:54 +0100 <[exa]> ski: oic, thx
2023-12-06 20:44:35 +0100trev(~trev@user/trev) (Quit: trev)
2023-12-06 20:46:30 +0100ericcodes(~ericcodes@pool-72-83-186-186.washdc.fios.verizon.net)
2023-12-06 20:48:12 +0100petrolblue(~anon@2a02:908:1065:4340::1c45) (Quit: petrolblue)
2023-12-06 20:49:26 +0100 <EvanR> metadiscussion: list, [], and ++ is said to form a monoid, and sometimes the especially fast and loose will said it *is a* monoid. And from the perspective of hardline dependent type environments, I would say you could package them up to be used as a monoid (which is some type serving as a uniform interface). How many other ways can we skin a cat and is there any difference...
2023-12-06 20:49:29 +0100benjaminl(~benjaminl@user/benjaminl)
2023-12-06 20:50:14 +0100 <EvanR> *is a* served the purposes fine back in abstract algebra 101
2023-12-06 20:51:05 +0100 <monochrom> Two theorem provers, Isabel and Lean, have adopted the type class approach for this.
2023-12-06 20:51:58 +0100ericcodesGuest3304
2023-12-06 20:51:58 +0100Guest3304(~ericcodes@pool-72-83-186-186.washdc.fios.verizon.net) (Killed (tantalum.libera.chat (Nickname regained by services)))
2023-12-06 20:52:20 +0100ericcodes(~user@pool-72-83-186-186.washdc.fios.verizon.net)
2023-12-06 20:53:45 +0100 <monochrom> But while we are at it, *ML (pun on "meta"!) use modules and module interfaces.
2023-12-06 20:54:28 +0100 <bwe> [exa]: I am trying to let scalpel's Scraper return errors instead of just a Maybe. For this, I am trying to grasp monad transformers. For this I rolled my own Maybe, State. ski helped me a ton with that. Now I am rolling a thing that does Maybe and State at once. Next up should be Reader and Maybe. Then IO + Maybe. To see the pattern to emerge.
2023-12-06 20:54:38 +0100 <ski> length : (++) >---> (+) -- while we're at it
2023-12-06 20:54:41 +0100bramhaag74(~bramhaag@endeavour.server.bramh.me)
2023-12-06 20:55:02 +0100 <monochrom> haha nice
2023-12-06 20:55:09 +0100bramhaag7(~bramhaag@endeavour.server.bramh.me) (Read error: Connection reset by peer)
2023-12-06 20:55:09 +0100bramhaag74bramhaag7
2023-12-06 20:55:27 +0100 <EvanR> *and* and *+* work talking about monads might be misleading because those are commutative, but there's at least two ways to combine all those pairs of monads depending on what you want to happen
2023-12-06 20:55:35 +0100 <EvanR> s/work/when/
2023-12-06 20:55:36 +0100 <ski> (cue universal algebra, and categories for those)
2023-12-06 20:55:39 +0100 <bwe> do you know any visual explanation with boxes of monad transformers (or in my case doing the State and Maybe thing)? I feel that this would help me significantly.
2023-12-06 20:56:16 +0100 <EvanR> or a gastronomic explanation with burritos
2023-12-06 20:56:25 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-06 20:56:47 +0100 <[exa]> bwe: ah so, good. Honestly I'd recommend starting with IO+Maybe, because 1] Maybe is easiest and 2] you can't take IO apart which will prevent you from reimplementing it like State
2023-12-06 20:56:54 +0100 <monochrom> I don't think boxes are the right visuals for Maybe or MaybeT.
2023-12-06 20:57:00 +0100ericcodes(~user@pool-72-83-186-186.washdc.fios.verizon.net) (Ping timeout: 252 seconds)
2023-12-06 20:57:57 +0100 <ncf> [exa]: what's wrong with "is a" monoid?
2023-12-06 20:58:01 +0100 <ncf> sorry, EvanR *
2023-12-06 20:58:13 +0100 <ncf> as long as you're not saying "[a] is a monoid"
2023-12-06 20:58:22 +0100 <monochrom> I think box/block diagrams can only help read the code for State's >>=. For example, it won't help seeing why it satisfies laws.
2023-12-06 20:59:25 +0100 <bwe> monochrom: no, not for satisfying the laws; I was more after the pattern that leads me to the transformer like MaybeT.
2023-12-06 20:59:34 +0100 <monochrom> The right visual for Maybe may be decision trees.
2023-12-06 21:07:28 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-12-06 21:10:17 +0100 <EvanR> *can be packaged as a*, industrial semantics. *forms a* natural semantics. *is a* platonic semantics? xD
2023-12-06 21:11:49 +0100 <[exa]> "is" is dangerous, it's like saying "we all know which kind of equivalence I meant here right"
2023-12-06 21:12:12 +0100abrar_(~abrar@pool-72-78-199-167.phlapa.fios.verizon.net) (Quit: WeeChat 3.8)
2023-12-06 21:12:34 +0100 <monochrom> industrial? business? :)
2023-12-06 21:12:46 +0100 <monochrom> public relations? >:)
2023-12-06 21:13:02 +0100 <dminuoso_> [exa]: This is getting into silly language lawyering territory, as this kind of "is" is (!) at the meta language of us describing mathematical facts.
2023-12-06 21:13:10 +0100 <monochrom> equivalence? isomorphism?
2023-12-06 21:13:27 +0100abrar(~abrar@pool-72-78-199-167.phlapa.fios.verizon.net)
2023-12-06 21:13:51 +0100 <monochrom> Three most common words Haskellers use without actual understanding: isomorphism, thunk, strict.
2023-12-06 21:13:52 +0100 <[exa]> dminuoso_: yeah, I hate it since I saw actual ontology authors using `is` as a fully qualified term :D
2023-12-06 21:13:53 +0100 <dminuoso_> When I say "In category theory, a monoid is...", you get into just an endless circle of pointless journeys that roundtrip through homotopy type theory if you try and debate about "is" in that sentence.
2023-12-06 21:14:28 +0100 <[exa]> "we call ...blabla... a 'monoid' "
2023-12-06 21:14:40 +0100 <dminuoso_> I dont think Ive ever heard someone debate over "Set X equipped with a binary operation and ... is a monoid".
2023-12-06 21:15:02 +0100 <monochrom> call by name? >:)
2023-12-06 21:15:05 +0100 <dminuoso_> Whether you use "is", "is called", "forms" - this is all discussions about the natural language itself.
2023-12-06 21:15:09 +0100 <ncf> i mean, the "is a" in "([a], [], (++)) is a monoid" is clearly meant to be read as "has type"
2023-12-06 21:15:20 +0100 <monochrom> EvanR: What is natural semantics?
2023-12-06 21:16:03 +0100 <EvanR> I'm thinking it forms a monoid like molecular clouds form solar systems and caves form stalactites xD
2023-12-06 21:16:12 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 21:16:16 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 255 seconds)
2023-12-06 21:16:45 +0100 <monochrom> You know of the Niklaus Wirth (the Pascal guy, e.g) joke about call by name and call by value?
2023-12-06 21:17:08 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 21:17:40 +0100 <EvanR> nope
2023-12-06 21:17:57 +0100petrolblue(~petrolblu@ip-095-222-169-156.um34.pools.vodafone-ip.de)
2023-12-06 21:18:12 +0100 <monochrom> So he was giving a talk in the US. He began with "in Europe they call me <correct Swiss pronounciation of his name>, in the US you call me Nickel's Worth. So Europeans call by name and Americans call by value."
2023-12-06 21:18:29 +0100 <EvanR> lol
2023-12-06 21:19:11 +0100lottaquestions(~nick@2607:fa49:503d:b200:2d55:64ae:c120:e947) (Quit: Konversation terminated!)
2023-12-06 21:20:10 +0100petrolblue(~petrolblu@ip-095-222-169-156.um34.pools.vodafone-ip.de) (Client Quit)
2023-12-06 21:20:24 +0100 <monochrom> There is also "has the monoid trait" e.g. Scala.
2023-12-06 21:21:14 +0100 <monochrom> I think I like the trait idea or equivalent. For example the real numbers has many traits: field, metric space, vector space, ...
2023-12-06 21:21:26 +0100 <EvanR> ok that one might have a more obvious practical difference, i.e. you can probably do more with monoids in scala than in math
2023-12-06 21:21:58 +0100 <EvanR> like, test to see if it has that trait xD
2023-12-06 21:22:04 +0100 <monochrom> Wait that can't be true. Math can prove monoid theorems, Scala can't.
2023-12-06 21:22:49 +0100 <monochrom> Well no, you can only test to see if someone has declared that it has that trait.
2023-12-06 21:23:20 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-12-06 21:23:25 +0100 <monochrom> which is no better than math, in which you check to see if someone has proved stuff.
2023-12-06 21:24:05 +0100 <EvanR> in the sense that you check to see if a turing machine halts
2023-12-06 21:24:06 +0100 <dminuoso_> EvanR: In fact, "Is a monoid" is a perfectly reasonable description, since there's plenty of mathematical constructions where you consider that tuple as objects or some kind.
2023-12-06 21:24:30 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 252 seconds)
2023-12-06 21:24:41 +0100 <monochrom> No, Scala does not enable the computer to discover that lists are monoids.
2023-12-06 21:24:55 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-06 21:24:57 +0100 <EvanR> but it's much more reliable at determining if someone defined the trait
2023-12-06 21:25:00 +0100 <monochrom> Scala at best enables someone to declare it.
2023-12-06 21:25:36 +0100 <monochrom> For lists yes it's in the stdlib and comes out of the box. But in general, for an arbitrary type?
2023-12-06 21:26:33 +0100 <monochrom> Someone has defined a new data structure and uploaded it to the Scala community library repo. But they have not declared that it is a monoid.
2023-12-06 21:26:46 +0100 <EvanR> checking if someone somewhere ever proved a particular machine halts or not might stall xD
2023-12-06 21:27:10 +0100 <EvanR> but that would be a cool programming language feature
2023-12-06 21:27:21 +0100 <monochrom> Now you wonder whether someone else has figured it out and uploaded an update or a companion library package that makes it a monoid.
2023-12-06 21:27:33 +0100 <monochrom> So now you have to search the community library package repo.
2023-12-06 21:28:01 +0100 <monochrom> This is no better than a mathematician searching the literature for a known theorem and proof.
2023-12-06 21:28:11 +0100 <EvanR> anyway, I wasn't trying to get into the nitty gritty of programming monoids
2023-12-06 21:28:35 +0100 <EvanR> just the rhetoric of calling them out in public
2023-12-06 21:28:42 +0100 <dminuoso_> Haskell design question. I have whats called a Codec, which is a data structure containing serialization/deserialization information for various things for communication with clients. All of this makes heavy use of Dynamic for a bunch of reasons, so you do something like `encode codec "User-Name" (mkText "text")` where "User-Name" is looked up in the structure and encoded according to what it
2023-12-06 21:28:44 +0100 <dminuoso_> finds.
2023-12-06 21:29:20 +0100 <dminuoso_> Now, a select few things require an additional secret for crypto stuff, but each client I communicate with has a different secret.
2023-12-06 21:30:15 +0100 <dminuoso_> With an interface like `encode :: Codec -> AttributeName -> Dynamic -> IO ByteString`, how would I sensibly inject a secret that would probably not be needed, but maybe yes.
2023-12-06 21:30:20 +0100 <dminuoso_> Pass it all the time? That feels wrong, somehow.
2023-12-06 21:30:50 +0100 <EvanR> when you build the codec the cryptokeys can be closed over and hidden within it
2023-12-06 21:31:46 +0100 <EvanR> dunno if it would be good design
2023-12-06 21:31:48 +0100 <dminuoso_> EvanR: Well I suppose I could have a sort of PreCodec (sans secret), and upon a connection with a client lookup its secret, and build a `Codec {secret = "foo", ..}`
2023-12-06 21:31:56 +0100 <dminuoso_> Mmm
2023-12-06 21:32:44 +0100 <EvanR> you wouldn't need a separate type or a field, if any "methods" use the cryptokey, they would access it from the closure. But if you don't have the key at codec construction time, that's out
2023-12-06 21:33:31 +0100 <EvanR> unless you get it from the IVar in the closure... which might be jumping the shark into overengineering slightly
2023-12-06 21:33:40 +0100 <dminuoso_> What is an IVar?
2023-12-06 21:33:51 +0100 <EvanR> a write-once variable you can read in pure code
2023-12-06 21:34:09 +0100 <EvanR> some thread can set its value at a later date
2023-12-06 21:34:36 +0100 <EvanR> dependency injection!
2023-12-06 21:35:12 +0100 <EvanR> ... just pass the key in to the function that needs it xD
2023-12-06 21:35:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:9ce:2c57:5542:dde4)
2023-12-06 21:39:36 +0100petrolblue(~petrolblu@2a02:908:1065:4340::1c45)
2023-12-06 21:41:27 +0100dwt_(~dwt_@2601:2c6:8381:e5c:606f:34a3:7300:6f05)
2023-12-06 21:44:27 +0100dwt__(~dwt_@2601:2c6:8381:e5c:e4bc:2ef0:3dfa:99ac) (Ping timeout: 268 seconds)
2023-12-06 21:44:47 +0100ubert(~Thunderbi@178.165.165.175.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2023-12-06 21:46:52 +0100ubert(~Thunderbi@178.165.165.175.wireless.dyn.drei.com)
2023-12-06 21:49:14 +0100petrolblue(~petrolblu@2a02:908:1065:4340::1c45) (Quit: petrolblue)
2023-12-06 21:51:30 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 21:52:10 +0100ritoritog
2023-12-06 21:52:53 +0100ritog(~ritog@45.112.243.47) (Quit: Leaving)
2023-12-06 22:00:01 +0100 <ncf> bwe: one way to convince yourself that MaybeT m a = m (Maybe a) is the right definition is that, for any monad m, there is a *distributive law* l :: Maybe (m a) -> m (Maybe a) , but no distributive law in the other direction in general
2023-12-06 22:00:32 +0100 <ncf> so, exercise 1 (easy): define l
2023-12-06 22:00:44 +0100John_IvanLim_Fao
2023-12-06 22:01:56 +0100 <ncf> exercise 2 (harder): determine exactly what conditions such a distributive law l :: n (m a) -> m (n a) should satisfy in order to be able to make m ∘ n a monad
2023-12-06 22:04:06 +0100 <ncf> exercise 3: find similar distributive laws for Writer and Reader (hint: they may not all go in the same direction, i.e. you might have to use m ∘ n instead of n ∘ m) and derive WriterT and ReaderT from them
2023-12-06 22:04:26 +0100Lim_FaoDer_Dumm_Nemetzk
2023-12-06 22:04:35 +0100Der_Dumm_NemetzkDerDummNemetzkii
2023-12-06 22:06:52 +0100 <ncf> exercise 1.1: prove, or at least convince yourself, that there is no general distributive law m (Maybe a) -> Maybe (m a)
2023-12-06 22:10:17 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-12-06 22:10:31 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Remote host closed the connection)
2023-12-06 22:10:55 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-12-06 22:11:34 +0100ubert(~Thunderbi@178.165.165.175.wireless.dyn.drei.com) (Quit: ubert)
2023-12-06 22:12:37 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-12-06 22:13:00 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Max SendQ exceeded)
2023-12-06 22:14:03 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-12-06 22:15:43 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Max SendQ exceeded)
2023-12-06 22:16:46 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-12-06 22:18:22 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Max SendQ exceeded)
2023-12-06 22:19:24 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-12-06 22:22:51 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 245 seconds)
2023-12-06 22:27:22 +0100doyougnu(~doyougnu@45.46.170.68) (Ping timeout: 255 seconds)
2023-12-06 22:27:46 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-12-06 22:31:11 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 245 seconds)
2023-12-06 22:31:50 +0100doyougnu(~doyougnu@045-046-170-068.res.spectrum.com)
2023-12-06 23:02:39 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-12-06 23:02:39 +0100Feuermagier(~Feuermagi@user/feuermagier) (Killed (zirconium.libera.chat (Nickname regained by services)))
2023-12-06 23:02:39 +0100Feuermagier_Feuermagier
2023-12-06 23:06:21 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-12-06 23:10:48 +0100bryanv(~quassel@2603:c028:4503:7500:45b7:933:ab17:bc10)
2023-12-06 23:11:13 +0100 <ski> bwe : "do you know any visual explanation with boxes of monad transformers (or in my case doing the State and Maybe thing)? I feel that this would help me significantly." -- well, not quite that, but perhaps still could be useful/interesting :
2023-12-06 23:11:26 +0100 <ski> "railroad diagrams" for `Maybe'/`Either' <https://www.youtube.com/watch?v=srQt1NAHYC0#t=40m53s>,<https://www.slideshare.net/ScottWlaschin/functional-design-patterns-devternity2018> (starting at slide 90)
2023-12-06 23:11:36 +0100 <ski> the "state boxen" in "Lazy Functional State Threads" by John Launchbury,Simon L. Peyton Jones in 1993-11-08 - 1994-04-10 at <https://www.microsoft.com/en-us/research/wp-content/uploads/1994/06/lazy-functional-state-threads.…>
2023-12-06 23:11:46 +0100 <ski> "Monads, a Field Guide" by dpiponi 2006-10-21 at <http://blog.sigfpe.com/2006/10/monads-field-guide.html>
2023-12-06 23:11:59 +0100 <ski> also, you should probably at some point check out
2023-12-06 23:12:04 +0100 <ski> @where invented-monads
2023-12-06 23:12:04 +0100 <lambdabot> "You Could Have Invented Monads! (And Maybe You Already Have.)" by dpiponi in 2006-08-07 at <http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html>
2023-12-06 23:12:13 +0100 <ski> "The right visual for Maybe may be decision trees." -- or railroad diagrams
2023-12-06 23:12:24 +0100 <monochrom> Yeah.
2023-12-06 23:12:46 +0100 <geekosaur> has monad transformers step by step been mentioned?
2023-12-06 23:12:56 +0100 <monochrom> At some point I would also like to rant against this obsession with visuals. But perhaps another day.
2023-12-06 23:13:01 +0100 <ski> not that i recall, geekosaur
2023-12-06 23:13:18 +0100 <ski> Typeclassopedia, and "All About Monads" have, though
2023-12-06 23:13:37 +0100 <ski> (about half a month ago, when i talked to bwe last about this, before today)
2023-12-06 23:14:40 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-12-06 23:16:31 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 256 seconds)
2023-12-06 23:20:59 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-06 23:21:52 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-12-06 23:26:38 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 256 seconds)
2023-12-06 23:32:55 +0100 <np> is there a variant on zip that keeps the /longest/ list? something like this: (zipDefault [1, 2, 3] [4, 5] 0) -> ([(1, 4), (2, 5), (3, 0)])
2023-12-06 23:34:06 +0100 <ncf> np: https://hackage.haskell.org/package/semialign-1.3/docs/Data-Semialign.html
2023-12-06 23:34:28 +0100 <np> ncf: cheers
2023-12-06 23:35:51 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-12-06 23:36:51 +0100 <ncf> :t alignWith
2023-12-06 23:36:52 +0100 <lambdabot> error: Variable not in scope: alignWith
2023-12-06 23:37:02 +0100 <ncf> @let import Data.Align
2023-12-06 23:37:02 +0100 <lambdabot> /sandbox/tmp/.L.hs:66:1: error:
2023-12-06 23:37:03 +0100 <lambdabot> Could not find module ‘Data.Align’
2023-12-06 23:37:03 +0100 <lambdabot> Use -v (or `:set -v` in ghci) to see a list of the files searched for.
2023-12-06 23:37:07 +0100 <ncf> :(
2023-12-06 23:41:16 +0100zetef(~quassel@95.77.17.251)
2023-12-06 23:42:42 +0100pretty_dumm_guy(~trottel@2a02:810b:43bf:aba0:dc82:dff8:b6b:479) (Quit: WeeChat 3.5)
2023-12-06 23:44:36 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-12-06 23:45:52 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 256 seconds)
2023-12-06 23:48:24 +0100bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 268 seconds)
2023-12-06 23:49:17 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-06 23:52:24 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds)
2023-12-06 23:55:17 +0100jmdaemon(~jmdaemon@user/jmdaemon)