2026/02/04

2026-02-04 00:00:27 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 00:02:58 +0100wickedjargon(~user@24.83.46.194) (Remote host closed the connection)
2026-02-04 00:03:48 +0100 <gentauro> tomsmeding: did Haskell move to GitHub? I thought development was at GitLab
2026-02-04 00:04:07 +0100jmcantrell(~weechat@user/jmcantrell) (Ping timeout: 255 seconds)
2026-02-04 00:05:43 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 00:05:56 +0100 <tomsmeding> gentauro: GHC is on gitlab, various other things are on github
2026-02-04 00:07:18 +0100 <tomsmeding> ghcup was originally on the haskell gitlab too, but moved to github a few years back
2026-02-04 00:07:32 +0100 <monochrom> That's an interesting move.
2026-02-04 00:07:48 +0100 <tomsmeding> I'm not sure what was the reasoning behind it
2026-02-04 00:08:15 +0100 <tomsmeding> but it's maerwald so he probably had a good reason for it :p
2026-02-04 00:13:56 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2026-02-04 00:14:13 +0100infinity0(~infinity0@pwned.gg) infinity0
2026-02-04 00:14:41 +0100 <tomsmeding> gentauro: and in general, "haskell" is not a single person or a single project. :P
2026-02-04 00:16:14 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 00:21:11 +0100Square2(~Square@user/square) Square
2026-02-04 00:21:37 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 00:31:53 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 00:33:29 +0100haritz(~hrtz@user/haritz) (Remote host closed the connection)
2026-02-04 00:36:54 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-04 00:40:43 +0100trickard(~trickard@cpe-85-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 00:41:59 +0100jmcantrell_(~weechat@user/jmcantrell) jmcantrell
2026-02-04 00:42:55 +0100_JusSx_(~jussx@78.211.92.21) (Ping timeout: 264 seconds)
2026-02-04 00:42:59 +0100trickard_(~trickard@cpe-85-98-47-163.wireline.com.au)
2026-02-04 00:44:20 +0100_JusSx_(~jussx@78.210.76.107)
2026-02-04 00:47:42 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 00:51:25 +0100 <haskellbridge> <sm> current discussion of this: https://gitlab.haskell.org/ghc/ghc/-/issues/26824
2026-02-04 00:52:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 240 seconds)
2026-02-04 00:53:23 +0100Googulator(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 00:53:38 +0100Googulator(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 00:54:41 +0100trickard_(~trickard@cpe-85-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 00:54:55 +0100trickard_(~trickard@cpe-85-98-47-163.wireline.com.au)
2026-02-04 01:03:29 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 01:06:55 +0100karenw(~karenw@user/karenw) karenw
2026-02-04 01:08:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 246 seconds)
2026-02-04 01:08:43 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 260 seconds)
2026-02-04 01:17:13 +0100xff0x(~xff0x@2405:6580:b080:900:e10b:1e35:aa5b:abb9) (Ping timeout: 246 seconds)
2026-02-04 01:19:16 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 01:20:09 +0100Tuplanolla(~Tuplanoll@85-156-32-207.elisa-laajakaista.fi) Tuplanolla
2026-02-04 01:26:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 01:30:01 +0100xff0x(~xff0x@2405:6580:b080:900:e10b:1e35:aa5b:abb9)
2026-02-04 01:31:09 +0100Googulator(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 01:31:16 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 01:34:45 +0100Sgeo(~Sgeo@user/sgeo) Sgeo
2026-02-04 01:37:18 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 01:38:35 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2026-02-04 01:42:13 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 255 seconds)
2026-02-04 01:47:06 +0100wickedjargon(~user@24.83.46.194) wickedjargon
2026-02-04 01:50:30 +0100wickedjargon(~user@24.83.46.194) (Remote host closed the connection)
2026-02-04 01:50:36 +0100xff0x(~xff0x@2405:6580:b080:900:e10b:1e35:aa5b:abb9) (Ping timeout: 252 seconds)
2026-02-04 01:50:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 01:51:13 +0100wickedjargon(~user@24.83.46.194) wickedjargon
2026-02-04 01:55:59 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2026-02-04 01:59:11 +0100Digitteknohippie(~user@user/digit) Digit
2026-02-04 01:59:29 +0100Digit(~user@user/digit) (Ping timeout: 260 seconds)
2026-02-04 02:00:56 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com) (Remote host closed the connection)
2026-02-04 02:06:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 02:09:18 +0100otto_s(~user@p4ff273b1.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2026-02-04 02:10:52 +0100otto_s(~user@p5de2f01c.dip0.t-ipconnect.de)
2026-02-04 02:10:59 +0100paddymahoney(~paddymaho@pool-99-250-10-137.cpe.net.cable.rogers.com)
2026-02-04 02:11:43 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 02:16:06 +0100wickedjargon(~user@24.83.46.194) (Remote host closed the connection)
2026-02-04 02:16:45 +0100 <yin> > mempty :: Maybe Char
2026-02-04 02:16:46 +0100 <lambdabot> No instance for ‘Semigroup Char’ arising from a use of ‘mempty’
2026-02-04 02:16:46 +0100 <lambdabot> In the expression: mempty :: Maybe Char
2026-02-04 02:16:51 +0100 <yin> isn't this weird?
2026-02-04 02:21:28 +0100mvk(~mvk@2607:fea8:5c9d:ee00::5716) mvk
2026-02-04 02:21:31 +0100mvk(~mvk@2607:fea8:5c9d:ee00::5716) (Client Quit)
2026-02-04 02:22:20 +0100Square2(~Square@user/square) (Remote host closed the connection)
2026-02-04 02:22:23 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 02:23:20 +0100 <ncf> that there's no Semigroup instance for Char? not particularly, no
2026-02-04 02:23:47 +0100 <ncf> or that Monoid (Maybe a) requires Semigroup a? that one might be up for debate
2026-02-04 02:26:53 +0100 <yin> the latter yeah, but i get it
2026-02-04 02:27:18 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 256 seconds)
2026-02-04 02:29:13 +0100DigitteknohippieDigit
2026-02-04 02:29:14 +0100 <EvanR> maybe you're thinking of First
2026-02-04 02:29:49 +0100omidmash6(~omidmash@user/omidmash) omidmash
2026-02-04 02:29:56 +0100 <EvanR> > mempty :: First (Maybe Char)
2026-02-04 02:29:57 +0100 <lambdabot> First {getFirst = Nothing}
2026-02-04 02:31:02 +0100 <EvanR> > mempty :: Maybe (NonEmpty Char)
2026-02-04 02:31:03 +0100 <lambdabot> Nothing
2026-02-04 02:31:25 +0100trickard_trickard
2026-02-04 02:31:42 +0100omidmash(~omidmash@user/omidmash) (Ping timeout: 244 seconds)
2026-02-04 02:31:42 +0100omidmash6omidmash
2026-02-04 02:32:55 +0100Square2(~Square@user/square) Square
2026-02-04 02:32:59 +0100 <EvanR> > First (Just 'a') <> First (Just 'b')
2026-02-04 02:33:00 +0100 <lambdabot> First {getFirst = Just 'a'}
2026-02-04 02:33:26 +0100 <EvanR> > Just 'a' <> Just 'b' -- what should happen
2026-02-04 02:33:27 +0100 <lambdabot> No instance for ‘Semigroup Char’ arising from a use of ‘<>’
2026-02-04 02:33:27 +0100 <lambdabot> In the expression: Just 'a' <> Just 'b'
2026-02-04 02:33:48 +0100 <EvanR> Just ('a' <> 'b')
2026-02-04 02:38:12 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 02:42:35 +0100 <probie> I propose Just ('a' <> 'b') should be Just (chr ((ord 'a' + ord 'b') `mod` (ord maxBound))). It's a lawful instance
2026-02-04 02:42:50 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds)
2026-02-04 02:43:21 +0100 <EvanR> a C programmer would be impressed... except the modulo is by some oddball number 1114112 ?
2026-02-04 02:43:52 +0100 <EvanR> to me it seems like adding the note B to the note F... makes sense if you assume MIDI but...
2026-02-04 02:44:26 +0100 <EvanR> just seems like defining things for the sake of it so "they do something" (js style)
2026-02-04 02:50:10 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-04 02:53:55 +0100 <geekosaur> we already do that (see `Foldable` and `Traversable` instances on tuples)
2026-02-04 02:54:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 02:55:40 +0100 <probie> > sum (3,4)
2026-02-04 02:55:41 +0100 <lambdabot> 4
2026-02-04 02:56:04 +0100 <probie> makes sense to me :p
2026-02-04 02:56:33 +0100 <probie> embarrassing when trying to explain to someone just learning Haskell who expects 7
2026-02-04 02:59:19 +0100rainbyte(~rainbyte@186.22.19.214) (Remote host closed the connection)
2026-02-04 02:59:39 +0100 <EvanR> insofaras Functor works on pairs, it makes sense
2026-02-04 03:00:12 +0100 <EvanR> kind of a if it's a functor then it can be folded for better or worse
2026-02-04 03:01:13 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 03:01:22 +0100 <EvanR> as it stands somebody can define a Semigroup for Char to carry out their version of great justice, whatever it is
2026-02-04 03:01:49 +0100 <probie> Sure, but at that point why don't we add https://hackage.haskell.org/package/acme-default to base
2026-02-04 03:01:49 +0100 <EvanR> without inflicting it on us... hopefully
2026-02-04 03:02:04 +0100 <EvanR> how is that related
2026-02-04 03:02:21 +0100prdak(~Thunderbi@user/prdak) (Remote host closed the connection)
2026-02-04 03:02:26 +0100 <EvanR> defining stuff in your program means it should be in base?
2026-02-04 03:02:48 +0100prdak(~Thunderbi@user/prdak) prdak
2026-02-04 03:03:04 +0100 <EvanR> and I'm wrong about functor to foldable
2026-02-04 03:03:28 +0100 <EvanR> in general
2026-02-04 03:04:36 +0100 <probie> Since we'd moved to talking about Foldable/Traversable for tuples, I interpreted your Semigroup for Char to be implying it should be added to base (after all, it has to be, or it's an orphan instance)
2026-02-04 03:06:19 +0100Tuplanolla(~Tuplanoll@85-156-32-207.elisa-laajakaista.fi) (Ping timeout: 264 seconds)
2026-02-04 03:12:25 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 03:17:30 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-04 03:29:45 +0100pavonia(~user@user/siracusa) (Read error: Connection reset by peer)
2026-02-04 03:30:07 +0100pavonia(~user@user/siracusa) siracusa
2026-02-04 03:44:41 +0100infinity0(~infinity0@pwned.gg) (Ping timeout: 265 seconds)
2026-02-04 03:53:06 +0100omidmash(~omidmash@user/omidmash) (Quit: The Lounge - https://thelounge.chat)
2026-02-04 03:56:32 +0100omidmash(~omidmash@user/omidmash) omidmash
2026-02-04 03:56:49 +0100karenw(~karenw@user/karenw) (Ping timeout: 246 seconds)
2026-02-04 04:18:42 +0100 <EvanR> I heard orphans are impossible, then we have packages on hackage specifically advertising orphan instances
2026-02-04 04:19:20 +0100 <EvanR> that it would be an Orphan is good, so that might go a ways to stop it from getting out of hand
2026-02-04 04:31:05 +0100notzmv(~umar@user/notzmv) (Ping timeout: 265 seconds)
2026-02-04 04:31:44 +0100trickard(~trickard@cpe-85-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 04:31:58 +0100trickard_(~trickard@cpe-85-98-47-163.wireline.com.au)
2026-02-04 04:37:19 +0100machinedgod(~machinedg@d75-159-126-101.abhsia.telus.net) (Ping timeout: 240 seconds)
2026-02-04 04:41:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 04:43:52 +0100jmcantrell_jmcantrell
2026-02-04 04:47:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 04:49:59 +0100DragonMaus(~DragonMau@user/dragonmaus) (Remote host closed the connection)
2026-02-04 04:50:26 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 04:50:35 +0100DragonMaus(~DragonMau@user/dragonmaus) DragonMaus
2026-02-04 04:55:03 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-04 04:55:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 05:05:59 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 05:11:03 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 250 seconds)
2026-02-04 05:11:27 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 05:11:44 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 05:21:45 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 05:21:48 +0100DragonMaus(~DragonMau@user/dragonmaus) (Remote host closed the connection)
2026-02-04 05:21:52 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 246 seconds)
2026-02-04 05:22:03 +0100DragonMaus(~DragonMau@user/dragonmaus) DragonMaus
2026-02-04 05:27:01 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 05:28:56 +0100DragonMaus(~DragonMau@user/dragonmaus) (Remote host closed the connection)
2026-02-04 05:29:32 +0100DragonMaus(~DragonMau@user/dragonmaus) DragonMaus
2026-02-04 05:37:33 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 05:42:37 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-04 05:46:13 +0100emaczen(~user@user/emaczen) (Ping timeout: 264 seconds)
2026-02-04 05:53:20 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 06:00:23 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2026-02-04 06:01:34 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2026-02-04 06:04:44 +0100chexum(~quassel@gateway/tor-sasl/chexum) chexum
2026-02-04 06:05:48 +0100jmcantrell(~weechat@user/jmcantrell) (Ping timeout: 252 seconds)
2026-02-04 06:11:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 06:16:07 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 246 seconds)
2026-02-04 06:27:08 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 06:31:17 +0100jle`(~jle`@23.240.67.73) (Quit: WeeChat 4.8.1)
2026-02-04 06:31:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 240 seconds)
2026-02-04 06:41:15 +0100Square(~Square4@user/square) Square
2026-02-04 06:42:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 06:43:56 +0100Square2(~Square@user/square) (Ping timeout: 244 seconds)
2026-02-04 06:47:52 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 265 seconds)
2026-02-04 06:51:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 06:52:35 +0100trickard__(~trickard@cpe-55-98-47-163.wireline.com.au)
2026-02-04 06:53:13 +0100trickard_(~trickard@cpe-85-98-47-163.wireline.com.au) (Ping timeout: 246 seconds)
2026-02-04 06:53:40 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Ping timeout: 245 seconds)
2026-02-04 06:55:44 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 240 seconds)
2026-02-04 06:56:24 +0100mange(~mange@user/mange) (Ping timeout: 260 seconds)
2026-02-04 07:03:18 +0100mange(~mange@user/mange) mange
2026-02-04 07:05:53 +0100takuan(~takuan@d8D86B9E9.access.telenet.be)
2026-02-04 07:06:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 07:11:46 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 256 seconds)
2026-02-04 07:21:24 +0100califax(~califax@user/califx) (Remote host closed the connection)
2026-02-04 07:21:24 +0100marinelli(~weechat@gateway/tor-sasl/marinelli) (Remote host closed the connection)
2026-02-04 07:21:24 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2026-02-04 07:21:24 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Read error: Connection reset by peer)
2026-02-04 07:21:36 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2026-02-04 07:21:38 +0100chexum(~quassel@gateway/tor-sasl/chexum) chexum
2026-02-04 07:21:43 +0100marinelli(~weechat@gateway/tor-sasl/marinelli) marinelli
2026-02-04 07:21:46 +0100califax(~califax@user/califx) califx
2026-02-04 07:21:47 +0100ChaiTRex(~ChaiTRex@user/chaitrex) ChaiTRex
2026-02-04 07:22:18 +0100gmg(~user@user/gehmehgeh) gehmehgeh
2026-02-04 07:22:35 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 07:24:02 +0100mfc_kbs(~keibisoft@2a06:1fc0:0:1::1cd) (Quit: ZNC 1.9.0+deb2build3 - https://znc.in)
2026-02-04 07:24:22 +0100mfc_kbs(~keibisoft@2a06:1fc0:0:1::1cd)
2026-02-04 07:24:53 +0100xff0x_(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-04 07:26:25 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Ping timeout: 264 seconds)
2026-02-04 07:26:28 +0100xff0x_xff0x
2026-02-04 07:27:44 +0100michalz(~michalz@185.246.207.215)
2026-02-04 07:29:39 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2026-02-04 07:31:12 +0100haritz(~hrtz@2a01:4b00:bc2e:7000:d5af:a266:ca31:5ef8)
2026-02-04 07:31:12 +0100haritz(~hrtz@2a01:4b00:bc2e:7000:d5af:a266:ca31:5ef8) (Changing host)
2026-02-04 07:31:12 +0100haritz(~hrtz@user/haritz) haritz
2026-02-04 07:32:28 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 07:32:35 +0100igemnace(~igemnace@user/igemnace) (Quit: ZNC 1.9.0+deb2build3 - https://znc.in)
2026-02-04 07:34:07 +0100igemnace(~igemnace@user/igemnace) igemnace
2026-02-04 07:35:37 +0100attlin(~user@user/attlin) (Quit: Leaving)
2026-02-04 07:37:00 +0100jle`(~jle`@2603:8001:3b00:11:ceae:40d3:5f9b:7e4d) jle`
2026-02-04 07:37:49 +0100trickard__(~trickard@cpe-55-98-47-163.wireline.com.au) (Ping timeout: 264 seconds)
2026-02-04 07:37:55 +0100trickard___(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 07:38:32 +0100peterbecich(~Thunderbi@71.84.33.135) peterbecich
2026-02-04 07:38:42 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Ping timeout: 244 seconds)
2026-02-04 07:39:01 +0100trickard___trickard
2026-02-04 07:39:13 +0100attlin(~user@user/attlin) attlin
2026-02-04 07:40:38 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 07:42:12 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 07:45:19 +0100trickard(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 07:45:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-04 07:48:42 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 07:49:12 +0100michalz(~michalz@185.246.207.215) (Ping timeout: 252 seconds)
2026-02-04 07:50:11 +0100hakutaku(~textual@chen.yukari.eu.org) (Quit: Textual IRC Client: www.textualapp.com)
2026-02-04 07:50:25 +0100hakutaku(~textual@chen.yukari.eu.org)
2026-02-04 07:50:25 +0100hakutaku(~textual@chen.yukari.eu.org) (Changing host)
2026-02-04 07:50:25 +0100hakutaku(~textual@user/hakutaku) hakutaku
2026-02-04 07:50:38 +0100hakutaku(~textual@user/hakutaku) (Client Quit)
2026-02-04 07:51:01 +0100hakutaku(~textual@user/hakutaku) hakutaku
2026-02-04 07:52:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 07:57:37 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-02-04 07:57:37 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Read error: Connection reset by peer)
2026-02-04 08:02:43 +0100michalz(~michalz@185.246.207.217)
2026-02-04 08:05:20 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 08:08:09 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 08:09:19 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Ping timeout: 240 seconds)
2026-02-04 08:11:14 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 08:12:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 240 seconds)
2026-02-04 08:12:43 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Read error: Connection reset by peer)
2026-02-04 08:14:10 +0100ft(~ft@p508db4c0.dip0.t-ipconnect.de) (Quit: leaving)
2026-02-04 08:23:09 +0100jle`(~jle`@2603:8001:3b00:11:ceae:40d3:5f9b:7e4d) (Quit: WeeChat 4.8.1)
2026-02-04 08:23:37 +0100 <gentauro> tomsmeding: got it. Thx for explanation
2026-02-04 08:23:48 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 08:24:31 +0100michalz(~michalz@185.246.207.217) (Ping timeout: 255 seconds)
2026-02-04 08:25:55 +0100 <[exa]> is there some way to get an operation that would take a list (or so) of MVars and wait until any of them can be taken? Or do I generally have to do this with another synchronization tool (Chan)?
2026-02-04 08:26:56 +0100michalz(~michalz@185.246.207.218)
2026-02-04 08:28:22 +0100ar3ph(~ar3ph@user/ar3ph) (Quit: Ping timeout (120 seconds))
2026-02-04 08:28:33 +0100ar3ph(~ar3ph@user/ar3ph) ar3ph
2026-02-04 08:29:09 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2026-02-04 08:30:38 +0100 <gentauro> I've recently been following this persons task on removing F# from the boundries of the .NET platform to become trully native on bare metal: https://speakez.tech/blog/
2026-02-04 08:30:55 +0100 <gentauro> the blog post are really enjoyable to read
2026-02-04 08:31:04 +0100gentauroAnd I'm not the guy xD
2026-02-04 08:31:38 +0100 <gentauro> however, as I understand it, it's a single person doing all the work (perhaps with the help of AI-tools?)
2026-02-04 08:32:38 +0100 <Leary> [exa]: In principle you can `race` `takeMVar` across the list, but I suggest you just use `TMVar`s instead.
2026-02-04 08:34:22 +0100 <[exa]> Leary: oh TMVars, that would work too
2026-02-04 08:35:06 +0100emmanuelux(~em@user/emmanuelux) emmanuelux
2026-02-04 08:35:37 +0100 <[exa]> I'm currently thinking about just going with TChan, will see
2026-02-04 08:36:56 +0100fp(~Thunderbi@2001:708:150:10::9d7e) fp
2026-02-04 08:38:12 +0100YuutaW(~YuutaW@2404:f4c0:f9c3:502::100:6eef) (Read error: Connection reset by peer)
2026-02-04 08:38:24 +0100yuuta(~YuutaW@infornography.yta.moe) YuutaW
2026-02-04 08:39:08 +0100emmanuelux(~em@user/emmanuelux) (Read error: Connection reset by peer)
2026-02-04 08:39:34 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 08:40:12 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2026-02-04 08:43:08 +0100 <[exa]> gentauro: the lookings of the blog don't spawn much confidence indeed
2026-02-04 08:43:38 +0100emmanuelux(~em@user/emmanuelux) emmanuelux
2026-02-04 08:44:53 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 260 seconds)
2026-02-04 08:45:16 +0100emmanuelux(~em@user/emmanuelux) (Read error: Connection reset by peer)
2026-02-04 08:45:37 +0100vanishingideal(~vanishing@user/vanishingideal) vanishingideal
2026-02-04 08:45:46 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Quit: xff0x)
2026-02-04 08:47:26 +0100monochrom(trebla@216.138.220.146) (Quit: ZNC 1.9.1+deb2build5 - https://znc.in)
2026-02-04 08:49:20 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-04 08:52:22 +0100emmanuelux(~em@user/emmanuelux) emmanuelux
2026-02-04 08:53:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 08:53:30 +0100monochrom(trebla@216.138.220.146) monochrom
2026-02-04 08:57:47 +0100Enrico63(~Enrico63@148.252.128.12) Enrico63
2026-02-04 09:00:09 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds)
2026-02-04 09:01:10 +0100fp(~Thunderbi@2001:708:150:10::9d7e) (Ping timeout: 245 seconds)
2026-02-04 09:01:57 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net) (Quit: zzz)
2026-02-04 09:10:33 +0100kuribas(~user@2a02-1810-2825-6000-16d8-7b7e-1bcd-b36.ip6.access.telenet.be) kuribas
2026-02-04 09:11:24 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-02-04 09:13:43 +0100vanishingideal(~vanishing@user/vanishingideal) (Ping timeout: 240 seconds)
2026-02-04 09:16:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 250 seconds)
2026-02-04 09:17:19 +0100peterbecich(~Thunderbi@71.84.33.135) (Ping timeout: 240 seconds)
2026-02-04 09:19:16 +0100sord937(~sord937@gateway/tor-sasl/sord937) sord937
2026-02-04 09:20:39 +0100 <[exa]> hm I guess better ask about the original problem.. I have a few concurrent helpers for Streaming, and I want to have a parallel unfolding function. Example here: https://paste.tomsmeding.com/y8PLkSYh -- mapMForkNIO works, unfoldStream works, and I'd love to them combined, but I can't see a good data structure that would hold the temporary data for it together. Having a list queue there doesn't
2026-02-04 09:20:41 +0100 <[exa]> sound very good to me (I'll have to scan it quite often to find new work items, so it might get quite slow)
2026-02-04 09:21:52 +0100 <[exa]> (duck effect: I realized I might just place a limit on the queue size instead of the thread count, which would probably also limit the possible amount of stupid work done over the queue)
2026-02-04 09:22:05 +0100 <[exa]> anyway any ideas welcome. :D
2026-02-04 09:22:31 +0100_JusSx_(~jussx@78.210.76.107) (Ping timeout: 240 seconds)
2026-02-04 09:23:36 +0100_JusSx_(~jussx@78.210.76.107)
2026-02-04 09:30:36 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Quit: xff0x)
2026-02-04 09:32:55 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2026-02-04 09:40:29 +0100emmanuelux(~em@user/emmanuelux) (Quit: bye)
2026-02-04 09:40:42 +0100chele(~chele@user/chele) chele
2026-02-04 09:52:28 +0100prdak(~Thunderbi@user/prdak) (Quit: prdak)
2026-02-04 09:53:05 +0100housemate(~housemate@202.7.248.67) (Quit: https://ineedsomeacidtocalmmedown.space/)
2026-02-04 09:57:29 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-04 10:02:21 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2026-02-04 10:05:27 +0100fp(~Thunderbi@wireless-86-50-140-153.open.aalto.fi) fp
2026-02-04 10:05:53 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 10:06:07 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 10:09:34 +0100fp(~Thunderbi@wireless-86-50-140-153.open.aalto.fi) (Ping timeout: 246 seconds)
2026-02-04 10:15:19 +0100xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Ping timeout: 264 seconds)
2026-02-04 10:18:26 +0100lucabtz(~lucabtz@user/lucabtz) lucabtz
2026-02-04 10:19:01 +0100ljdarj(~Thunderbi@user/ljdarj) (Ping timeout: 246 seconds)
2026-02-04 10:20:01 +0100housemate(~housemate@202.7.248.67) housemate
2026-02-04 10:21:43 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 10:21:56 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 10:29:45 +0100qqq(~qqq@185.54.21.178)
2026-02-04 10:31:53 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 10:32:04 +0100fp(~Thunderbi@wireless-86-50-140-153.open.aalto.fi) fp
2026-02-04 10:32:34 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 10:37:02 +0100weary-traveler(~user@user/user363627) user363627
2026-02-04 10:51:40 +0100fp(~Thunderbi@wireless-86-50-140-153.open.aalto.fi) (Ping timeout: 255 seconds)
2026-02-04 10:59:39 +0100AlexNoo_(~AlexNoo@85.174.181.199)
2026-02-04 11:00:25 +0100AlexNoo__(~AlexNoo@85.174.181.199)
2026-02-04 11:01:49 +0100AlexZenon(~alzenon@178.34.150.239) (Ping timeout: 264 seconds)
2026-02-04 11:03:07 +0100AlexNoo(~AlexNoo@178.34.150.239) (Ping timeout: 246 seconds)
2026-02-04 11:03:33 +0100AlexNoo(~AlexNoo@85.174.181.199)
2026-02-04 11:04:19 +0100AlexNoo_(~AlexNoo@85.174.181.199) (Ping timeout: 260 seconds)
2026-02-04 11:04:54 +0100AlexNoo__(~AlexNoo@85.174.181.199) (Ping timeout: 260 seconds)
2026-02-04 11:05:16 +0100AlexZenon(~alzenon@85.174.181.199)
2026-02-04 11:05:18 +0100AlexNoo_(~AlexNoo@85.174.181.199)
2026-02-04 11:07:49 +0100AlexNoo(~AlexNoo@85.174.181.199) (Ping timeout: 260 seconds)
2026-02-04 11:14:25 +0100housemate(~housemate@202.7.248.67) (Quit: https://ineedsomeacidtocalmmedown.space/)
2026-02-04 11:21:32 +0100 <gentauro> [exa]: if you search for "// F* specification for verified memory operation" it seems that he also will add somekind of `liquid F#/F*` support? https://speakez.tech/blog/doubling-down/
2026-02-04 11:22:05 +0100 <gentauro> I mean, all the things that he mentions are "extremely hard" to do on its own.
2026-02-04 11:25:29 +0100 <[exa]> gentauro: given the amount of "complete" code they have on githubs I'd say this might be a case for poc||gtfo
2026-02-04 11:31:43 +0100qqq(~qqq@185.54.21.178) (Ping timeout: 244 seconds)
2026-02-04 11:32:04 +0100AlexNoo_AlexNoo
2026-02-04 11:37:18 +0100vanishingideal(~vanishing@user/vanishingideal) vanishingideal
2026-02-04 11:38:57 +0100trickard_trickard
2026-02-04 11:39:50 +0100qqq(~qqq@185.54.21.178)
2026-02-04 11:43:43 +0100pavonia(~user@user/siracusa) (Read error: Connection reset by peer)
2026-02-04 11:44:01 +0100pavonia(~user@user/siracusa) siracusa
2026-02-04 11:54:06 +0100fp(~Thunderbi@2001:708:20:1406::1370) fp
2026-02-04 11:55:14 +0100 <gentauro> [exa]: could be. However, I would love to see F# removing all dependencies to MS, a bit like Java did with the openJDK
2026-02-04 11:59:26 +0100 <gentauro> … and Oracle :)
2026-02-04 12:06:26 +0100 <[exa]> doesn't it kinda become haskell by then?
2026-02-04 12:08:34 +0100 <[exa]> (or ocaml, depending on which direction you take)
2026-02-04 12:11:40 +0100 <gentauro> [exa]: but both Haskell and OCaml have garbage collectors. They seem to go the `C/C++/Rust` way -> https://speakez.tech/blog/gaining-closure/
2026-02-04 12:12:44 +0100 <gentauro> like I say, they are so many "complex and hard" topics that I really would like this to succeed, just to see the outcome :o
2026-02-04 12:12:55 +0100vanishingideal(~vanishing@user/vanishingideal) (Ping timeout: 240 seconds)
2026-02-04 12:13:25 +0100gentauroanyway, back to "old-school" coding
2026-02-04 12:14:56 +0100 <[exa]> gentauro: I was trying to do similar some 10 years ago, the outcome is that converting any existing functional programming system to this behavior is either impossible or basically you end up with something like the compiled schemes or Rust
2026-02-04 12:16:16 +0100 <[exa]> there was also quite a bit of research on related things back in 90s, maybe some stuff moved but my main takeaway was that it's not practical
2026-02-04 12:17:42 +0100 <mesaoptimizer> what is the current recommended setup for emacs with haskell? if you have a robust configuration, please link it to me.
2026-02-04 12:18:30 +0100 <mesaoptimizer> I think `haskell-mode` is unable to do stuff like open a `cabal repl` on a file that has an in-built set of dependencies declared
2026-02-04 12:20:22 +0100 <haskellbridge> <magic_rb> thats more of a cabal problem i seem to recal
2026-02-04 12:22:52 +0100[exa]hides behind his zero lines of vim config
2026-02-04 12:30:44 +0100 <gentauro> mesaoptimizer: my current setup doesn't work as expected, so I just "go with it" (no intellisense) xD
2026-02-04 12:31:07 +0100 <gentauro> I'm going to give a talk in March. I should probably begin to look into how to solve it
2026-02-04 12:31:10 +0100fp(~Thunderbi@2001:708:20:1406::1370) (Ping timeout: 245 seconds)
2026-02-04 12:31:16 +0100 <gentauro> but you know, we are "lazy" after all xD
2026-02-04 12:31:20 +0100fp1(~Thunderbi@2001:708:150:10::9d7e) fp
2026-02-04 12:31:59 +0100 <gentauro> [exa]: yeah, it sounds to good to be true. But I like how they go to academia to get knowledge.
2026-02-04 12:32:31 +0100 <gentauro> but, that sometimes come with the downside of not being "industry friendly" as you mention
2026-02-04 12:33:32 +0100 <[exa]> wait how do they get knowledge from academia? (I probably missed that part, looks super industrial to me tbh)
2026-02-04 12:34:30 +0100fp(~Thunderbi@130.233.70.158) fp
2026-02-04 12:34:59 +0100fp1(~Thunderbi@2001:708:150:10::9d7e) (Client Quit)
2026-02-04 12:36:48 +0100 <gentauro> [exa]: MLKit comes from academia -> https://www.itu.dk/research/mlkit (and the reserach page doesn't even work, so yeah, 100% academia xD)
2026-02-04 12:37:29 +0100 <gentauro> The F* "thingy" is a 100% copied from Liquid Haskell -> https://software.imdea.org/careers/2022-02-intern-liquid/
2026-02-04 12:38:41 +0100 <gentauro> so this core components are mental. Then they are also opting for creating all the environment tools https://speakez.tech/blog/leveling-up-with-lattice/
2026-02-04 12:38:46 +0100 <gentauro> seems too much
2026-02-04 12:41:33 +0100 <[exa]> seems a bit too much like the "works by MAGIC!!!!" 100% better FP compiler that we had here like 1 year ago (what was the name btw)
2026-02-04 12:41:34 +0100_JusSx_(~jussx@78.210.76.107) (Ping timeout: 256 seconds)
2026-02-04 12:41:41 +0100 <[exa]> with extra LLM flavor on top
2026-02-04 12:42:05 +0100trickard(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 12:42:18 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 12:43:29 +0100_JusSx_(~jussx@37.161.247.165)
2026-02-04 12:44:17 +0100 <gentauro> the one that spawned from Elm?
2026-02-04 12:44:59 +0100 <gentauro> https://www.roc-lang.org/examples/ElmWebApp/README <- this one?
2026-02-04 12:45:23 +0100 <gentauro> not to confuse with https://en.wikipedia.org/wiki/Rocq (rename of Coq)
2026-02-04 12:46:05 +0100 <gentauro> https://www.roc-lang.org/ <- this link instead
2026-02-04 12:46:10 +0100 <mesaoptimizer> gentauro: MLton and Poly/ML are rock solid though
2026-02-04 12:46:16 +0100 <tomsmeding> gentauro: do you mean this? https://elsman.com/mlkit/
2026-02-04 12:46:25 +0100 <mesaoptimizer> I think the MLkit links are broken but IIRC they still have a github
2026-02-04 12:46:44 +0100 <mesaoptimizer> tomsmeding: yes. https://github.com/melsman/mlkit
2026-02-04 12:47:20 +0100 <[exa]> gentauro: nah it was some weirder one, unrelated to elm, it claimed it has waaaaaay better evaluation method than stg
2026-02-04 12:47:54 +0100 <gentauro> xD
2026-02-04 12:48:03 +0100 <tomsmeding> I know which you mean but names
2026-02-04 12:48:12 +0100 <gentauro> tomsmeding: yes
2026-02-04 12:48:27 +0100 <[exa]> yes
2026-02-04 12:48:37 +0100 <tomsmeding> lol
2026-02-04 12:48:39 +0100trickard_trickard
2026-02-04 12:48:52 +0100 <[exa]> kinda looks like it disappeared from the internets, I'd say that confirms a hypothesis
2026-02-04 12:48:58 +0100 <tomsmeding> Formality by Maia Victor
2026-02-04 12:49:00 +0100 <tomsmeding> memory worked
2026-02-04 12:49:44 +0100 <gentauro> «Mads Tofte (Main architect of adding region support to the MLKit, co-developer of MLKit version 1)»
2026-02-04 12:49:53 +0100 <gentauro> I know him :)
2026-02-04 12:50:11 +0100 <tomsmeding> oh right it was renamed, I guess HVM now
2026-02-04 12:51:07 +0100 <gentauro> Victor Maia is the guy doing crazy lambda calculus right?
2026-02-04 12:51:25 +0100 <tomsmeding> yeah graph reduction evaluation strategies for asymptotic performance improvements of standard evaluation
2026-02-04 12:51:31 +0100 <tomsmeding> *over
2026-02-04 12:52:16 +0100 <gentauro> tomsmeding: yeah, that's who I'm thinking of
2026-02-04 12:52:49 +0100 <[exa]> but where's the explanation with the MAGIC gif
2026-02-04 12:52:58 +0100 <tomsmeding> I dunno
2026-02-04 12:53:15 +0100qqq(~qqq@185.54.21.178) (Ping timeout: 244 seconds)
2026-02-04 12:53:32 +0100 <tomsmeding> but this does fancy evaluation strategies + had a hype cycle a few years back, so fits your description
2026-02-04 12:53:41 +0100 <mesaoptimizer> https://xcancel.com/VictorTaelin/ do you mean this guy?
2026-02-04 12:53:48 +0100vanishingideal(~vanishing@user/vanishingideal) vanishingideal
2026-02-04 12:53:56 +0100 <tomsmeding> name matches, in any case
2026-02-04 12:53:58 +0100 <mesaoptimizer> he's gotten very distracted rewriting his interaction nets compiler
2026-02-04 12:54:11 +0100 <tomsmeding> well interaction nets is what it was all about anyway from the start
2026-02-04 12:54:12 +0100 <mesaoptimizer> went from Haskell to Rust to C IIRC
2026-02-04 13:04:48 +0100comerijn(~merijn@77.242.116.146) merijn
2026-02-04 13:06:08 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 240 seconds)
2026-02-04 13:06:20 +0100 <gentauro> tomsmeding: it's the same person -> https://github.com/maiavictor (
2026-02-04 13:06:25 +0100 <gentauro> Account renamed to VictorTaelin.)
2026-02-04 13:07:02 +0100 <tomsmeding> yeah
2026-02-04 13:13:35 +0100Pozyomka(~pyon@user/pyon) (Quit: brb)
2026-02-04 13:15:55 +0100Pozyomka(~pyon@user/pyon) pyon
2026-02-04 13:16:05 +0100lucabtz(~lucabtz@user/lucabtz) (Ping timeout: 244 seconds)
2026-02-04 13:20:52 +0100 <[exa]> I love how github gists serve as primary research communication vessel there
2026-02-04 13:25:32 +0100wbrawner(~wbrawner@129.146.105.153) (Remote host closed the connection)
2026-02-04 13:25:33 +0100 <tomsmeding> I've seen worse
2026-02-04 13:25:39 +0100 <tomsmeding> at least gists have a unique ID
2026-02-04 13:26:41 +0100 <int-e> Better than Discord.
2026-02-04 13:26:58 +0100 <tomsmeding> ^
2026-02-04 13:27:14 +0100 <tomsmeding> right, gists also have the obvious (?) advantage of being public
2026-02-04 13:28:59 +0100 <[exa]> int-e: <3 <3 <3 publishing on a non-public chat <3 <3 <3 never thought about the advantages
2026-02-04 13:31:51 +0100wbrawner(~wbrawner@129.146.105.153) wbrawner
2026-02-04 13:32:32 +0100 <int-e> [exa]: you can always cits such things as "personal communcation" :P
2026-02-04 13:32:34 +0100 <tomsmeding> [exa]: also gists have public edit history
2026-02-04 13:32:42 +0100machinedgod(~machinedg@d75-159-126-101.abhsia.telus.net) machinedgod
2026-02-04 13:32:46 +0100tomsmedingnow wonders if you can force-push to gists
2026-02-04 13:33:53 +0100lucabtz(~lucabtz@user/lucabtz) lucabtz
2026-02-04 13:34:20 +0100 <opqdonut> I'm pretty sure I've done it
2026-02-04 13:37:24 +0100 <haskellbridge> <Morj> Yes you can, github gists are just a repository with a weird interface
2026-02-04 13:37:25 +0100lucabtz(~lucabtz@user/lucabtz) (Client Quit)
2026-02-04 13:37:27 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) humasect
2026-02-04 13:37:35 +0100lucabtz(~lucabtz@user/lucabtz) lucabtz
2026-02-04 13:37:38 +0100 <haskellbridge> <Morj> And a restriction on having directories which is annoying
2026-02-04 13:38:18 +0100 <tomsmeding> [exa]: here, the first weakness over arxiv spotted
2026-02-04 13:38:30 +0100 <tomsmeding> /s
2026-02-04 13:44:44 +0100vanishingideal(~vanishing@user/vanishingideal) (Ping timeout: 260 seconds)
2026-02-04 13:45:50 +0100 <int-e> [exa]: there's also this 4chan story: https://en.wikipedia.org/wiki/Superpermutation#Lower_bounds,_or_the_Haruhi_problem
2026-02-04 13:48:53 +0100 <[exa]> lovely
2026-02-04 13:48:59 +0100 <mesaoptimizer> btw, did the FP complete people create Stack, and then move on to Rust?
2026-02-04 13:49:13 +0100 <[exa]> (I'm busy starting Lecture Gists in Computer Science)
2026-02-04 13:50:43 +0100 <int-e> [exa]: sorry I can't pay attention unless it's a 30 second performative dance in 9:16 format
2026-02-04 13:54:52 +0100AlexZenon(~alzenon@85.174.181.199) (Quit: ;-)
2026-02-04 13:56:37 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 13:56:46 +0100AlexNoo(~AlexNoo@85.174.181.199) (Quit: Leaving)
2026-02-04 13:56:57 +0100qqq(~qqq@185.54.21.178)
2026-02-04 13:58:19 +0100 <gentauro> mesaoptimizer: yeah, it seems like Snoyman did that :(
2026-02-04 13:59:41 +0100 <gentauro> https://www.snoyman.com/ -> «With a deep passion for Rust and functional programming, …»
2026-02-04 13:59:52 +0100gentauroRust before FP :'(
2026-02-04 14:00:56 +0100chromoblob(~chromoblo@user/chromob1ot1c) (Ping timeout: 240 seconds)
2026-02-04 14:04:04 +0100mange(~mange@user/mange) (Ping timeout: 246 seconds)
2026-02-04 14:15:39 +0100comerijn(~merijn@77.242.116.146) (Ping timeout: 260 seconds)
2026-02-04 14:16:53 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-04 14:18:29 +0100xff0x(~xff0x@2405:6580:b080:900:5e48:b86:53c8:1c87)
2026-02-04 14:20:37 +0100AlexZenon(~alzenon@85.174.181.199)
2026-02-04 14:22:22 +0100AlexNoo(~AlexNoo@85.174.181.199)
2026-02-04 14:23:09 +0100AlexNoo_(~AlexNoo@85.174.181.199)
2026-02-04 14:23:25 +0100qqq(~qqq@185.54.21.178) (Ping timeout: 264 seconds)
2026-02-04 14:23:53 +0100AlexNoo__(~AlexNoo@85.174.181.199)
2026-02-04 14:24:55 +0100AlexZenon(~alzenon@85.174.181.199) (Ping timeout: 240 seconds)
2026-02-04 14:26:46 +0100AlexNoo(~AlexNoo@85.174.181.199) (Ping timeout: 255 seconds)
2026-02-04 14:26:54 +0100zenstoic(uid461840@id-461840.hampstead.irccloud.com) zenstoic
2026-02-04 14:27:40 +0100AlexNoo_(~AlexNoo@85.174.181.199) (Ping timeout: 255 seconds)
2026-02-04 14:28:07 +0100AlexNoo__(~AlexNoo@85.174.181.199) (Ping timeout: 255 seconds)
2026-02-04 14:28:52 +0100chromoblob(~chromoblo@user/chromob1ot1c) chromoblob\0
2026-02-04 14:29:09 +0100AlexZenon(~alzenon@85.174.181.199)
2026-02-04 14:29:23 +0100Alex_delenda_est(~al_test@85.174.181.199)
2026-02-04 14:31:45 +0100AlexNoo(~AlexNoo@85.174.181.199)
2026-02-04 14:32:43 +0100emaczen(~user@user/emaczen) emaczen
2026-02-04 14:37:49 +0100mjacob(~mjacob@adrastea.uberspace.de) (Ping timeout: 264 seconds)
2026-02-04 14:42:01 +0100 <mesaoptimizer> wonder why
2026-02-04 14:42:30 +0100 <mesaoptimizer> perhaps their target customer base changed
2026-02-04 14:44:33 +0100 <gentauro> mesaoptimizer: I recall that Snoyman is educated in Actuarial sciences. Perhaps Rust is a better tool for solving those kind of problems?
2026-02-04 14:54:57 +0100infinity0(~infinity0@pwned.gg) infinity0
2026-02-04 14:56:00 +0100poscat0x04(~poscat@user/poscat) poscat
2026-02-04 14:57:58 +0100poscat(~poscat@user/poscat) (Ping timeout: 265 seconds)
2026-02-04 15:01:31 +0100infinity0(~infinity0@pwned.gg) (Ping timeout: 264 seconds)
2026-02-04 15:02:07 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 240 seconds)
2026-02-04 15:03:48 +0100__monty__(~toonn@user/toonn) toonn
2026-02-04 15:04:30 +0100akegalj(~akegalj@141-136-251-118.dsl.iskon.hr) akegalj
2026-02-04 15:06:43 +0100Enrico63(~Enrico63@148.252.128.12) (Ping timeout: 272 seconds)
2026-02-04 15:07:28 +0100merijn(~merijn@77.242.116.146) merijn
2026-02-04 15:08:33 +0100tremon(~tremon@83.80.159.219) tremon
2026-02-04 15:09:00 +0100lucabtz(~lucabtz@user/lucabtz) (Quit: leaving)
2026-02-04 15:09:10 +0100lucabtz(~lucabtz@user/lucabtz) lucabtz
2026-02-04 15:13:02 +0100wickedjargon(~user@2605:8d80:5431:33ac:d84d:2363:57fe:412) wickedjargon
2026-02-04 15:13:29 +0100 <mesaoptimizer> well, I haven't tried Rust yet, but I do understand that it has a surprising number of ML-family features I appreciate, such as ADTs and exhaustive pattern matching
2026-02-04 15:21:02 +0100 <haskellbridge> <magic_rb> and it lacks a substantial amount of features that make using it a pain :P
2026-02-04 15:21:34 +0100infinity0(~infinity0@pwned.gg) infinity0
2026-02-04 15:23:39 +0100 <lucabtz> magic_rb what features would you like to see in rust?
2026-02-04 15:23:47 +0100 <merijn> It's more like "Rust pays a (fairly heavy) price, to attain something hard to achieve" (i.e. memory safety without GC)
2026-02-04 15:24:03 +0100 <merijn> So Rust is supercool. IFF you cannot afford/accept a GC
2026-02-04 15:24:18 +0100 <haskellbridge> <magic_rb> lucabtz: monads, more type magic, GC
2026-02-04 15:24:38 +0100 <merijn> Now, personally I think the vast majority of code is perfectly fine with a GC. In which case you pay the price for nothing
2026-02-04 15:24:45 +0100 <lucabtz> it kinda has do notation, but only for Option and Result
2026-02-04 15:25:03 +0100 <merijn> If you can afford GC then something like Haskell, Scala, any ML will give you essentially all the stuff you want
2026-02-04 15:25:03 +0100 <lucabtz> and for future
2026-02-04 15:25:07 +0100 <haskellbridge> <magic_rb> in 99% of cases i dont give a rats ass about not having a GC and having to fight the borrow checker or sprinkle Arc<> absolutely everywhere is not what i want to be doing
2026-02-04 15:25:23 +0100 <haskellbridge> <magic_rb> not having actual do notation with Monads is to me a deal breaker
2026-02-04 15:25:43 +0100 <haskellbridge> <magic_rb> things get so much more awkward with those imo
2026-02-04 15:25:58 +0100 <lucabtz> yeah they missed a chance with do notation maybe
2026-02-04 15:29:12 +0100 <haskellbridge> <Morj> «what features would you like to see in rust» I want `pub fn append_byte<const N: usize>(array: [u8; N], b: u8) -> [u8; N + 1]` to compile
2026-02-04 15:29:39 +0100 <haskellbridge> <Morj> And monad readers
2026-02-04 15:29:50 +0100 <haskellbridge> <magic_rb> and a GC
2026-02-04 15:29:57 +0100 <haskellbridge> <magic_rb> just, give me haskell thank you very much
2026-02-04 15:30:11 +0100 <haskellbridge> <Morj> I'm partial to the RIO approach of having only one monad, but you parameterize the context you read from it
2026-02-04 15:30:22 +0100Enrico63(~Enrico63@148.252.128.12) Enrico63
2026-02-04 15:30:29 +0100 <haskellbridge> <Morj> If this were in rust, some problems of async runtimes would be removed
2026-02-04 15:30:41 +0100 <haskellbridge> <magic_rb> honestly the only reason i may personally choose rust over haskell is due to the library ecosystem. for embedded i would try microhs, though idk how well that would work
2026-02-04 15:31:06 +0100 <haskellbridge> <Morj> «just, give me haskell thank you very much» yeh. Except I currently have to write a thing without gc or a large runtime at all
2026-02-04 15:31:12 +0100 <haskellbridge> <magic_rb> :(
2026-02-04 15:31:27 +0100 <haskellbridge> <Morj> Hm, actually microhs might fit there, need to evaluate
2026-02-04 15:32:17 +0100 <haskellbridge> <Morj> Although, performance..
2026-02-04 15:32:26 +0100 <haskellbridge> <magic_rb> microhs still does gc no?
2026-02-04 15:32:33 +0100 <haskellbridge> <magic_rb> or does it do refcounting
2026-02-04 15:33:18 +0100 <haskellbridge> <Morj> I think it's gc. I was rather talking about not having a big runtime, the environment is rather memory constrained
2026-02-04 15:33:26 +0100 <haskellbridge> <Morj> «I have a [Word8] that I would like to convert to a Word32 in big endian. How can I do that?» - type shit that I have to deal with haskell
2026-02-04 15:33:43 +0100 <haskellbridge> <Morj> *with in haskell
2026-02-04 15:38:20 +0100 <haskellbridge> <magic_rb> my condolences
2026-02-04 15:38:32 +0100 <haskellbridge> <magic_rb> i wrote a fat32 filesystem driver in haskell for my thesis, it was an experience
2026-02-04 15:39:55 +0100 <merijn> I mean, that's kinda easy, just turn into ByteString and use attoparsec and/or binary :p
2026-02-04 15:49:04 +0100noctux(~noctux@user/noctux) (Ping timeout: 246 seconds)
2026-02-04 15:49:05 +0100 <akegalj> magic_rb: found this https://mail.haskell.org/pipermail/beginners/2010-October/005571.html
2026-02-04 15:54:54 +0100 <gentauro> Morj: I noticed myself that Rust needs to know (statically) the size of arrays. Don't you end up by using a fixed buffer size and then just iterate?
2026-02-04 15:55:35 +0100 <gentauro> And you end up padding/populating non-used array items with some value.
2026-02-04 15:55:57 +0100 <haskellbridge> <Morj> In rust you can have a choice between statically and dynamically known sizes, roughly [u8; N] and Box<[u8]>
2026-02-04 15:56:33 +0100 <haskellbridge> <Morj> I wanted to write this function because I have arrays of different sizes (for XOF seeding), and the algorithm wants to append one or two bytes to the seeds sometimes
2026-02-04 15:57:19 +0100 <haskellbridge> <Morj> If it were just Box<[u8]>, this could be achieved very simply. If it were [u8; 32] to append a byte and get [u8; 33] - also very simple. But I wanted to write one function for several N sizes
2026-02-04 15:59:58 +0100 <haskellbridge> <Morj> I could create an array of size 33 padded with zeroes, true, but it's even less convenient to use - there is no simple conversion from size 33 to size 32
2026-02-04 16:00:40 +0100 <dutchie> why can I never remember which way the numbers go in fixity declarations
2026-02-04 16:01:30 +0100 <dutchie> i always have to :i $ in ghci to see whether low number is tight binding or not
2026-02-04 16:01:55 +0100 <haskellbridge> <Morj> I wanted to suggest memorizing that ($) is zero and using that as a mnemonic =)
2026-02-04 16:04:28 +0100 <gentauro> Morj: Got it
2026-02-04 16:06:59 +0100noctux(~noctux@user/noctux) noctux
2026-02-04 16:09:17 +0100trickard(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 16:09:31 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 16:09:57 +0100 <mesaoptimizer> microhs + mcabal cannot yet install / build most hackage packages
2026-02-04 16:10:23 +0100 <mesaoptimizer> IIRC it couldn't build aeson for example, because that relied on ghc-prim
2026-02-04 16:10:35 +0100 <mesaoptimizer> any package that depends on ghc-prim cannot be installed via mcabal
2026-02-04 16:10:50 +0100 <mesaoptimizer> also any package that involves networking seems to throw an error
2026-02-04 16:17:34 +0100tydes(~tydes@user/ttydes) ttydes
2026-02-04 16:19:54 +0100petrichor(~jez@user/petrichor) (Quit: ZNC 1.10.1 - https://znc.in)
2026-02-04 16:24:24 +0100 <haskellbridge> <Morj> But can I build using ghc with mcabal?
2026-02-04 16:25:13 +0100Inline(~User@2a02:908:1246:26e0:e780:60f2:d5f3:ea13) (Quit: KVIrc 5.2.6 Quasar http://www.kvirc.net/)
2026-02-04 16:30:59 +0100 <mesaoptimizer> you mean the `--ghc` switch? yeah I have troubles with using cabal for effectively anything. If you have a working cabal setup for your GHC then I guess that works. I don't think that strategy is tenable for someone who wants to use only microhs + mcabal though
2026-02-04 16:31:15 +0100pavonia(~user@user/siracusa) (Ping timeout: 265 seconds)
2026-02-04 16:31:21 +0100 <mesaoptimizer> also I'm unsure what happens when you use the `--ghc` switch with mcabal
2026-02-04 16:32:51 +0100 <haskellbridge> <Morj> I meant building packages using ghc as the compiler and mcabal as the build system (mcabal calling ghc instead of microhs)
2026-02-04 16:33:15 +0100wickedjargon(~user@2605:8d80:5431:33ac:d84d:2363:57fe:412) (Remote host closed the connection)
2026-02-04 16:33:33 +0100fp(~Thunderbi@130.233.70.158) (Ping timeout: 250 seconds)
2026-02-04 16:33:51 +0100 <mesaoptimizer> I see. I think that is what the switch that I recall may have been doing.
2026-02-04 16:34:15 +0100mesaoptimizersighs and reinstalls microhs again to double check
2026-02-04 16:34:38 +0100 <haskellbridge> <Morj> Oh cool. I should install and try it myself (=
2026-02-04 16:35:08 +0100 <mesaoptimizer> its lovely to have a very tiny haskell implementation, to be honest
2026-02-04 16:35:29 +0100 <haskellbridge> <Morj> The worst part is that I get an urge to write one myself too
2026-02-04 16:35:34 +0100 <mesaoptimizer> the obvious downside is that almost the entire hackage system is inaccessible
2026-02-04 16:36:12 +0100 <mesaoptimizer> I think it is a fun idea :)
2026-02-04 16:36:31 +0100 <mesaoptimizer> I've thought about a call-by-push-value lambda calculus compiler for haskell
2026-02-04 16:48:01 +0100Enrico63(~Enrico63@148.252.128.12) (Quit: Client closed)
2026-02-04 16:49:12 +0100lucabtz(~lucabtz@user/lucabtz) (Quit: Lost terminal)
2026-02-04 16:53:44 +0100trickard_trickard
2026-02-04 16:56:31 +0100weary-traveler(~user@user/user363627) (Remote host closed the connection)
2026-02-04 17:00:13 +0100Square(~Square4@user/square) (Ping timeout: 244 seconds)
2026-02-04 17:01:21 +0100edwardkawakens from his long slumber.
2026-02-04 17:01:53 +0100edwardk(sid47016@id-47016.ilkley.irccloud.com) (Changing host)
2026-02-04 17:01:53 +0100edwardk(sid47016@haskell/developer/edwardk) edwardk
2026-02-04 17:04:32 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 17:04:48 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 17:07:59 +0100_JusSx_(~jussx@37.161.247.165) (Ping timeout: 265 seconds)
2026-02-04 17:08:32 +0100 <merijn> edwardk: Like an eldritch horror ready to melt the minds of man?
2026-02-04 17:11:33 +0100petrichor(~jez@user/petrichor) petrichor
2026-02-04 17:11:42 +0100 <tomsmeding> magic_rb: you can't suffice with refcounting for haskell, you get cycles all over the place that you have to collect with some kind of tracing GC
2026-02-04 17:12:10 +0100 <tomsmeding> (python is known for its refcounting system but it has a tracing GC too that runs occasionally, because of cycles)
2026-02-04 17:21:58 +0100Enrico63(~Enrico63@148.252.128.12) Enrico63
2026-02-04 17:29:06 +0100Googulator61(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 17:29:10 +0100Googulator27(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 17:32:43 +0100 <edwardk> merijn: precisely
2026-02-04 17:33:51 +0100Enrico63(~Enrico63@148.252.128.12) (Quit: Client closed)
2026-02-04 17:33:55 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Quit: leaving)
2026-02-04 17:34:15 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) ezzieyguywuf
2026-02-04 17:39:43 +0100bggd_(~bgg@2a01:e0a:fd5:f510:ffc1:9b0f:82de:9e53) (Remote host closed the connection)
2026-02-04 17:40:27 +0100 <merijn> tomsmeding: Additionally that just doesn't jive well with the garbage profile of most haskell programs
2026-02-04 17:40:46 +0100 <merijn> Refcounting is great when you have few mostly long lived big things
2026-02-04 17:40:53 +0100 <merijn> Not for "bazillions of short-lived tiny things"
2026-02-04 17:52:03 +0100 <gentauro> greetings edwardk
2026-02-04 17:53:22 +0100gentaurolucky enough to have experienced edwardk coding-live at Poznan at a river while everybody else were partying <3
2026-02-04 17:53:47 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2026-02-04 17:57:58 +0100 <edwardk> gentauro: =)
2026-02-04 17:58:25 +0100 <edwardk> Most of my coding lately has been in systemverilog
2026-02-04 17:58:28 +0100merijn(~merijn@77.242.116.146) (Ping timeout: 260 seconds)
2026-02-04 17:58:40 +0100 <edwardk> That said, we are starting to use Haskell again at Positron!
2026-02-04 18:00:08 +0100 <edwardk> I think that was an inevitable consequence of hiring johnw and bgamari.
2026-02-04 18:08:47 +0100acidjnk(~acidjnk@p200300d6e700e57835d41376842fa308.dip0.t-ipconnect.de) acidjnk
2026-02-04 18:11:51 +0100humasect(~humasect@dyn-192-249-132-90.nexicom.net) (Quit: Leaving...)
2026-02-04 18:13:11 +0100akegalj(~akegalj@141-136-251-118.dsl.iskon.hr) (Remote host closed the connection)
2026-02-04 18:14:47 +0100 <gentauro> I recall bgamari from working on GHC paid by MS right? (Simon Marlow mentioned this)
2026-02-04 18:15:34 +0100tzh(~tzh@c-76-115-131-146.hsd1.or.comcast.net)
2026-02-04 18:16:58 +0100 <geekosaur> dunno about that but more recently he was working for Well-Typed which I think took on ghc after MSR dropped it?
2026-02-04 18:19:55 +0100 <gentauro> geekosaur: I guess the wording should have been "sponsored" by MS.
2026-02-04 18:20:12 +0100 <gentauro> I guess also since Marlow left FB/Meta, they dropped Haskell right?
2026-02-04 18:21:16 +0100Googulator27(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu) (Quit: Client closed)
2026-02-04 18:21:24 +0100Googulator27(~Googulato@2a01-036d-0106-216f-0081-f2ad-9e0f-9d89.pool6.digikabel.hu)
2026-02-04 18:24:41 +0100 <edwardk> gentauro, geekosaur: correct on both accounts
2026-02-04 18:25:02 +0100 <edwardk> re fb/meta not sure if _all_ haskell inside meta is gone, but a lot of it is
2026-02-04 18:25:11 +0100jmcantrell_(~weechat@user/jmcantrell) jmcantrell
2026-02-04 18:25:17 +0100jmcantrell_jmcantrell
2026-02-04 18:29:40 +0100 <gentauro> edwardk: :'(
2026-02-04 18:30:45 +0100 <gentauro> and when Mathieu Boespflug sold Tweag, both Haskell and OCaml was "somehow" abandoned :'(
2026-02-04 18:30:55 +0100 <gentauro> not good time for FP tbh :-\
2026-02-04 18:31:35 +0100gentaurowhat if we rename the awesome tools to: hAIskell and ocAIml xD
2026-02-04 18:31:43 +0100mniip(mniip@libera/staff-emeritus/mniip) (Ping timeout: 612 seconds)
2026-02-04 18:31:48 +0100gentaurowe would probably down in funding xD
2026-02-04 18:33:48 +0100 <gentauro> down = drown
2026-02-04 18:36:48 +0100mniip(mniip@libera/staff-emeritus/mniip) mniip
2026-02-04 18:46:31 +0100 <int-e> gentAIuro: Be caireful whait you wish for.
2026-02-04 18:49:11 +0100 <gentauro> AInt-e: roger that
2026-02-04 18:54:53 +0100wickedjargon(~user@24.83.46.194) wickedjargon
2026-02-04 18:57:35 +0100ft(~ft@p508db4c0.dip0.t-ipconnect.de) ft
2026-02-04 18:59:24 +0100ljdarj(~Thunderbi@user/ljdarj) ljdarj
2026-02-04 19:02:56 +0100gabiruh(~gabiruh@vps19177.publiccloud.com.br) (Ping timeout: 256 seconds)
2026-02-04 19:03:25 +0100 <apache> tomsmeding: thanks for dealing with that :)
2026-02-04 19:03:38 +0100 <apache> the lycurgus situation I mean
2026-02-04 19:03:44 +0100gabiruh(~gabiruh@vps19177.publiccloud.com.br) gabiruh
2026-02-04 19:04:02 +0100 <apache> gentauro: you don't need to rename ocaML
2026-02-04 19:04:03 +0100 <edwardk> gentauro: i mean, positron is still hiring haskell folks
2026-02-04 19:04:25 +0100 <apache> haskeLLM - fixed
2026-02-04 19:04:54 +0100 <edwardk> haskLLM has a nice ring to it
2026-02-04 19:13:45 +0100divlamir(~divlamir@user/divlamir) (Read error: Connection reset by peer)
2026-02-04 19:14:00 +0100divlamir(~divlamir@user/divlamir) divlamir
2026-02-04 19:14:08 +0100wickedjargon(~user@24.83.46.194) (Remote host closed the connection)
2026-02-04 19:16:58 +0100trickard(~trickard@cpe-61-98-47-163.wireline.com.au) (Read error: Connection reset by peer)
2026-02-04 19:17:11 +0100trickard_(~trickard@cpe-61-98-47-163.wireline.com.au)
2026-02-04 19:27:23 +0100 <gentauro> edwardk: that's pretty nice :)
2026-02-04 19:28:24 +0100 <gentauro> and I'm guessing Galois is also still hiring haskells right?
2026-02-04 19:30:10 +0100 <edwardk> i haven't checked galois' pulse in a while. i'd presume so
2026-02-04 19:30:40 +0100 <edwardk> topos institute is working with aria on some category theory ish stuff, but its all over in rust these days
2026-02-04 19:31:19 +0100 <gentauro> iirc teh LEAN project also hired a few prominent haskellers
2026-02-04 19:32:37 +0100arandombit(~arandombi@user/arandombit) (Remote host closed the connection)
2026-02-04 19:37:20 +0100kilolympus(~kilolympu@vmi1102682.contaboserver.net) kilolympus
2026-02-04 19:43:54 +0100chele(~chele@user/chele) (Remote host closed the connection)