IRCBrowse

2023/02/10

2023-02-10 00:01:15 +0100dcoutts_(~duncan@host81-156-211-188.range81-156.btcentralplus.com)
2023-02-10 00:01:17 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-10 00:03:32 +0100dcoutts(~duncan@host81-156-211-203.range81-156.btcentralplus.com) (Ping timeout: 252 seconds)
2023-02-10 00:03:47 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-02-10 00:05:06 +0100dcoutts__(~duncan@host81-156-211-188.range81-156.btcentralplus.com)
2023-02-10 00:05:44 +0100dcoutts_(~duncan@host81-156-211-188.range81-156.btcentralplus.com) (Ping timeout: 252 seconds)
2023-02-10 00:06:46 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-02-10 00:06:55 +0100dcoutts_(~duncan@host81-156-211-188.range81-156.btcentralplus.com)
2023-02-10 00:09:34 +0100dcoutts__(~duncan@host81-156-211-188.range81-156.btcentralplus.com) (Ping timeout: 260 seconds)
2023-02-10 00:13:24 +0100dcoutts(~duncan@host86-150-41-141.range86-150.btcentralplus.com)
2023-02-10 00:13:48 +0100dcoutts_(~duncan@host81-156-211-188.range81-156.btcentralplus.com) (Ping timeout: 252 seconds)
2023-02-10 00:22:14 +0100dcoutts_(~duncan@host86-151-9-49.range86-151.btcentralplus.com)
2023-02-10 00:23:42 +0100king_gs(~Thunderbi@2806:103e:29:1779:fe89:b45a:2ae8:5941) (Remote host closed the connection)
2023-02-10 00:24:01 +0100king_gs(~Thunderbi@2806:103e:29:1779:fe89:b45a:2ae8:5941)
2023-02-10 00:24:47 +0100dcoutts(~duncan@host86-150-41-141.range86-150.btcentralplus.com) (Ping timeout: 264 seconds)
2023-02-10 00:28:09 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-02-10 00:28:12 +0100cheater_(~Username@user/cheater)
2023-02-10 00:30:00 +0100michalz(~michalz@185.246.204.121) (Remote host closed the connection)
2023-02-10 00:31:02 +0100cheater(~Username@user/cheater) (Ping timeout: 268 seconds)
2023-02-10 00:31:06 +0100cheater_cheater
2023-02-10 00:31:55 +0100AlexZenon(~alzenon@178.34.160.79) (Ping timeout: 248 seconds)
2023-02-10 00:34:07 +0100Alex_test(~al_test@178.34.160.79) (Ping timeout: 268 seconds)
2023-02-10 00:34:59 +0100Square(~adude___@user/square) (Ping timeout: 264 seconds)
2023-02-10 00:37:17 +0100AlexZenon(~alzenon@178.34.160.79)
2023-02-10 00:39:09 +0100Alex_test(~al_test@178.34.160.79)
2023-02-10 00:40:24 +0100dcoutts(~duncan@host86-151-9-49.range86-151.btcentralplus.com)
2023-02-10 00:40:59 +0100dcoutts_(~duncan@host86-151-9-49.range86-151.btcentralplus.com) (Ping timeout: 264 seconds)
2023-02-10 00:51:06 +0100Midjak(~Midjak@82.66.147.146)
2023-02-10 01:00:20 +0100nattiestnate(~nate@202.138.250.11)
2023-02-10 01:01:26 +0100nattiestnate(~nate@202.138.250.11) (Client Quit)
2023-02-10 01:05:30 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 252 seconds)
2023-02-10 01:09:26 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com)
2023-02-10 01:09:31 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-02-10 01:10:27 +0100opticblast(~Thunderbi@172.58.84.5) (Ping timeout: 260 seconds)
2023-02-10 01:15:59 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) ()
2023-02-10 01:18:26 +0100_leo___(~emmanuelu@user/emmanuelux)
2023-02-10 01:21:11 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-10 01:21:40 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Ping timeout: 260 seconds)
2023-02-10 01:24:52 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-10 01:25:29 +0100nattiestnate(~nate@202.138.250.6)
2023-02-10 01:25:31 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 01:37:30 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-10 01:38:44 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-10 01:43:11 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 268 seconds)
2023-02-10 01:54:18 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-02-10 02:05:52 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-02-10 02:05:52 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-02-10 02:05:52 +0100wroathe(~wroathe@user/wroathe)
2023-02-10 02:05:55 +0100dcoutts_(~duncan@host86-167-90-212.range86-167.btcentralplus.com)
2023-02-10 02:07:50 +0100dcoutts(~duncan@host86-151-9-49.range86-151.btcentralplus.com) (Ping timeout: 252 seconds)
2023-02-10 02:10:42 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-02-10 02:11:21 +0100troydm(~troydm@user/troydm)
2023-02-10 02:16:49 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-02-10 02:20:37 +0100werneta(~werneta@137.79.195.231) (Remote host closed the connection)
2023-02-10 02:26:59 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 260 seconds)
2023-02-10 02:31:32 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 02:35:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Ping timeout: 248 seconds)
2023-02-10 02:36:09 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Quit: Leaving)
2023-02-10 02:40:27 +0100_xor(~xor@74.215.182.83) (Quit: brb)
2023-02-10 02:40:28 +0100codaraxis___(~codaraxis@user/codaraxis) (Ping timeout: 252 seconds)
2023-02-10 02:41:41 +0100MQ-17J(~MQ-17J@104.28.216.166) (Ping timeout: 246 seconds)
2023-02-10 02:41:58 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2023-02-10 02:42:13 +0100MQ-17J(~MQ-17J@104.28.216.166)
2023-02-10 02:43:32 +0100irrgit__(~irrgit@89.47.234.74)
2023-02-10 02:44:47 +0100xff0x(~xff0x@2405:6580:b080:900:876a:aa31:e2c4:b726) (Ping timeout: 255 seconds)
2023-02-10 02:45:32 +0100irrgit_(~irrgit@176.113.74.130) (Ping timeout: 265 seconds)
2023-02-10 02:47:17 +0100Sciencentistguy5(~sciencent@hacksoc/ordinary-member)
2023-02-10 02:47:37 +0100thongpv87(~thongpv87@2402:9d80:36f:d082:2f70:3163:c158:b60a)
2023-02-10 02:49:17 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 252 seconds)
2023-02-10 02:49:17 +0100Sciencentistguy5Sciencentistguy
2023-02-10 03:06:44 +0100rettahcay(~kaushikv@c-24-20-37-193.hsd1.or.comcast.net)
2023-02-10 03:12:47 +0100MQ-17J(~MQ-17J@104.28.216.166) (Ping timeout: 248 seconds)
2023-02-10 03:13:19 +0100MQ-17J(~MQ-17J@104.28.216.165)
2023-02-10 03:22:35 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 248 seconds)
2023-02-10 03:24:07 +0100gehmehgeh(~user@user/gehmehgeh)
2023-02-10 03:24:31 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2023-02-10 03:25:05 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-02-10 03:25:23 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-02-10 03:25:47 +0100MQ-17J(~MQ-17J@104.28.216.165) (Quit: Quit)
2023-02-10 03:26:00 +0100MQ-17J(~MQ-17J@104.28.216.165)
2023-02-10 03:38:48 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-02-10 03:40:25 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-02-10 03:44:17 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-10 03:44:24 +0100azimut_(~azimut@gateway/tor-sasl/azimut)
2023-02-10 03:49:12 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca)
2023-02-10 03:50:53 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Remote host closed the connection)
2023-02-10 03:51:38 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca)
2023-02-10 03:57:45 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Remote host closed the connection)
2023-02-10 03:58:26 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca)
2023-02-10 04:02:52 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Remote host closed the connection)
2023-02-10 04:05:29 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb) (Remote host closed the connection)
2023-02-10 04:05:52 +0100 <EvanR> this is kind of interesting. I have one VPS instance with enough memory to install ghc and compile hello world. This hello world binary runs. Then I move the binary to another VPS and it the program runs but says No such file or directory on stderr
2023-02-10 04:06:21 +0100 <EvanR> ldd says "not a dynamic executable"
2023-02-10 04:07:00 +0100 <EvanR> the two versions of the kernel and system software are a few years apart
2023-02-10 04:08:42 +0100 <yushyin> EvanR: try strace -f that binary and filter/grep for 'No such file or directory'
2023-02-10 04:09:09 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 04:09:28 +0100 <int-e> . o O ( maybe it's a wrapper shell script )
2023-02-10 04:10:35 +0100 <int-e> Another thing I've seen is that it's an ELF executable but the corresponding "interpreter" (like /lib64/ld-linx-x86-64.so.2) is missing.
2023-02-10 04:10:48 +0100 <yushyin> -f will trace child processes too
2023-02-10 04:12:01 +0100 <EvanR> lets see if I can move strace over from the other VPS xD
2023-02-10 04:12:32 +0100 <EvanR> /lib64/anything is definitely not there
2023-02-10 04:12:40 +0100 <yushyin> do you have file? file shows the interpreter
2023-02-10 04:12:49 +0100 <sm> are they both 64 bit ?
2023-02-10 04:12:55 +0100 <EvanR> Main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=0x744bc042692450008ac194110400490945cc56e9, not stripped
2023-02-10 04:13:25 +0100 <EvanR> if this is a 32 bit linux that will be wild
2023-02-10 04:13:32 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds)
2023-02-10 04:13:35 +0100 <sm> arch -a
2023-02-10 04:14:08 +0100 <EvanR> uname -m says -686
2023-02-10 04:14:12 +0100 <EvanR> i686
2023-02-10 04:14:14 +0100 <int-e> 32 bit!
2023-02-10 04:14:18 +0100 <int-e> <3
2023-02-10 04:14:21 +0100 <EvanR> damn
2023-02-10 04:14:22 +0100 <yushyin> there you go :D
2023-02-10 04:14:23 +0100 <sm> and by the way you can have a frankenlinux like mine, that's both (32 bit vps upgraded over time to 64 bit software)
2023-02-10 04:14:46 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-02-10 04:15:00 +0100 <EvanR> I was hoping to trick these shitty VPS into doing my haskell bidding without getting dirty and just upgrading them
2023-02-10 04:15:58 +0100 <EvanR> what's this about "dynamically linked (uses shared libs)" and ldd reports "not a dynamic executable"
2023-02-10 04:16:03 +0100 <int-e> well, you can try to find a 32 bit ghc
2023-02-10 04:16:51 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-02-10 04:17:41 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-02-10 04:18:06 +0100 <dminuoso> 04:10:35 int-e | Another thing I've seen is that it's an ELF executable but the corresponding "interpreter" (like /lib64/ld-linx-x86-64.so.2) is missing.
2023-02-10 04:18:12 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-02-10 04:18:19 +0100 <dminuoso> If the elf interpreter is missing, you will just get an ominous "file not found" error.
2023-02-10 04:18:21 +0100 <int-e> EvanR: AFAIK `ldd` works by tracing the actual dynamic linker as it's loading shared objects... that would be the /lib64/ld-linx-x86-64.so.2 thing that you don't have.
2023-02-10 04:18:25 +0100 <dminuoso> Incredibly frustrating and incredibly misleading.
2023-02-10 04:18:48 +0100 <dminuoso> Because as far as your eyes go, the executable you're trying to execute doesnt exist. But it does.
2023-02-10 04:19:13 +0100 <int-e> Yeah, it was quite mystifying the first time I ran into this.
2023-02-10 04:19:33 +0100 <sm> misleading error messages are a tool of satan
2023-02-10 04:19:36 +0100 <int-e> The error is technically accurate of course.
2023-02-10 04:19:52 +0100 <dminuoso> int-e: well it doesnt really matter whether its accurate, its *specified* in `man 2 execve`
2023-02-10 04:19:53 +0100 <EvanR> I knew the exe was not not found because luckily the message is printed differently
2023-02-10 04:20:00 +0100 <dminuoso> ENOENT The file pathname or a script or ELF interpreter does not exist.
2023-02-10 04:20:01 +0100 <int-e> The kernel tries to map that file; it fails because the file does not exist. So that's the error returned...
2023-02-10 04:20:18 +0100 <EvanR> nevermind, it's like the file is not found
2023-02-10 04:20:19 +0100 <dminuoso> int-e: So really, execve cant differentiate between "file pathname does not exist" and "ELF interpreter does not exist"
2023-02-10 04:20:40 +0100 <dminuoso> And I suppose there's no err string set to explain the difference
2023-02-10 04:20:43 +0100 <EvanR> dminuoso, thanks for pointing out the additional nonsense there I didn't even notice
2023-02-10 04:20:56 +0100 <int-e> But it's surprising at first that `exec` reads two files.
2023-02-10 04:21:04 +0100 <EvanR> it's the shell telling me the exe is literally not found lol
2023-02-10 04:21:20 +0100 <dminuoso> well thats dynamically linked executables for you]
2023-02-10 04:21:24 +0100 <int-e> dminuoso: Where would that string be? There's only errno, I think.
2023-02-10 04:21:37 +0100 <dminuoso> int-e: strerror
2023-02-10 04:21:43 +0100 <dminuoso> or no hold on
2023-02-10 04:21:59 +0100 <int-e> (And/or the return value from exec.)
2023-02-10 04:22:23 +0100 <int-e> strerror is just a table of strings corresponding to the standard error return values.
2023-02-10 04:22:34 +0100 <dminuoso> I cant recall the specific C function, but there was one using static storage, where you could extract an additional error message from the most recently errno
2023-02-10 04:23:16 +0100 <dminuoso> Maybe that was glibc specific though
2023-02-10 04:23:19 +0100 <EvanR> errno plus? heh
2023-02-10 04:23:24 +0100 <EvanR> the shadow errno
2023-02-10 04:24:03 +0100 <int-e> Anyway, the error is what it is; it can be explained, but it comes from a detail of loading ELF executables that nobody ordinarily thinks about.
2023-02-10 04:24:23 +0100 <dminuoso> dynamically linked elf executables, though
2023-02-10 04:24:29 +0100 <int-e> yes
2023-02-10 04:24:54 +0100 <int-e> And maybe we should also blame `ldd` for blindly reporting that error.
2023-02-10 04:25:28 +0100 <dminuoso> Well `ldd` would be subject to a TOCTOU condition if it tried to disambiguate
2023-02-10 04:25:39 +0100 <dminuoso> There really isnt any way other than to introduce an additional errno to execve
2023-02-10 04:26:18 +0100 <int-e> Well it could at least try to be more helpful.
2023-02-10 04:26:29 +0100 <dminuoso> (And that can easily spawn philosophical discussions whether an almost-never-wrong behavior that has much improved diagnostics in 99.99% cases isnt flat out better)
2023-02-10 04:26:32 +0100 <EvanR> I'm a bit surprised that this binary is dynamically linked
2023-02-10 04:26:45 +0100 <int-e> Also if you use `ldd` in a scenario where you're subject to races you deserve what you get.
2023-02-10 04:26:46 +0100 <EvanR> did I compile it wrong or
2023-02-10 04:27:00 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 04:27:21 +0100 <EvanR> well, the 64 bit thing is the nail in the coffin but. Didn't ghc usually statically link everything
2023-02-10 04:27:24 +0100 <dminuoso> EvanR: its not dynamically linked, though
2023-02-10 04:27:30 +0100 <dminuoso> EvanR | ldd says "not a dynamic executable
2023-02-10 04:27:33 +0100 <dminuoso> Try `file`
2023-02-10 04:27:52 +0100 <dminuoso> EvanR: yes and no.
2023-02-10 04:28:08 +0100 <EvanR> I pasted the output of file above
2023-02-10 04:28:08 +0100 <dminuoso> EvanR: ghc statically links Haskell modules in, but dynamically links the rest of the ELF
2023-02-10 04:28:12 +0100 <int-e> Have you tried `ldd` on the host where the program works?
2023-02-10 04:28:25 +0100 <dminuoso> EvanR: by default, anyway
2023-02-10 04:29:15 +0100 <EvanR> yes it has 7 dynamically linked libraries
2023-02-10 04:29:33 +0100 <EvanR> and lists the lib64 loader
2023-02-10 04:30:12 +0100 <EvanR> cool
2023-02-10 04:30:45 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca)
2023-02-10 04:31:11 +0100 <EvanR> so next year when I try this again and both linuxes are 64 bit, it will still be a roll of the dice if this shenanigan will work, because of those system libraries
2023-02-10 04:31:28 +0100 <sm> at least you'll have a chance :)
2023-02-10 04:34:23 +0100ft(~ft@p508dbcc4.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-10 04:35:06 +0100 <EvanR> one of those libraries is libgmp btw
2023-02-10 04:35:12 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 04:35:12 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-10 04:35:12 +0100finn_elijaFinnElija
2023-02-10 04:35:17 +0100 <EvanR> isn't this extraneous
2023-02-10 04:35:49 +0100 <EvanR> don't we have a replacement that is pure haskell
2023-02-10 04:36:16 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 04:40:55 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-02-10 04:41:55 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-05-174-88-194-86.dsl.bell.ca) (Ping timeout: 252 seconds)
2023-02-10 04:46:51 +0100mncheck(~mncheck@193.224.205.254) (Ping timeout: 265 seconds)
2023-02-10 04:47:07 +0100varoo(~varoo@117.203.246.41)
2023-02-10 04:47:20 +0100razetime(~Thunderbi@117.193.2.129)
2023-02-10 04:47:44 +0100 <yushyin> link gmp static too, if you like?
2023-02-10 04:48:01 +0100 <c_wraith> there is a pure haskell replacement, but it's a lot slower
2023-02-10 04:48:36 +0100 <c_wraith> and also, switching to it requires a different build of ghc
2023-02-10 04:48:45 +0100 <dminuoso> Note, that libgmp is GPL/LGPL licensed.
2023-02-10 04:48:56 +0100 <dminuoso> So statically linking can have a strong impact on your licensing.
2023-02-10 04:51:17 +0100 <dminuoso> (If you do, you must license your software under GPLv3)
2023-02-10 04:51:22 +0100varoo(~varoo@117.203.246.41) (Ping timeout: 252 seconds)
2023-02-10 04:51:30 +0100 <dminuoso> But integer-simple is a thing, luckily
2023-02-10 04:51:57 +0100varoo(~varoo@2401:4900:5d32:3584:d341:898a:30ee:d5df)
2023-02-10 04:53:39 +0100varoo(~varoo@2401:4900:5d32:3584:d341:898a:30ee:d5df) (Client Quit)
2023-02-10 04:53:47 +0100varoo(~varoo@2401:4900:5d32:3584:d341:898a:30ee:d5df)
2023-02-10 04:54:09 +0100 <int-e> Was a thing; the story has changed to ghc-bignum with the "native" backend.
2023-02-10 04:54:39 +0100 <dminuoso> Uh, I did not get that memo
2023-02-10 04:55:12 +0100 <dminuoso> Okay cool, so that issue is gone completely
2023-02-10 04:55:24 +0100 <dminuoso> https://iohk.io/en/blog/posts/2020/07/28/improving-haskells-big-numbers-support/
2023-02-10 04:55:25 +0100 <yushyin> https://www.gnu.org/licenses/gpl-faq.html#LGPLStaticVsDynamic you just need to provide the objects to relink
2023-02-10 04:56:06 +0100 <dminuoso> Mmm
2023-02-10 04:57:19 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 248 seconds)
2023-02-10 04:58:30 +0100 <dminuoso> yushyin: I guess that can complicate the build process easily.
2023-02-10 04:58:48 +0100 <dminuoso> Unless cabal has some first class support for that use case
2023-02-10 04:59:03 +0100 <dminuoso> But anyhow, given that ghc-bignum is a thing now apparently, I guess that particular point is moot anyway
2023-02-10 04:59:27 +0100td_(~td@i5387090F.versanet.de) (Ping timeout: 248 seconds)
2023-02-10 05:00:14 +0100 <yushyin> just wanted to address a common misconception about LGPL
2023-02-10 05:00:30 +0100 <int-e> dminuoso: The story is largely the same though; the backend is fixed when you build ghc.
2023-02-10 05:01:02 +0100td_(~td@i53870923.versanet.de)
2023-02-10 05:01:38 +0100thegeekinside(~thegeekin@189.180.83.186) (Ping timeout: 252 seconds)
2023-02-10 05:02:59 +0100 <int-e> And GMP is the default. I'm a fan of that because I deal with big integers fairly often. But it is a niche.
2023-02-10 05:04:05 +0100 <yushyin> dminuoso: one could argue that a partly dynamically linked binary is already an object format that can be relinked against gmp ... :P
2023-02-10 05:04:26 +0100 <dminuoso> yushyin: Sure, but we were talking about fully statically linked binaries previously
2023-02-10 05:04:44 +0100gpncarl_(~gpncarl@222.249.231.3)
2023-02-10 05:05:25 +0100 <int-e> OTOH I doubt EvanR is running into that licensing issue at all...
2023-02-10 05:07:18 +0100gpncarl(~gpncarl@210.12.195.6) (Ping timeout: 268 seconds)
2023-02-10 05:07:25 +0100_xor(~xor@74.215.182.83)
2023-02-10 05:20:22 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-02-10 05:23:12 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-10 05:25:06 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-10 05:28:07 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 252 seconds)
2023-02-10 05:28:53 +0100thegeekinside(~thegeekin@189.180.83.186)
2023-02-10 05:30:25 +0100 <dminuoso> Mmm, is there a way to provide a StreamingBody for a servant-server endpoint?
2023-02-10 05:30:35 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 248 seconds)
2023-02-10 05:31:02 +0100 <dminuoso> It seems as if only `SourceT IO` is supported, and that seems a bit limiting
2023-02-10 05:32:00 +0100maerwald(~maerwald@user/maerwald) (Ping timeout: 248 seconds)
2023-02-10 05:33:49 +0100thegeekinside(~thegeekin@189.180.83.186) (Ping timeout: 268 seconds)
2023-02-10 05:43:44 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-02-10 05:46:18 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Read error: Connection reset by peer)
2023-02-10 05:46:37 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10)
2023-02-10 05:52:18 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 05:56:05 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-02-10 06:04:57 +0100EvanR(~EvanR@user/evanr) (Quit: Leaving)
2023-02-10 06:07:52 +0100king_gs(~Thunderbi@2806:103e:29:1779:fe89:b45a:2ae8:5941) (Ping timeout: 252 seconds)
2023-02-10 06:11:03 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net)
2023-02-10 06:16:36 +0100gpncarl(~gpncarl@210.12.195.6)
2023-02-10 06:18:55 +0100gpncarl_(~gpncarl@222.249.231.3) (Ping timeout: 248 seconds)
2023-02-10 06:20:35 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net) (Ping timeout: 264 seconds)
2023-02-10 06:24:23 +0100motherfsck(~motherfsc@user/motherfsck) (Ping timeout: 268 seconds)
2023-02-10 06:41:31 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 248 seconds)
2023-02-10 06:43:28 +0100razetime(~Thunderbi@117.193.2.129) (Ping timeout: 248 seconds)
2023-02-10 06:46:49 +0100razetime(~Thunderbi@117.254.34.69)
2023-02-10 06:48:27 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Remote host closed the connection)
2023-02-10 06:50:13 +0100michalz(~michalz@185.246.204.107)
2023-02-10 06:54:21 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net)
2023-02-10 06:56:53 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl)
2023-02-10 06:58:33 +0100thongpv87(~thongpv87@2402:9d80:36f:d082:2f70:3163:c158:b60a) (Read error: Connection reset by peer)
2023-02-10 06:58:46 +0100Intel8086(~Intel8086@user/Intel8086)
2023-02-10 06:59:25 +0100varoo(~varoo@2401:4900:5d32:3584:d341:898a:30ee:d5df) (Ping timeout: 260 seconds)
2023-02-10 06:59:48 +0100Intel8086(~Intel8086@user/Intel8086) (Max SendQ exceeded)
2023-02-10 07:00:17 +0100Intel8086(~Intel8086@user/Intel8086)
2023-02-10 07:00:18 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-02-10 07:00:34 +0100sefidel(~sefidel@user/sefidel)
2023-02-10 07:08:08 +0100Intel8086(~Intel8086@user/Intel8086) (Quit: Quit)
2023-02-10 07:15:12 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl) (Remote host closed the connection)
2023-02-10 07:15:31 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl)
2023-02-10 07:19:12 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-02-10 07:24:39 +0100king_gs(~Thunderbi@187.201.41.239)
2023-02-10 07:27:16 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-02-10 07:31:05 +0100rettahcay(~kaushikv@c-24-20-37-193.hsd1.or.comcast.net) ()
2023-02-10 07:32:51 +0100takuan_dozo(~takuan@178-116-218-225.access.telenet.be)
2023-02-10 07:32:51 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Read error: Connection reset by peer)
2023-02-10 07:34:32 +0100theproffesor(~theproffe@2601:282:8880:20::4a63)
2023-02-10 07:34:32 +0100theproffesor(~theproffe@2601:282:8880:20::4a63) (Changing host)
2023-02-10 07:34:32 +0100theproffesor(~theproffe@user/theproffesor)
2023-02-10 07:44:15 +0100razetime(~Thunderbi@117.254.34.69) (Ping timeout: 248 seconds)
2023-02-10 07:51:10 +0100gpncarl(~gpncarl@210.12.195.6) (Read error: Connection reset by peer)
2023-02-10 07:51:34 +0100gpncarl(~gpncarl@210.12.195.6)
2023-02-10 07:53:16 +0100echoreply(~echoreply@45.32.163.16) (Quit: WeeChat 2.8)
2023-02-10 07:54:07 +0100varoo(~varoo@117.203.246.41)
2023-02-10 07:54:33 +0100echoreply(~echoreply@45.32.163.16)
2023-02-10 07:57:47 +0100ddellacosta(~ddellacos@146.70.165.139) (Ping timeout: 248 seconds)
2023-02-10 08:01:27 +0100tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Quit: Leaving)
2023-02-10 08:01:43 +0100troydm(~troydm@user/troydm) (Ping timeout: 252 seconds)
2023-02-10 08:03:38 +0100tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2023-02-10 08:07:54 +0100kritzefitz(~kritzefit@debian/kritzefitz) (Ping timeout: 260 seconds)
2023-02-10 08:08:07 +0100kritzefitz(~kritzefit@debian/kritzefitz)
2023-02-10 08:12:57 +0100king_gs(~Thunderbi@187.201.41.239) (Read error: Connection reset by peer)
2023-02-10 08:13:16 +0100king_gs(~Thunderbi@2806:103e:29:1779:b5f0:ff23:4044:f15)
2023-02-10 08:14:20 +0100 <dminuoso> Mmm, it occured to me that I could use Raw and then just work with StreamingBody directly
2023-02-10 08:14:51 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 248 seconds)
2023-02-10 08:16:36 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1)
2023-02-10 08:20:12 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-02-10 08:20:35 +0100gpncarl(~gpncarl@210.12.195.6) (Quit: WeeChat 3.8)
2023-02-10 08:25:03 +0100varoo_(~varoo@2a09:bac1:36e0:5f70::ca:21)
2023-02-10 08:25:24 +0100Sauvin(~sauvin@user/Sauvin) (Ping timeout: 260 seconds)
2023-02-10 08:27:47 +0100varoo__(~varoo@117.203.246.41)
2023-02-10 08:28:19 +0100varoo(~varoo@117.203.246.41) (Ping timeout: 260 seconds)
2023-02-10 08:30:26 +0100varoo__(~varoo@117.203.246.41) (Client Quit)
2023-02-10 08:30:52 +0100varoo_(~varoo@2a09:bac1:36e0:5f70::ca:21) (Ping timeout: 252 seconds)
2023-02-10 08:31:44 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net) (Ping timeout: 252 seconds)
2023-02-10 08:35:04 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl)
2023-02-10 08:40:26 +0100marek443214321(~marek@46.204.100.225.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 246 seconds)
2023-02-10 08:41:49 +0100Sauvin(~sauvin@user/Sauvin)
2023-02-10 08:44:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-10 08:45:15 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1) (Ping timeout: 248 seconds)
2023-02-10 08:47:35 +0100razetime(~Thunderbi@117.254.34.69)
2023-02-10 08:54:03 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-02-10 08:54:44 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-02-10 08:54:56 +0100mncheck(~mncheck@193.224.205.254)
2023-02-10 08:55:19 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:7c13:bc21:ab83:3404)
2023-02-10 08:59:36 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Read error: Connection reset by peer)
2023-02-10 08:59:55 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-02-10 09:02:12 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-10 09:03:57 +0100thongpv87(~thongpv87@2402:9d80:36d:9eb8:c69f:d737:e064:f8f1)
2023-02-10 09:10:17 +0100phma(phma@2001:5b0:211b:c068:2b96:30a1:aa3d:6ccd) (Read error: Connection reset by peer)
2023-02-10 09:15:28 +0100phma(~phma@2001:5b0:212a:e8d8:156a:28d7:9925:258)
2023-02-10 09:16:20 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-02-10 09:20:08 +0100codaraxis___(~codaraxis@user/codaraxis)
2023-02-10 09:21:18 +0100chele(~chele@user/chele)
2023-02-10 09:26:30 +0100razetime(~Thunderbi@117.254.34.69) (Remote host closed the connection)
2023-02-10 09:28:12 +0100zeenk(~zeenk@2a02:2f04:a214:1e00::7fe)
2023-02-10 09:32:40 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-10 09:34:21 +0100trev(~trev@user/trev)
2023-02-10 09:36:14 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:7c13:bc21:ab83:3404) (Quit: WeeChat 2.8)
2023-02-10 09:39:32 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de) (Quit: leaving)
2023-02-10 09:47:04 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-02-10 09:51:16 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-02-10 09:51:39 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32)
2023-02-10 09:55:50 +0100maroloccio(~marolocci@90.167.55.241)
2023-02-10 10:02:46 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-10 10:05:02 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl)
2023-02-10 10:06:09 +0100vpan(~0@212.117.1.172)
2023-02-10 10:08:00 +0100_leo___(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-02-10 10:08:02 +0100Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: The Lounge - https://thelounge.chat)
2023-02-10 10:08:42 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-02-10 10:08:46 +0100_leo___(~emmanuelu@user/emmanuelux)
2023-02-10 10:08:48 +0100Katarushisu(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-02-10 10:10:49 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-10 10:15:38 +0100MajorBiscuit(~MajorBisc@145.94.153.3)
2023-02-10 10:16:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 10:18:40 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-10 10:21:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Ping timeout: 248 seconds)
2023-02-10 10:23:04 +0100 <jackdk> dminuoso: here is an example of using servant to forward a stream from S3; it might be useful for you? https://github.com/aveltras/amazonka-servant-streaming/blob/main/src/Main.hs
2023-02-10 10:23:57 +0100 <jackdk> Note the lack of resourceT in `oneStepHandler` so that the connection is closed only after production of the response completes.
2023-02-10 10:26:27 +0100king_gs(~Thunderbi@2806:103e:29:1779:b5f0:ff23:4044:f15) (Remote host closed the connection)
2023-02-10 10:26:46 +0100king_gs(~Thunderbi@2806:103e:29:1779:b5f0:ff23:4044:f15)
2023-02-10 10:28:03 +0100remexre_(~remexre@mail.sift.net)
2023-02-10 10:28:18 +0100remexre(~remexre@user/remexre) (Read error: Connection reset by peer)
2023-02-10 10:28:55 +0100remexre_remexre
2023-02-10 10:29:56 +0100 <dminuoso> jackdk: Mmm, yeah so I would like my `mason` builder to directly write into the socket, avoiding intermediate allocations.
2023-02-10 10:31:21 +0100 <dminuoso> But its still an interesting example given the streaming S3 forwarding
2023-02-10 10:31:55 +0100 <freeside> when I define a type with arguments, e.g. data MyType a b c = Constructor a b c, what is the technical term for those arguments? are they "free type parameters"?
2023-02-10 10:32:37 +0100 <dminuoso> freeside: You could call them type parameters (in the defining position), and type arguments in the type application position.
2023-02-10 10:33:00 +0100 <dminuoso> One way to think about parameterized type constructors is as injective type functions
2023-02-10 10:33:42 +0100 <freeside> Gotcha. I'm trying to communicate that as I go up the layers of my library stack, they start out free, and by the time we get close to the application, they're fixed, i.e. type MyConcreteType = MyType String Int State
2023-02-10 10:34:24 +0100 <dminuoso> Another way of phrasing "free" and "fixed" is polymorphic/monomorphic
2023-02-10 10:35:56 +0100 <freeside> ah, yes
2023-02-10 10:37:56 +0100 <dminuoso> freeside: An additional benefit is that using `polymorphic` and `monomorphic` avoids needing to talk about type parameters/arguments altogether here. :p
2023-02-10 10:38:14 +0100 <freeside> yes, that makes so much sense, thank you.
2023-02-10 10:39:24 +0100 <dminuoso> jackdk: Im almost tempted to just use SourceIO after all, the main thing with Raw is that I dont know how to use my custom handler monad inside
2023-02-10 10:39:45 +0100 <dminuoso> (because instead of the endpoint running as `MyMonad Application`, its `Tagged MyMonad Application` instead
2023-02-10 10:41:29 +0100thongpv87(~thongpv87@2402:9d80:36d:9eb8:c69f:d737:e064:f8f1) (Read error: Connection reset by peer)
2023-02-10 10:45:05 +0100 <freeside> So, ok, conceptually I have a tree -- the root is polymorphic, and as the paramters get fixed, the tree proceeds toward leaves which are entirely monomorphic. Is there some term for this tree? In OOP land one talks about class hierarchies ... here do we talk about type hierarchies?
2023-02-10 10:45:47 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-02-10 10:47:23 +0100 <turlando> Is that just for the sake of taxonomic pleasure or do you need to impose type constraints?
2023-02-10 10:47:54 +0100cfricke(~cfricke@user/cfricke)
2023-02-10 10:48:11 +0100king_gs(~Thunderbi@2806:103e:29:1779:b5f0:ff23:4044:f15) (Ping timeout: 264 seconds)
2023-02-10 10:49:00 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-10 10:49:24 +0100ubert(~Thunderbi@p200300ecdf13012ec893c5f497fd9467.dip0.t-ipconnect.de)
2023-02-10 10:50:50 +0100 <freeside> i'm not thinking about constraints here, just narrowing of `type MyNum a` to `MyNum Float` vs `MyNum Int`
2023-02-10 10:55:13 +0100 <dminuoso> freeside: In previous discussions about related topics in #haskell we just said that "the leaves of the program are kept polymorphic"
2023-02-10 10:56:50 +0100 <[exa]> freeside: you want to use the tree to actually model the class hierarchy?
2023-02-10 10:56:55 +0100 <dminuoso> Usually such discussions involved final tagless encoding
2023-02-10 10:57:25 +0100 <dminuoso> an example of which is writing leaf code as mtl polymorphic
2023-02-10 10:57:38 +0100 <dminuoso> One of the ideas is that the more general the type, the less its implementation can do.
2023-02-10 10:57:48 +0100 <dminuoso> So if its maximally polymorphic, its extremely constrained
2023-02-10 10:58:22 +0100 <dminuoso> which helps reason about its behavior, in case of final tagless encoding, the idea is that keeping the code polymorphic means the only usable effects are those described in the constraints
2023-02-10 10:58:29 +0100tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Ping timeout: 256 seconds)
2023-02-10 10:59:03 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-02-10 11:00:51 +0100mei(~mei@user/mei)
2023-02-10 11:02:31 +0100codaraxis___(~codaraxis@user/codaraxis) (Ping timeout: 252 seconds)
2023-02-10 11:02:58 +0100skidisagrees about referring to them in terms of "polymorphic/monomorphic"
2023-02-10 11:03:23 +0100tcard(~tcard@229.12.156.220.rev.vmobile.jp)
2023-02-10 11:03:31 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de)
2023-02-10 11:03:34 +0100 <ski> freeside : it's say `MyNum Int' is more specific than, is a specialization of, `MyNum a'
2023-02-10 11:03:54 +0100 <dminuoso> ski: How is `MyNum Int` not more monomorphic than `MyNum a`?
2023-02-10 11:04:07 +0100 <ski> (but `MyNum' (nor `MyNum a') is definitely not polymorphic)
2023-02-10 11:04:25 +0100 <dminuoso> Mmm
2023-02-10 11:04:38 +0100 <dminuoso> because its terms that are polymorphic, not the types themselves?
2023-02-10 11:04:52 +0100 <dminuoso> i.e. a polymorphic type would be a higher kinded type like `Const (t :: k) a`?
2023-02-10 11:05:09 +0100 <dminuoso> oh `Const t (a :: k)` of course
2023-02-10 11:05:33 +0100 <ski> if you say `foo :: MyNum a -> ..a..' (by which i mean `foo :: forall a. MyNum a -> ..a..', which is how it will be interpreted, in most contexts), and `bar :: MyNum Int -> ...', then `foo' is (more) polymorphic than the (monomorphic) `bar'
2023-02-10 11:05:44 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 252 seconds)
2023-02-10 11:05:46 +0100 <ski> yes, dminuoso
2023-02-10 11:06:36 +0100 <ski> you can say `MyNum' is a parameterized, or parametric, type. or, `MyNum' is a type function. or, `MuNum a' is type that's parameterized over `a'
2023-02-10 11:07:04 +0100 <dminuoso> Okay thats a fine distinction, but I think largely irrelant to the intent of the discussion.
2023-02-10 11:07:37 +0100irrgit_(~irrgit@176.113.74.130)
2023-02-10 11:07:38 +0100tcard(~tcard@229.12.156.220.rev.vmobile.jp) (Read error: Connection reset by peer)
2023-02-10 11:07:43 +0100 <dminuoso> Saying that "the leaves of the program (which we could think of as the expressions/bindings) are polymorphic" seems fine even with that distinction
2023-02-10 11:08:11 +0100 <dminuoso> Regardless, you're right I should have been more careful with my wording here.
2023-02-10 11:08:20 +0100 <ski> (fwiw, i also dislike the term "higher kinded type". what that's about is really higher-order types. like e.g. `ReaderT', having kind `* -> (* -> *) -> * -> *', being a type function that takes another type function as argument/parameter, hence `ReaderT' being a higher-order type)
2023-02-10 11:08:29 +0100 <dminuoso> Hjeh
2023-02-10 11:08:36 +0100 <dminuoso> I was debating whether to correct myself and say `polykinded` here.
2023-02-10 11:08:39 +0100AWizzArd(~code@gehrels.uberspace.de) (Remote host closed the connection)
2023-02-10 11:08:48 +0100 <dminuoso> Did realize that higher kinded was not appropriate here
2023-02-10 11:09:14 +0100 <ski> not sure i get the tree and leaves thing
2023-02-10 11:09:53 +0100 <ski> freeside said "the root is polymorphic, and as the paramters get fixed, the tree proceeds toward leaves which are entirely monomorphic" .. which seems to go in the opposite direction from what you're talking about (re leaves) ?
2023-02-10 11:10:27 +0100 <dminuoso> If we imagine a program to be a tree in which nodes represent (top-level) bindings, and edges represent uses of bindings (i.e. given `bar = 1; foo = bar` then `foo` uses `bar`, and bar would be a leaf)
2023-02-10 11:10:52 +0100irrgit__(~irrgit@89.47.234.74) (Ping timeout: 252 seconds)
2023-02-10 11:10:53 +0100 <dminuoso> Think a final tagless encoding of an effect system, in which all your surrounding modules are written polymorphic
2023-02-10 11:11:01 +0100 <dminuoso> and you instantiate them at concrete types along the spine of your program
2023-02-10 11:11:53 +0100 <ski> my take on what freeside said was that they were thinking about writing some "core" operations, which tend to be polymorphic in type parameters like `a', re `MyNum a'. and then, when writing parts of the code that's closer to the application-specific details, those parameters would tend to get more specialized, like maybe `MyNum (Complex a)' and `MyNum Int', and we we're approaching "leaves" in that sense,
2023-02-10 11:11:56 +0100 <dminuoso> So much of your server implementation might be written `getUser :: (HasDb m, HasLogger m) => Uid -> m User`, where almost never you refer to a specific monad
2023-02-10 11:11:59 +0100 <ski> the operations which we write then would tend to be monomorphic
2023-02-10 11:12:14 +0100mmhat(~mmh@p200300f1c7108bb6ee086bfffe095315.dip0.t-ipconnect.de)
2023-02-10 11:12:25 +0100 <Hecate> HELLO
2023-02-10 11:12:34 +0100 <ski> ehlo, Hecate
2023-02-10 11:12:41 +0100 <Hecate> I noticed we're talking about effects
2023-02-10 11:13:08 +0100 <Hecate> I'd like to advise against polymorphic monads, they cannot be optimised whilst keeping reasonable compilation times
2023-02-10 11:13:27 +0100 <Hecate> once you're past "toy project" size, it's a real burden at run-time
2023-02-10 11:13:27 +0100 <ski> dminuoso : yea, i think that makes sense
2023-02-10 11:14:04 +0100 <ski> (just not sure it's the same kind of situation that freeside had in mind .. and if it was, you two did have opposite terminologies wrt "leaf" vs. "root")
2023-02-10 11:14:44 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-10 11:17:10 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-10 11:19:32 +0100 <ski> freeside : in `data MyType a b c = ..a..b..c..', i'd call the `a',`b',`c' (to the left of the `=') (formal) type parameters. (if in the body, to the right of `=', you say e.g. `Map a (Either b c)', then `a',`b',`c' (as well as `Either a b') are actual type parameters (to `Map' and `Either') there)
2023-02-10 11:19:47 +0100mmhat(~mmh@p200300f1c7108bb6ee086bfffe095315.dip0.t-ipconnect.de) (Quit: WeeChat 3.8)
2023-02-10 11:20:21 +0100maroloccio(~marolocci@90.167.55.241) (Quit: WeeChat 3.7.1)
2023-02-10 11:21:36 +0100 <ski> freeside : i think "fixed" is okay. i might also say "specialized" or "specific". where by "specialize" i mean replace some type variables, in a type expression, by other type expressions (usually not all of the replacements being type variables)
2023-02-10 11:21:44 +0100 <dminuoso> jackdk: but oh well, I think my best bet is to just use a lazy bytestring and OctetStream, thanks for your help.
2023-02-10 11:23:29 +0100Guest67(~Guest67@159.153.150.4)
2023-02-10 11:26:08 +0100 <ski> freeside : however, `Either c c' could be said to be a specialization of `Either a b'. since the former insists the two alternatives have the same type, while the latter allows them to not have the same type. however, i wouldn't exactly try to draw a type hieararchy of this, in a similar way to subtyping hierarchies in OO. e.g. because `Either a b' and `Either a c' are not the same type, although they're
2023-02-10 11:26:14 +0100 <ski> equivalent (up to renaming type variables). but often, you're in a situation where you have some type variables in scope, that you can't just arbitrarily rename (without impacting other adjacent code). the type `b -> Either a b' is not equivalent to the type `b -> Either a c'
2023-02-10 11:27:11 +0100 <freeside> mmm. The tree I have in mind is conceptual, I'm not trying to deal with an actual Data.Tree. I just meant, a sort of hierarchy, where the levels of the hierarchy denote increasing fixedness of the type arguments
2023-02-10 11:27:26 +0100 <freeside> until eventually all the a b c params have been nailed down to Float Int String.
2023-02-10 11:27:45 +0100glguy(~glguy@libera/staff-emeritus/glguy) (Ping timeout: 260 seconds)
2023-02-10 11:27:58 +0100glguy_(~glguy@libera/staff-emeritus/glguy)
2023-02-10 11:28:46 +0100 <ski> (so, it doesn't make sense exactly, to try to put the "very non-specific" type `a' at one extreme end of a type hierarchy, and to put progressively more specific types, like `Maybe b',`Map b (Either b c)',`Map Int (Either Int c)', when going in the opposite direction. you can't just consider a type expression on its own, you also have to take into account which type variables are allowed to be used in it.
2023-02-10 11:28:52 +0100 <ski> you can't directly compare two type expressions that allow different type variables)
2023-02-10 11:29:07 +0100 <freeside> the "node" of that "tree" which has been fixed to Float Int String could be considered a "sibling" to a node which is fixed to Float Int Text.Text
2023-02-10 11:29:08 +0100 <ski> yea, i get what you're thinking (i think), freeside
2023-02-10 11:29:28 +0100 <freeside> :D
2023-02-10 11:29:44 +0100 <ski> i'm just saying that it will not turn out quite the same way as a subtyping hierarchy with `Object'/`Any' being most non-specific
2023-02-10 11:30:14 +0100 <ski> having type parameters (type variables) do add complications to that picture
2023-02-10 11:30:51 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-02-10 11:33:49 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-02-10 11:34:16 +0100 <ski> .. i'm probably not really explaining the issue with the hierarchy quite well (meaning that i probably don't quite understand the issue well enough, on an explicit level. i guess one could say i have a "gut feeling" for the kind of trouble you get, but can't satisfactorially put my finger on it)
2023-02-10 11:34:19 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-02-10 11:35:27 +0100Inst__Inst
2023-02-10 11:36:13 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Quit: Leaving)
2023-02-10 11:38:33 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-02-10 11:38:33 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-10 11:38:48 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Client Quit)
2023-02-10 11:40:18 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-02-10 11:47:46 +0100glguy_(~glguy@libera/staff-emeritus/glguy) (Ping timeout: 252 seconds)
2023-02-10 11:48:18 +0100glguy(~glguy@libera/staff-emeritus/glguy)
2023-02-10 11:54:55 +0100codaraxis__(~codaraxis@user/codaraxis) (Ping timeout: 260 seconds)
2023-02-10 11:57:57 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1)
2023-02-10 11:58:31 +0100__monty__(~toonn@user/toonn)
2023-02-10 11:58:39 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-02-10 11:59:55 +0100pernzs(~pernzs@101.175.168.100)
2023-02-10 12:04:10 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 268 seconds)
2023-02-10 12:04:23 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1) (Ping timeout: 264 seconds)
2023-02-10 12:07:39 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-02-10 12:08:58 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-02-10 12:09:48 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-10 12:10:38 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 252 seconds)
2023-02-10 12:16:13 +0100troydm(~troydm@user/troydm)
2023-02-10 12:16:18 +0100acidjnk(~acidjnk@p200300d6e715c449a5c1454d82f25d58.dip0.t-ipconnect.de)
2023-02-10 12:20:33 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de)
2023-02-10 12:23:33 +0100maerwald(~maerwald@mail.hasufell.de)
2023-02-10 12:24:59 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-02-10 12:25:45 +0100MQ-17J(~MQ-17J@104.28.216.165) (Ping timeout: 268 seconds)
2023-02-10 12:25:58 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de)
2023-02-10 12:26:36 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-02-10 12:27:22 +0100trev(~trev@user/trev)
2023-02-10 12:27:51 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-02-10 12:30:00 +0100maerwald(~maerwald@mail.hasufell.de) (Changing host)
2023-02-10 12:30:00 +0100maerwald(~maerwald@user/maerwald)
2023-02-10 12:31:54 +0100yaroot(~yaroot@p2790051-ipngn7801souka.saitama.ocn.ne.jp) (Ping timeout: 252 seconds)
2023-02-10 12:32:36 +0100yaroot(~yaroot@p3431218-ipngn9301souka.saitama.ocn.ne.jp)
2023-02-10 12:38:57 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-10 12:43:56 +0100npmania(~Thunderbi@45.8.223.213)
2023-02-10 12:50:28 +0100pernzs(~pernzs@101.175.168.100) (Ping timeout: 260 seconds)
2023-02-10 12:53:22 +0100thongpv(~thongpv87@2402:9d80:32e:8f1:5f45:6f5f:527a:b486)
2023-02-10 12:55:39 +0100pernzs(~pernzs@101.175.168.100)
2023-02-10 12:58:32 +0100tcard(~tcard@p5309141-ipxg23901hodogaya.kanagawa.ocn.ne.jp)
2023-02-10 13:03:24 +0100paulpaul1076(~textual@95-29-5-53.broadband.corbina.ru) (Quit: Textual IRC Client: www.textualapp.com)
2023-02-10 13:03:26 +0100tcard_(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2023-02-10 13:03:53 +0100tcard(~tcard@p5309141-ipxg23901hodogaya.kanagawa.ocn.ne.jp) (Ping timeout: 252 seconds)
2023-02-10 13:09:49 +0100shapr(~user@net-5-88-238-17.cust.vodafonedsl.it)
2023-02-10 13:10:16 +0100 <shapr> Does anyone have fourmolu working as an emacs save-hook? I'm using --no-cabal right now, but I'd prefer some way to point it to the cabal file if anyone has that
2023-02-10 13:10:23 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-02-10 13:12:38 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:c52:e2ce:11c8:93da)
2023-02-10 13:15:39 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 248 seconds)
2023-02-10 13:17:17 +0100CiaoSen(~Jura@p200300c9570460002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-02-10 13:21:38 +0100freeside(~mengwong@151.192.86.187)
2023-02-10 13:22:44 +0100xff0x(~xff0x@2405:6580:b080:900:161d:e8bd:9253:e61c)
2023-02-10 13:26:39 +0100freeside(~mengwong@151.192.86.187) (Ping timeout: 248 seconds)
2023-02-10 13:31:23 +0100pernzs(~pernzs@101.175.168.100) (Quit: Client closed)
2023-02-10 13:42:20 +0100anpad(~pandeyan@user/anpad) (Quit: ZNC 1.8.2 - https://znc.in)
2023-02-10 13:42:35 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1)
2023-02-10 13:43:43 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-02-10 13:44:45 +0100anpad(~pandeyan@user/anpad)
2023-02-10 13:46:03 +0100pernzs(~pernzs@101.175.168.100)
2023-02-10 13:46:51 +0100freeside(~mengwong@151.192.86.187)
2023-02-10 13:51:07 +0100freeside(~mengwong@151.192.86.187) (Ping timeout: 260 seconds)
2023-02-10 13:51:20 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-02-10 13:53:05 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-02-10 13:54:47 +0100gurkenglas(~gurkengla@dynamic-046-114-000-101.46.114.pool.telefonica.de) (Ping timeout: 246 seconds)
2023-02-10 14:00:22 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-02-10 14:07:28 +0100pernzs(~pernzs@101.175.168.100) (Ping timeout: 260 seconds)
2023-02-10 14:13:25 +0100mncheck(~mncheck@193.224.205.254) (Remote host closed the connection)
2023-02-10 14:13:36 +0100mncheck(~mncheck@193.224.205.254)
2023-02-10 14:29:04 +0100sammelweis(~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 248 seconds)
2023-02-10 14:33:46 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-02-10 14:34:03 +0100acidjnk(~acidjnk@p200300d6e715c449a5c1454d82f25d58.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-02-10 14:36:59 +0100_leo___(~emmanuelu@user/emmanuelux) (Ping timeout: 260 seconds)
2023-02-10 14:42:19 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-02-10 14:42:28 +0100npmania1(~Thunderbi@45.8.223.243)
2023-02-10 14:42:33 +0100npmania(~Thunderbi@45.8.223.213) (Ping timeout: 255 seconds)
2023-02-10 14:42:33 +0100npmania1npmania
2023-02-10 14:43:31 +0100notzmv(~zmv@user/notzmv)
2023-02-10 14:44:14 +0100AWizzArd(~code@user/awizzard)
2023-02-10 14:46:42 +0100freeside(~mengwong@151.192.86.187)
2023-02-10 14:51:19 +0100freeside(~mengwong@151.192.86.187) (Ping timeout: 260 seconds)
2023-02-10 14:52:40 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-02-10 14:54:24 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-02-10 14:55:30 +0100jero98772(~jero98772@2800:484:1d80:d8ce:9815:cfda:3661:17bb)
2023-02-10 14:55:50 +0100npmania1(~Thunderbi@45.8.223.228)
2023-02-10 14:57:11 +0100Cale(~cale@cpe80d04ade0a03-cm80d04ade0a01.cpe.net.cable.rogers.com) (Ping timeout: 264 seconds)
2023-02-10 14:57:20 +0100yoneda(~mike@193.206.102.122) (Quit: leaving)
2023-02-10 14:57:47 +0100npmania(~Thunderbi@45.8.223.243) (Ping timeout: 264 seconds)
2023-02-10 14:57:48 +0100npmania1npmania
2023-02-10 14:58:15 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-02-10 14:59:46 +0100rburkholder(~blurb@96.45.2.121) (Remote host closed the connection)
2023-02-10 15:01:06 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-02-10 15:01:15 +0100Cale(~cale@cpe80d04ade0a03-cm80d04ade0a01.cpe.net.cable.rogers.com)
2023-02-10 15:01:32 +0100azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-10 15:03:17 +0100Guest|81(~Guest|81@208.84.107.234)
2023-02-10 15:05:38 +0100Guest|81(~Guest|81@208.84.107.234) (Client Quit)
2023-02-10 15:06:40 +0100jinsun(~jinsun@user/jinsun) (Read error: Connection reset by peer)
2023-02-10 15:06:56 +0100ddellacosta(~ddellacos@146.70.166.139)
2023-02-10 15:07:31 +0100kurbus(~kurbus@user/kurbus)
2023-02-10 15:08:20 +0100jinsun(~jinsun@user/jinsun)
2023-02-10 15:12:26 +0100Midjak(~Midjak@82.66.147.146)
2023-02-10 15:14:27 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-02-10 15:14:41 +0100sefidel(~sefidel@user/sefidel)
2023-02-10 15:14:55 +0100npmania(~Thunderbi@45.8.223.228) (Ping timeout: 248 seconds)
2023-02-10 15:15:10 +0100npmania(~Thunderbi@121.128.227.178)
2023-02-10 15:15:34 +0100vpan(~0@212.117.1.172) (Remote host closed the connection)
2023-02-10 15:16:18 +0100 <shapr> does anyone use fourmolu with emacs?
2023-02-10 15:16:36 +0100 <shapr> I'm using it with haskell-stylish, but I'd like to know of other options
2023-02-10 15:17:53 +0100freeside(~mengwong@151.192.86.187)
2023-02-10 15:19:38 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-02-10 15:20:45 +0100npmania1(~Thunderbi@45.8.223.198)
2023-02-10 15:21:13 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 15:21:54 +0100npmania(~Thunderbi@121.128.227.178) (Ping timeout: 260 seconds)
2023-02-10 15:21:54 +0100npmania1npmania
2023-02-10 15:22:02 +0100freeside(~mengwong@151.192.86.187) (Ping timeout: 252 seconds)
2023-02-10 15:23:37 +0100thegeekinside(~thegeekin@189.180.83.186)
2023-02-10 15:25:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Ping timeout: 255 seconds)
2023-02-10 15:26:17 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 255 seconds)
2023-02-10 15:28:27 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-02-10 15:28:29 +0100rettahcay(~kaushikv@c-24-20-37-193.hsd1.or.comcast.net)
2023-02-10 15:29:33 +0100rettahcay(~kaushikv@c-24-20-37-193.hsd1.or.comcast.net) ()
2023-02-10 15:34:13 +0100npmania1(~Thunderbi@45.8.223.243)
2023-02-10 15:34:51 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-10 15:36:18 +0100npmania(~Thunderbi@45.8.223.198) (Ping timeout: 268 seconds)
2023-02-10 15:36:19 +0100npmania1npmania
2023-02-10 15:36:29 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 15:40:09 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-10 15:42:55 +0100vpan(~0@212.117.1.172)
2023-02-10 15:55:28 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1) (Ping timeout: 248 seconds)
2023-02-10 15:56:51 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-02-10 15:58:03 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2023-02-10 15:59:43 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-10 16:00:59 +0100 <shapr> This channel sure is quiet in the european daytime
2023-02-10 16:01:34 +0100megaTherion(~therion@unix.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-02-10 16:01:55 +0100 <merijn> shapr: It varies *a lot* :p
2023-02-10 16:02:16 +0100 <merijn> Sometimes it's super busy, but today's quiet, yeah
2023-02-10 16:03:14 +0100megaTherion(~therion@unix.io)
2023-02-10 16:03:15 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-02-10 16:03:52 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-02-10 16:04:35 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-02-10 16:04:36 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-02-10 16:05:25 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 16:06:45 +0100 <[exa]> depends a lot, e.g. now it's european friday and as far as I can see no one really cares here. :D
2023-02-10 16:10:42 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-02-10 16:12:49 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-02-10 16:15:35 +0100ft(~ft@p3e9bc443.dip0.t-ipconnect.de)
2023-02-10 16:15:41 +0100sefidel(~sefidel@user/sefidel)
2023-02-10 16:17:15 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-10 16:19:31 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 260 seconds)
2023-02-10 16:22:56 +0100 <vpan> it seems the loss in migration from freenode to libera was significant, around 40% by now I suppose, as I recall the count to be over 1k. But I would guess the majority of active people are still here, so the majority of the people who fell off the train were lurkers and it should not affect the activity much.
2023-02-10 16:23:53 +0100 <Inst_> how pissed off do you guys get if I describe Haskell education as "teaching C by starting with pointers?"
2023-02-10 16:24:16 +0100 <Hecate> shapr: it's because we work during european day time :p
2023-02-10 16:24:24 +0100 <geekosaur> if you;ve a better idea, we're all ears
2023-02-10 16:25:11 +0100 <shapr> Hecate: c'est bien
2023-02-10 16:25:36 +0100 <Hecate> :p
2023-02-10 16:26:10 +0100 <Inst_> geekosaur: I just got hit by a ton of toxicity from FP Discord
2023-02-10 16:26:34 +0100 <Inst_> the point with me is more, start with IO, start with stuff like this tutorial, which I think produces something fun and interesting
2023-02-10 16:26:44 +0100 <Inst_> https://andrew.gibiansky.com/blog/haskell/haskell-gloss/
2023-02-10 16:26:45 +0100 <geekosaur> this is part of why I don't hang out there
2023-02-10 16:27:20 +0100 <Inst_> start by teaching not FP, but imperative shell, functional core, and understand how to work a combination of imperative shell, functional core
2023-02-10 16:27:54 +0100 <Inst_> and teach libs
2023-02-10 16:34:29 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 16:34:54 +0100mc47(~mc47@xmonad/TheMC47)
2023-02-10 16:35:23 +0100 <Inst_> i guess you disagree vehemently, but have resolved not to be toxic?
2023-02-10 16:35:32 +0100Inst_Inst
2023-02-10 16:35:44 +0100 <ski> how to teach functional core, without teaching FP ?
2023-02-10 16:35:45 +0100 <Inst> sorry, just on edge
2023-02-10 16:35:54 +0100 <ski> no worry
2023-02-10 16:35:55 +0100 <Inst> teach FP as the way to actually process the data
2023-02-10 16:36:42 +0100 <Inst> get data, process data, do something impure with the data
2023-02-10 16:36:54 +0100 <ski> there is no impure, in Haskell
2023-02-10 16:37:00 +0100 <Inst> side-effecting
2023-02-10 16:37:06 +0100 <ski> no side-effects
2023-02-10 16:37:14 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-02-10 16:37:33 +0100 <Inst> a function that produces an IO action with the data, with the IO action being connected to main
2023-02-10 16:37:40 +0100 <ski> that's effects
2023-02-10 16:37:44 +0100 <dminuoso> Mmm, after the previous discussion, Im beginning to dislike the entire notion of `side effects`
2023-02-10 16:38:29 +0100 <ski> i'm not too clear what you place in the terms "FP" vs. "functional core"
2023-02-10 16:39:21 +0100 <[exa]> is this discussion the side effect of side effects?
2023-02-10 16:39:22 +0100skiidly wonders in which sense dminuoso means that
2023-02-10 16:40:07 +0100 <Inst> In this context, it's more, FP is taught through, pattern matching, higher order functions, processing data immutably
2023-02-10 16:40:38 +0100 <Inst> functional core is just FP, but the notion is that we still use an imperative shell to make the FP part useful
2023-02-10 16:41:28 +0100 <Inst> maybe use Py or mutable references as a way to demonstrate how FP creates more concise and maintainable code by comparison
2023-02-10 16:42:06 +0100 <ski> pattern-matching is of fundamental importance, to be able to define and use custom `data' types. higher-order functions are quite useful as well, for abstracting out more complicated code, and separating concerns
2023-02-10 16:42:47 +0100 <ski> ("Py" ?)
2023-02-10 16:43:21 +0100 <merijn> Inst: I mean, the entire point of IO is that it *isn't* impure
2023-02-10 16:43:25 +0100 <Inst> w/e, sorry, FP discord is just annoyed because this is like one of my hobby courses
2023-02-10 16:43:32 +0100 <Inst> *hobbyhorses
2023-02-10 16:43:35 +0100 <Inst> and I beat it once in a while
2023-02-10 16:43:47 +0100 <Inst> Python
2023-02-10 16:44:06 +0100 <ski> no issue with contemplating things, Inst
2023-02-10 16:44:41 +0100 <Hecate> no Inst, FP Discord is annoyed because you're an expert beginner who is permanently confused (totally acceptable) but who is also poisoning the understanding of Haskell for new beginners. As such it is extremely draining to clean up behind you because you leave most newcomers confused as hell on topics in which you're also extremely confused about
2023-02-10 16:44:59 +0100shaprhugs Inst
2023-02-10 16:45:17 +0100 <shapr> Inst: be nice as you can and things will work out
2023-02-10 16:45:19 +0100shaprhugs Hecate
2023-02-10 16:45:29 +0100 <Inst> I don't think I message that much in #Haskell-beginners these days
2023-02-10 16:45:40 +0100skihugs shapr
2023-02-10 16:45:59 +0100shaprhugs ski
2023-02-10 16:46:02 +0100 <shapr> howdy! Long time no see
2023-02-10 16:47:06 +0100Sgeo(~Sgeo@user/sgeo)
2023-02-10 16:47:43 +0100 <Inst> Or is it annoying that I've been teaching a friend TVar or some other mutvar to start out with?
2023-02-10 16:47:43 +0100ski's been obsessing a bit over definitions and patterns, lately
2023-02-10 16:49:03 +0100 <ski> annoying, how, Inst ?
2023-02-10 16:49:14 +0100 <Inst> offensive, rather.
2023-02-10 16:49:20 +0100 <ski> i dunno
2023-02-10 16:49:32 +0100 <ski> might perhaps be confusing to them, after a while
2023-02-10 16:49:45 +0100 <Inst> ehhh, point is that it's there, not that you should use it
2023-02-10 16:50:14 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-10 16:50:28 +0100 <shapr> ski: what kind of patterns?
2023-02-10 16:51:14 +0100 <ski> i'd typically expect someone learning about `TVar's to already know about higher-order code, and about `data' types. perhaps one could do things in a different order .. but i'm not sure how useful that'd be
2023-02-10 16:51:27 +0100 <Inst> ehhh, it's more like an experiment
2023-02-10 16:51:48 +0100 <Inst> but, as i've mentioned, via Hecate's friend Julie Moronuki:
2023-02-10 16:52:35 +0100 <Inst> actually, TVar comes in pretty late
2023-02-10 16:52:39 +0100 <Inst> https://typeclasses.com/phrasebook/mutable-references
2023-02-10 16:52:59 +0100 <ski> shapr : as in pattern-matching. i've been pondering various extensions to patterns (and how that interacts with defining equations) .. some of them, i'm not sure how practically useful they'd be .. but it's fun to ponder different variants
2023-02-10 16:53:35 +0100 <Inst> for_ comes in after enum ranges, using the REPL, and case expressions
2023-02-10 16:55:22 +0100 <ski> shapr : `let'-patterns, lambda-patterns, absurd-patterns, definiendum-patterns
2023-02-10 16:58:09 +0100 <ski> shapr : part of the point is that i want a "logical" (as opposed to "algorithmic") static semantics, a set of inference rules where, if you erase the proof terms, you get reasonable-looking logical rules
2023-02-10 16:59:47 +0100theproffesor(~theproffe@user/theproffesor) (Ping timeout: 255 seconds)
2023-02-10 17:00:27 +0100 <ski> `f x (\(x + y) -> g y) = g' is an example of a defining equation, using some of my extended pattern ideas
2023-02-10 17:01:34 +0100 <ski> Inst : `for_' is higher-order, so you'd better cover higher-order operations, before `for_' .. unless you intend to treat it ad hoc, without explaining how it works
2023-02-10 17:04:29 +0100 <Inst> ski: ever considered using empty backtick as a ditto mark in a sequence of pattern matching?
2023-02-10 17:04:32 +0100 <ski> (`f :: Num a => a -> (a -> b) -> (a -> b)' is the inferred type for that example)
2023-02-10 17:05:00 +0100 <ski> ditto mark, how do you mean ?
2023-02-10 17:05:20 +0100 <Inst> "same as last element above"
2023-02-10 17:05:25 +0100 <Inst> top-level pattern matching
2023-02-10 17:05:38 +0100 <Inst> `` -> "same as corresponding element in previous top-level pattern match"
2023-02-10 17:05:46 +0100 <ski> you mean, same as the corresponding position in the previous defining equation ?
2023-02-10 17:05:54 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 17:05:54 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-10 17:05:54 +0100finn_elijaFinnElija
2023-02-10 17:06:11 +0100 <Inst> yeah, and i eventually just wandered off to using case-based pattern matching instead of top-level pattern matching for most cases
2023-02-10 17:06:35 +0100 <ski> if that corresponding pattern mentioned variables, then this "ditto mark" would bring variables into scope, in the current defining equation, without mentioning them explicitly (no explicit binding site) .. which i don't really like
2023-02-10 17:08:37 +0100 <ski> (no, i don't really like `RecordWildCards', `MkFoo {..}')
2023-02-10 17:09:00 +0100 <Inst> i guess case + tuple is just better for that in general
2023-02-10 17:09:41 +0100 <Inst> and tbh, for me personally, hof was hard only because of the name
2023-02-10 17:10:07 +0100 <Inst> "higher-order function", sounds fancy. reality: "it's just a function that takes another function as an argument"
2023-02-10 17:10:39 +0100troydm(~troydm@user/troydm) (Ping timeout: 268 seconds)
2023-02-10 17:10:48 +0100 <Inst> if you introduce . or even $ early, you're teaching hof
2023-02-10 17:11:13 +0100 <Inst> so if you do a getline example with $, you're already teaching hof
2023-02-10 17:11:25 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-02-10 17:12:45 +0100ski. o O ( `\cases' <https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/lambda_case.html>,<https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0302-cases.rst> )
2023-02-10 17:12:46 +0100 <mauke> yes (except I'd do map first)
2023-02-10 17:12:59 +0100dcoutts(~duncan@host86-167-90-212.range86-167.btcentralplus.com)
2023-02-10 17:13:55 +0100dcoutts_(~duncan@host86-167-90-212.range86-167.btcentralplus.com) (Ping timeout: 252 seconds)
2023-02-10 17:14:25 +0100 <Inst> map only makes sense if you teach pattern matching on lists, as well as recursion
2023-02-10 17:14:31 +0100 <Inst> . and $ gets you an introduction to the concept
2023-02-10 17:15:08 +0100acidjnk(~acidjnk@p200300d6e715c445102af608dfe0cdc6.dip0.t-ipconnect.de)
2023-02-10 17:16:29 +0100 <ski> strictly speaking, one would often say that a function that produces another function as output is also higher-order. however, if such a function is simply curried, doesn't do any interesting / non-trivial work, before receiving all the parameters (which is what you get with the usual curried style convention in Haskell), we tend to not count that as "serious higher-order"
2023-02-10 17:16:30 +0100 <mauke> nah, I can just start with lists and map
2023-02-10 17:16:52 +0100 <Inst> yeah, some kid who hates Haskell, and I'm basically thinking of him a lot, I'm trying to help him out
2023-02-10 17:17:05 +0100 <ski> who ?
2023-02-10 17:17:08 +0100 <Inst> I don't think he even got lists and list processing yet
2023-02-10 17:17:14 +0100 <mauke> similarly, I can teach while loops in C without explaining condition flags or relative branching
2023-02-10 17:17:57 +0100 <ski> for lists, one could choose to teach list comprehensions first
2023-02-10 17:18:08 +0100 <Inst> do people actually like list comprehensions?
2023-02-10 17:18:16 +0100 <ski> sometimes they're handy
2023-02-10 17:18:36 +0100cheater(~Username@user/cheater)
2023-02-10 17:18:44 +0100 <ski> (there's even a `MonadComphrehensions' extension)
2023-02-10 17:19:08 +0100 <Inst> I know, someone taught me a really cool trick with [myTerm | booleanExpression]
2023-02-10 17:19:29 +0100 <mauke> list do > monad comprehensions
2023-02-10 17:19:37 +0100 <ski> possibly failing patterns in generators can also be useful
2023-02-10 17:23:43 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de)
2023-02-10 17:24:36 +0100 <Inst> Also, I'm curious, what's your take on effect systems, or rather, the definition of such?
2023-02-10 17:25:55 +0100 <Inst> I consider ALL languages to have an effect system; languages without an IO type have a nullary / unary effect system (every effect is allowed everywhere), Haskell in prelude has a unary / binary effect system (IO vs non-IO), then you have more complex effect systems
2023-02-10 17:27:18 +0100 <ski> `Maybe' expresses an effect
2023-02-10 17:27:23 +0100 <Inst> so does List, I guess
2023-02-10 17:27:30 +0100[exa]sees IO vs non-IO ----> [its_the_same_thing_meme.gif]
2023-02-10 17:31:24 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 260 seconds)
2023-02-10 17:33:01 +0100 <[exa]> Inst: btw did you try to consider the actual computation as an effect? As in "production of more organized results in the representation within the computer". The view you're using here seems to me very biased towards distinguishing between "internal program thinking" and "externally visible stuff", yet this precise distinction is quite unrealistic
2023-02-10 17:34:47 +0100 <Inst> Why is it unrealistic?
2023-02-10 17:35:06 +0100 <Inst> (also, even with pure, non-effecting code, space and time are still effects)
2023-02-10 17:35:24 +0100 <Inst> actual side effects?
2023-02-10 17:35:28 +0100 <[exa]> yep, and many other things are effects
2023-02-10 17:35:47 +0100 <[exa]> is the microsonics that the CPUs do a "communication" effect?
2023-02-10 17:35:59 +0100 <[exa]> (there's a paper about breaking RSA with microphones somewhere)
2023-02-10 17:36:14 +0100 <[exa]> are the page requests from the operating system an effect?
2023-02-10 17:36:17 +0100 <Inst> But why is it unrealistic?
2023-02-10 17:37:30 +0100 <[exa]> because literally everyone can argue that everyone other has the distinction line wrong
2023-02-10 17:37:43 +0100 <[exa]> it's completely under-defined
2023-02-10 17:38:22 +0100 <Inst> Thanks, [exa]. I got trolled for a while by some guy who went on for ages about the definition of effect systems.
2023-02-10 17:38:55 +0100 <Inst> And got really upset when I explained my definition of effect system, and was aiming to call me always wrong.
2023-02-10 17:39:10 +0100 <Inst> Ended up blocking him.
2023-02-10 17:39:10 +0100 <[exa]> yeah, that's the basic outcome of the property being under-defined
2023-02-10 17:39:41 +0100AWizzArd(~code@user/awizzard) (Quit: Lost terminal)
2023-02-10 17:41:29 +0100 <[exa]> in haskell, the usual logical system that allows us to model stuff reliably (and without misinterpretation/handwaving) has no side effects, and the wiggly line of deciding what is a side effect and what's not is delegated to the description of the runtime which interprets the code
2023-02-10 17:42:29 +0100 <Inst> The problem with starting with a language that's pure is that it's hard to understand what impurity means without the contrast.
2023-02-10 17:42:34 +0100mastarija(~mastarija@2a05:4f46:e03:6000:4eb2:bb7f:1ccf:de1a)
2023-02-10 17:42:55 +0100 <[exa]> luckily there's no impurity, right? :D
2023-02-10 17:44:41 +0100ubert(~Thunderbi@p200300ecdf13012ec893c5f497fd9467.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-02-10 17:45:21 +0100razetime(~Thunderbi@117.254.34.69)
2023-02-10 17:45:48 +0100 <[exa]> btw I'm completely opposed to the impurity view even with imperative languages; in C you're writing down a list of instructions for the machine which is being interpreted by the machine, and what the machine does is similar to what it does with haskell (except for completely logic-irrelevant differences like the way you organize subroutines)
2023-02-10 17:46:47 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-02-10 17:47:34 +0100 <Inst> i suppose a PC becoming inoperable due to overclocking is an effect, no?
2023-02-10 17:48:20 +0100 <[exa]> as in, it's the nice transformation of instructions into other instructions that the C language is about, not the execution and checking for whether the phenomena affect other phenomena
2023-02-10 17:48:56 +0100 <[exa]> not really, it's how the machine works
2023-02-10 17:49:09 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 17:49:32 +0100 <ski> what matters is what reasoning (including refactoring) you can do, at the level of the language
2023-02-10 17:50:15 +0100 <Inst> i'm not sure, is this impure in Haskell? One, reading from a file, which breaks pure functions to an extent because the file is not under the program's control and can have any set of data
2023-02-10 17:50:24 +0100 <Inst> Two, a function that takes a mutable reference as an argument?
2023-02-10 17:50:34 +0100[exa]needs to disappear shortly but will be back
2023-02-10 17:51:00 +0100 <ski> imho, neither
2023-02-10 17:51:25 +0100 <Inst> it's more like concealed effects
2023-02-10 17:51:30 +0100 <Inst> or for that matter, System.Random
2023-02-10 17:52:54 +0100 <ski> how does `hGetLine :: Handle -> IO String' "break pure functions to an extent" ?
2023-02-10 17:53:16 +0100 <ski> or `readIORef :: IORef a -> IO a', for that matter
2023-02-10 17:53:26 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 17:54:26 +0100 <Inst> the logic is more, the input is deterministic, it's always the same handle or the same IORef, but the underlying value of the IORef can vary, as can what's contained within the handle
2023-02-10 17:54:31 +0100 <ski> .. however, if you want to talk about "pure", then perhaps you should read
2023-02-10 17:54:36 +0100 <ski> @where purely-functional
2023-02-10 17:54:36 +0100 <lambdabot> "What is a Purely Functional Language?" by Amr Sabry in 1993-01 at <https://www.cs.indiana.edu/~sabry/papers/purelyFunctional.ps>
2023-02-10 17:54:44 +0100 <Inst> https://wiki.haskell.org/Pure
2023-02-10 17:55:53 +0100 <ski> "but the underlying value of the IORef can vary, as can what's contained within the handle" -- conceptually, a value of type `IORef a' does *not* "contain" a value of type `a'. similarly, a value of type `Handle' does not contain `Char's
2023-02-10 17:57:03 +0100 <Inst> IORef a contains a pointer and has the type of the value being referenced, iirc
2023-02-10 17:57:35 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 17:57:56 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl)
2023-02-10 17:58:59 +0100MajorBiscuit(~MajorBisc@145.94.153.3) (Ping timeout: 264 seconds)
2023-02-10 17:59:13 +0100 <ski> (note that two `IORef a's can be compared for equality, without requiring equality on `a'. it's `instance Eq (IORef a)', not `instance Eq a => Eq (IORef a)'. conceptually, you can think of an `IORef a' as a bit like an `Int' that you use to index inside a `Map Int Blah' or `IntMap Blah' .. except that `IORef a' is parameterized by the "target type" `a', and the corresponding "map" is "heterogenous" .. a bit
2023-02-10 17:59:19 +0100 <ski> comparable to `DMap IORef Identity')
2023-02-10 17:59:22 +0100 <ski> @hackage dependent-map
2023-02-10 17:59:22 +0100 <lambdabot> https://hackage.haskell.org/package/dependent-map
2023-02-10 18:00:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-10 18:01:04 +0100vpan(~0@212.117.1.172) (Quit: Leaving.)
2023-02-10 18:01:08 +0100npmania1(~Thunderbi@121.128.227.178)
2023-02-10 18:01:55 +0100 <Inst> is it wrong to think of IORef as just a pointer to a mutable?
2023-02-10 18:02:11 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 260 seconds)
2023-02-10 18:02:39 +0100 <ski> i'm not sure what you mean by the latter
2023-02-10 18:02:55 +0100npmania(~Thunderbi@45.8.223.243) (Ping timeout: 256 seconds)
2023-02-10 18:02:55 +0100npmania1npmania
2023-02-10 18:03:07 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Remote host closed the connection)
2023-02-10 18:03:32 +0100 <ski> is an `Int' that you use to index inside an `IntMap Blah'/`Map Int Blah', or an `Array Int Blah', or a `Vector Blah' .. is such an `Int' a pointer ?
2023-02-10 18:04:23 +0100 <Inst> mutable or pointer?
2023-02-10 18:04:27 +0100 <ski> if you thread successive versions of such an `IntMap Blah'/.. through a computation .. is that a mutable structure ?
2023-02-10 18:04:30 +0100 <ski> Inst : both
2023-02-10 18:05:04 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-02-10 18:06:06 +0100slack1256(~slack1256@186.11.102.104)
2023-02-10 18:06:07 +0100 <Inst> that is to say, IORef is fundamentally immutable in its own way
2023-02-10 18:06:08 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-10 18:06:48 +0100 <Inst> the IORef always points to the same thing
2023-02-10 18:06:56 +0100 <Inst> but the thing can change
2023-02-10 18:09:09 +0100 <ski> > let fact n = factTimes n 1 where factTimes _ 0 = 0; factTimes 0 acc = acc; factTimes n acc = factTimes (n-1) (acc * n) in fact 5 -- does this computation express something that is mutable ?
2023-02-10 18:09:11 +0100 <lambdabot> 120
2023-02-10 18:09:47 +0100 <Inst> it's iterative because of the accumulating parameter
2023-02-10 18:10:09 +0100 <ski> does the accumulator express something mutable ?
2023-02-10 18:10:51 +0100 <Inst> no, it doesn't, it doesn't mutate, but acts as though it does through passing the output of the argument around, modified
2023-02-10 18:11:11 +0100 <ski> i would say it does. i would also answer my two previous questions with "yes"
2023-02-10 18:11:43 +0100 <Inst> that's an interesting take, because people go "Haskell has no mutation" to newbies
2023-02-10 18:11:45 +0100 <ski> it may or may not be *implemented* in terms of update-in-place .. but that's not the issue here
2023-02-10 18:13:23 +0100 <Inst> why claim that acc is mutable, then?
2023-02-10 18:13:26 +0100 <ski> the succession of versions of the accumulator expresses, de facto, a mutable concept, in my mind
2023-02-10 18:13:29 +0100 <dminuoso> ski: So side effects usually relate to some observable state modification outside of the perspecftive you are considering. Either these side-effects are irrelevant, in which even giving it a name is relatively meaningless (i.e. do we ever care about the heat generation of a computation as a side effect?), or they are irrelevant, in which your perspective is probably ill tuned.
2023-02-10 18:13:35 +0100 <gurkenglas> Free theorems let me encode some laws by cleverly picking my types. Can I do this for laws whose forall quantifier ranges over the values of a type instead of over all types? I'm hoping for "a:A B such that for any (f :: forall b. A b -> A b), f a == a"
2023-02-10 18:14:13 +0100 <c_wraith> gurkenglas: you would need dependent types to express that
2023-02-10 18:14:16 +0100 <ski> if you want to, you could say this is an encoding of something being mutable
2023-02-10 18:14:36 +0100 <Inst> yes, it is, it's an attempt to translate a for loop
2023-02-10 18:15:02 +0100 <ski> Inst : a single `acc' is not mutable. the succession of them (all being different variables, dynamically speaking), does express something mutable
2023-02-10 18:15:15 +0100 <Inst> well, is shadowing mutation?
2023-02-10 18:16:15 +0100 <Inst> > main = do {let x = 1; x <- x + 1; x <- x + 1; print x}
2023-02-10 18:16:17 +0100 <lambdabot> <hint>:1:6: error: parse error on input ‘=’
2023-02-10 18:16:29 +0100 <dminuoso> ski: that is, there arent really any "outside" state variables. If you care about them, they are definitely not "outside", and if you dont, its irrelevant.
2023-02-10 18:16:32 +0100 <ski> i'm not sure how shadowing is relevant. there's no shadowing in the example, except from the `n' in `fact' being shadowed by `n' in the last defining equation for `factTimes' .. but we could rename the former to say `n0', with no change in behaviour
2023-02-10 18:16:40 +0100 <Inst> > do {let x = 1; x <- x + 1; x <- x + 1; print x}
2023-02-10 18:16:42 +0100 <lambdabot> <hint>:1:18: error:
2023-02-10 18:16:42 +0100 <lambdabot> parse error on input ‘<-’
2023-02-10 18:16:42 +0100 <lambdabot> Perhaps this statement should be within a 'do' block?
2023-02-10 18:17:05 +0100 <Inst> > do ; let x = 1; x <- x+1; x <- x +1; print x
2023-02-10 18:17:07 +0100 <lambdabot> <hint>:1:19: error:
2023-02-10 18:17:07 +0100 <lambdabot> parse error on input ‘<-’
2023-02-10 18:17:07 +0100 <lambdabot> Perhaps this statement should be within a 'do' block?
2023-02-10 18:17:15 +0100 <Inst> !!! >:(
2023-02-10 18:17:18 +0100 <geekosaur> you need extra braces around the let bindings
2023-02-10 18:17:25 +0100 <geekosaur> because let uses layout as well
2023-02-10 18:17:43 +0100 <geekosaur> > do {let {x = 1}; x <- x + 1; x <- x + 1; print x}
2023-02-10 18:17:44 +0100 <lambdabot> error:
2023-02-10 18:17:44 +0100 <lambdabot> • No instance for (Num (IO (IO ()))) arising from a use of ‘+’
2023-02-10 18:17:44 +0100 <lambdabot> • In a stmt of a 'do' block: x <- x + 1
2023-02-10 18:17:48 +0100 <Inst> > do {{let x = 1}; x <- x + 1; x <- x + 1; print x}
2023-02-10 18:17:49 +0100 <lambdabot> <hint>:1:5: error: parse error on input ‘{’
2023-02-10 18:17:53 +0100 <ski> dminuoso : itym s/or they are irrelevant/or they are relevant/ ?
2023-02-10 18:18:28 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:c52:e2ce:11c8:93da) (Quit: WeeChat 2.8)
2023-02-10 18:18:32 +0100skiwould not limit "side-effects" to state, fwiw
2023-02-10 18:18:43 +0100 <dminuoso> I meant `state` in a very general sense
2023-02-10 18:18:45 +0100 <geekosaur> and, as I showed, you have a type error because x is pure and therefore has the wrong type for `<-`
2023-02-10 18:18:48 +0100 <dminuoso> The state of the world, if you want.
2023-02-10 18:18:58 +0100 <Inst> > u = do {let {x = 1}; x <- pure $ x + 1; x <- pure $ x + 1; print x}
2023-02-10 18:18:59 +0100 <lambdabot> <hint>:1:3: error: parse error on input ‘=’
2023-02-10 18:18:59 +0100 <Inst> whoops
2023-02-10 18:19:42 +0100 <ski> i consider exceptions, nondeterminism, continuations, as other examples, that are not state
2023-02-10 18:19:49 +0100 <Inst> > do {let {x = 1}; x <- pure $ x + 1; x <- pure $ x + 1; print x}
2023-02-10 18:19:50 +0100 <lambdabot> <IO ()>
2023-02-10 18:20:05 +0100 <Inst> > do {let {x = 1}; x <- pure $ x + 1; x <- pure $ x + 1; pure x}
2023-02-10 18:20:06 +0100 <lambdabot> error:
2023-02-10 18:20:06 +0100 <lambdabot> • Ambiguous type variable ‘m0’ arising from a use of ‘show_M627921637676...
2023-02-10 18:20:06 +0100 <lambdabot> prevents the constraint ‘(Show (m0 Integer))’ from being solved.
2023-02-10 18:20:32 +0100 <tomsmeding> % do {let {x = 1}; x <- pure $ x + 1; x <- pure $ x + 1; print x}
2023-02-10 18:20:32 +0100 <yahb2> 3
2023-02-10 18:20:32 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-02-10 18:20:33 +0100 <Inst> i'll stop spamming
2023-02-10 18:22:06 +0100razetime(~Thunderbi@117.254.34.69) (Remote host closed the connection)
2023-02-10 18:22:11 +0100 <ski> dminuoso : i'm not really following what you're trying to get across, sorry
2023-02-10 18:22:18 +0100 <dminuoso> ski: never mind, then.
2023-02-10 18:24:25 +0100 <ski> trying to grasp what you meant by "outside of the perspecftive you are considering"
2023-02-10 18:25:16 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-02-10 18:25:27 +0100 <ski> gurkenglas : hm, are you talking about operations whose type `forall'-quantifies not a type, but a value ?
2023-02-10 18:27:12 +0100 <gurkenglas> ski: the operation f up there quantifies over types, but the equation f a == a quantifies over the possible values of f
2023-02-10 18:27:36 +0100 <ski> would `b' and `B' be values, rather than types, there ?
2023-02-10 18:27:50 +0100 <gurkenglas> both are types
2023-02-10 18:28:02 +0100o-90(~o-90@gateway/tor-sasl/o-90)
2023-02-10 18:28:12 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net)
2023-02-10 18:28:23 +0100accord(uid568320@id-568320.hampstead.irccloud.com)
2023-02-10 18:28:26 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 246 seconds)
2023-02-10 18:29:05 +0100o-90(~o-90@gateway/tor-sasl/o-90) (Client Quit)
2023-02-10 18:29:23 +0100 <ski> which would be the operation (whose type) the free theorem was derived from ?
2023-02-10 18:29:31 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 18:31:36 +0100 <gurkenglas> I see whence the confusion, now - I had only stated the theorem I'd want, not the clever type that would get it
2023-02-10 18:31:51 +0100waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-02-10 18:31:56 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 246 seconds)
2023-02-10 18:33:48 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 252 seconds)
2023-02-10 18:33:57 +0100 <ski> any `f' of the appropriate type has `a' as a fixed point .. apparently
2023-02-10 18:35:17 +0100 <Inst_> ...
2023-02-10 18:35:46 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 265 seconds)
2023-02-10 18:35:51 +0100 <gurkenglas> yes, that's what i want to encode. i don't have the solution yet, i was hoping Haskell lets me do this and someone knows how. I'm scribbling.
2023-02-10 18:36:59 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-02-10 18:39:32 +0100 <Inst_> ...
2023-02-10 18:40:28 +0100ski. o O ( "Internalizing Parametricity" by Guilhem Moulin in 2016 at <https://core.ac.uk/display/70616322> )
2023-02-10 18:40:44 +0100zeenk(~zeenk@2a02:2f04:a214:1e00::7fe) (Quit: Konversation terminated!)
2023-02-10 18:44:26 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-02-10 18:45:38 +0100asscrackbandit(~user@eth-west-pareq2-46-193-2-167.wb.wifirst.net) (Ping timeout: 246 seconds)
2023-02-10 18:48:37 +0100cheater_(~Username@user/cheater)
2023-02-10 18:51:39 +0100cheater(~Username@user/cheater) (Ping timeout: 248 seconds)
2023-02-10 18:51:42 +0100 <shapr> I like list comprehensions.
2023-02-10 18:51:43 +0100cheater_cheater
2023-02-10 18:52:31 +0100 <geekosaur> I started out not liking them much but have warmed to them a bit
2023-02-10 18:53:11 +0100pja(~pja@2a02:8010:6098:0:e65f:1ff:fe1f:660f) (Read error: Connection reset by peer)
2023-02-10 18:53:24 +0100npmania1(~Thunderbi@45.8.223.243)
2023-02-10 18:54:07 +0100npmania(~Thunderbi@121.128.227.178) (Ping timeout: 248 seconds)
2023-02-10 18:54:08 +0100npmania1npmania
2023-02-10 18:56:24 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 18:57:16 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 252 seconds)
2023-02-10 18:57:27 +0100pja(~pja@2a02:8010:6098:0:e65f:1ff:fe1f:660f)
2023-02-10 18:59:02 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-02-10 19:00:06 +0100kurbus(~kurbus@user/kurbus)
2023-02-10 19:01:47 +0100shapr(~user@net-5-88-238-17.cust.vodafonedsl.it) (Ping timeout: 248 seconds)
2023-02-10 19:05:37 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl)
2023-02-10 19:06:53 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 19:11:31 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 268 seconds)
2023-02-10 19:22:15 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-02-10 19:23:03 +0100kurbus(~kurbus@user/kurbus) (Ping timeout: 260 seconds)
2023-02-10 19:23:11 +0100king_gs(~Thunderbi@187.201.41.239)
2023-02-10 19:28:31 +0100 <c_wraith> I read a paper a while back that used sequence_ with a list comprehension instead of mapM_ . I couldn't wrap my head around that particular choice
2023-02-10 19:32:10 +0100 <glguy> c_wraith: I don't know the example, but list comprehensions can be a much clearer way to write the list transformation than a lambda, especially with guards, patterns, and multiple bindings
2023-02-10 19:32:28 +0100 <c_wraith> glguy: there was a do block inside the list comprehension. :P
2023-02-10 19:33:20 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-02-10 19:33:32 +0100king_gs(~Thunderbi@187.201.41.239) (Quit: king_gs)
2023-02-10 19:39:59 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-02-10 19:43:05 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-02-10 19:43:56 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-02-10 19:47:27 +0100npmania(~Thunderbi@45.8.223.243) (Quit: npmania)
2023-02-10 19:48:27 +0100thongpv(~thongpv87@2402:9d80:32e:8f1:5f45:6f5f:527a:b486) (Read error: Connection reset by peer)
2023-02-10 19:49:04 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-02-10 19:50:20 +0100Sinbad(~Sinbad@user/sinbad)
2023-02-10 19:50:45 +0100 <ddellacosta> So I'm trying to write some integration tests which start up my main process in an Async, I send messages to it via TQueue, then test some state to see if it behaved as expected. However, I realized my folly when the test returned with a failure before anything in the threaded process could run. Whoops. I'm thinking now that I could pass in another TQueue and send a message _from_ the main thread
2023-02-10 19:50:46 +0100 <ddellacosta> once it's gotten to the end of its event loop (at which point I can check assertions), but this feels like an ugly hack just to support tests. Are there better approaches?
2023-02-10 19:51:20 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-02-10 19:51:45 +0100 <ski> c_wraith : obviously ought to have used `MonadComprehensions', like `sequence_ [[foo a b | _ <- putStrLn "foo",a <- getLine,b <- readLn] | x <- xs,y <- ys]' ;)
2023-02-10 19:51:57 +0100Feuermagier_(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-02-10 19:53:22 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-02-10 19:53:44 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 252 seconds)
2023-02-10 19:56:00 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 265 seconds)
2023-02-10 19:58:09 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-02-10 19:59:08 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Ping timeout: 246 seconds)
2023-02-10 19:59:13 +0100mjs2600_(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2023-02-10 20:04:23 +0100mechap(~mechap@user/mechap)
2023-02-10 20:05:24 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 260 seconds)
2023-02-10 20:07:08 +0100opticblast(~Thunderbi@172.58.80.43)
2023-02-10 20:11:11 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com)
2023-02-10 20:13:17 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-02-10 20:19:08 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-02-10 20:19:52 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-02-10 20:20:44 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-02-10 20:21:57 +0100irrgit_(~irrgit@176.113.74.130) (Read error: Connection reset by peer)
2023-02-10 20:25:23 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 264 seconds)
2023-02-10 20:34:30 +0100thegeekinside(~thegeekin@189.180.83.186) (Remote host closed the connection)
2023-02-10 20:34:35 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-02-10 20:35:53 +0100 <Inst_> i guess my issue with list comprehensions is that i've seen bad code done in list comprehensions
2023-02-10 20:36:07 +0100 <Inst_> it seems that idiomatic list comprehensions use the Haskell whitespacing rules more efficiently
2023-02-10 20:36:28 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 20:36:58 +0100EvanR(~EvanR@user/evanr)
2023-02-10 20:37:16 +0100econo(uid147250@user/econo)
2023-02-10 20:40:36 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-02-10 20:40:43 +0100ddellacosta(~ddellacos@146.70.166.139) (Ping timeout: 252 seconds)
2023-02-10 20:40:51 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 260 seconds)
2023-02-10 20:43:00 +0100 <davean> Inst_: Is there something you haven't seen bad code done with?
2023-02-10 20:44:24 +0100notzmv(~zmv@user/notzmv)
2023-02-10 20:45:08 +0100Inst_Inst
2023-02-10 20:45:28 +0100skisometimes wonders whether lists, list comprehensions, ought to have used `;', rather than `,'
2023-02-10 20:45:37 +0100 <monochrom> I'm pretty sure the answer is yes, and I'm also pretty sure human are absolutely biased and selective, so there is really nothing to discuss.
2023-02-10 20:47:26 +0100 <Inst> if you're asking about my complaints about list syntax, it's that Julia and Matlab have better ways to handle matrices than Haskell
2023-02-10 20:47:50 +0100 <EvanR> haskell isn't good at "everything is a matrix"
2023-02-10 20:48:15 +0100 <EvanR> in the words of B user guide, it's good at non-numeric applications xD
2023-02-10 20:48:18 +0100 <geekosaur> if you want matrices then use APL >.>
2023-02-10 20:48:29 +0100 <EvanR> if you want to write numeric programs use fortran
2023-02-10 20:48:49 +0100 <Inst> had some Julian run up and talk about how pretty their recursive fib definition was, until i pointed out that doing it via matrices was both more succinct and faster
2023-02-10 20:49:09 +0100 <Inst> problem was, the Haskell port wasn't good
2023-02-10 20:49:20 +0100chomwitt(~chomwitt@2a02:587:7a12:aa00:1ac0:4dff:fedb:a3f1)
2023-02-10 20:49:24 +0100 <EvanR> restructuring something as a matrix is always a cool party trick
2023-02-10 20:49:47 +0100 <monochrom> If you like Haskell and APL, then use Haskell to give semantics to APL >:) https://link.springer.com/chapter/10.1007/978-3-662-54434-1_21
2023-02-10 20:49:59 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2023-02-10 20:50:10 +0100mjs2600_(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Read error: Connection reset by peer)
2023-02-10 20:51:34 +0100 <monochrom> A linear transformation of a vector can always be linearized (pun intended haha) to tuple-manipulating code instead of invoking any matrix syntax.
2023-02-10 20:52:12 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Read error: Connection reset by peer)
2023-02-10 20:53:19 +0100 <davean> Inst: What do lists have to do with matrixes?
2023-02-10 20:53:19 +0100 <Inst> thanks, will show that to an APLer friend
2023-02-10 20:53:31 +0100 <Inst> matrices in haskell are implemented as nested lists
2023-02-10 20:53:41 +0100 <davean> No they aren't
2023-02-10 20:53:45 +0100 <EvanR> among other ways
2023-02-10 20:53:46 +0100 <monochrom> That's not what hmatrix does.
2023-02-10 20:53:57 +0100 <davean> Thats just silly to claim
2023-02-10 20:54:11 +0100 <EvanR> e.g. linear (package) 4x4 matrix is 4 V4s
2023-02-10 20:54:24 +0100 <Inst> yes, i'm aware, typed matrices with a Nat for the size
2023-02-10 20:54:25 +0100 <monochrom> See? I called it. There is really nothing to discuss. "discuss".
2023-02-10 20:54:32 +0100 <davean> Inst: Not just that
2023-02-10 20:54:55 +0100 <EvanR> oh, hmatrix implements matrices using a matrix? interesting
2023-02-10 20:54:59 +0100 <davean> monochrom: yah this is pointless, this can't even be in good faith
2023-02-10 20:55:10 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-02-10 20:55:15 +0100 <Inst> ????
2023-02-10 20:57:32 +0100 <Inst> but to finish, the point is, Haskell doesn't have first-class syntactical support for matrices, that's all
2023-02-10 20:58:32 +0100 <davean> Inst: sure it does, naturally by how its syntax is designed so it doesn't need to special case it. You can just do it as a library
2023-02-10 20:58:52 +0100 <davean> You can build syntax just fine
2023-02-10 20:58:57 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-02-10 20:59:08 +0100 <davean> And you can have matrix comprehensions too and such
2023-02-10 20:59:39 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de) (Ping timeout: 248 seconds)
2023-02-10 20:59:52 +0100 <Inst> i'm going through hmatrix lib right now
2023-02-10 21:03:14 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-02-10 21:03:14 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-02-10 21:06:40 +0100foghorn(~foghorn@user/foghorn)
2023-02-10 21:07:58 +0100 <Inst> the syntax here at least seems to be converting from lists
2023-02-10 21:07:59 +0100 <Inst> https://hackage.haskell.org/package/hmatrix-0.20.2/docs/Numeric-LinearAlgebra-Data.html
2023-02-10 21:08:10 +0100 <Inst> with an annotation that converts a list to a matrix
2023-02-10 21:10:26 +0100azure_vermilion(~azure_ver@23.106.59.29) (Ping timeout: 255 seconds)
2023-02-10 21:11:00 +0100azure_vermilion(~azure_ver@164.39.138.83)
2023-02-10 21:15:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Remote host closed the connection)
2023-02-10 21:18:40 +0100mechap(~mechap@user/mechap) (Ping timeout: 252 seconds)
2023-02-10 21:20:26 +0100mechap(~mechap@user/mechap)
2023-02-10 21:21:49 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de)
2023-02-10 21:27:56 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-02-10 21:29:58 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-02-10 21:33:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 21:33:53 +0100slack1256(~slack1256@186.11.102.104) (Remote host closed the connection)
2023-02-10 21:35:00 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-02-10 21:37:29 +0100bilegeek(~bilegeek@2600:1008:b059:33a6:3874:3d26:7f6d:f6e5)
2023-02-10 21:39:33 +0100 <monochrom> Ugh 9.2.6 is released. This recompiles everything again.
2023-02-10 21:39:45 +0100monochromis on the 9.2.x stream.
2023-02-10 21:40:55 +0100 <Hecate> monochrom: did you need the fixes?
2023-02-10 21:41:08 +0100 <monochrom> I think no. :)
2023-02-10 21:43:07 +0100 <monochrom> Yeah I'm a pretty light user, I hadn't run into the bugs.
2023-02-10 21:45:25 +0100 <Hecate> ok :)
2023-02-10 21:48:00 +0100 <geekosaur> still. so far I've found that someone will trip over them, so I try to keep up to date. but this one hasn't hit ghcup yet, from the looks of it
2023-02-10 21:48:14 +0100 <geekosaur> speaking of, I need to try 9.6 alpha2
2023-02-10 21:54:00 +0100gehmehgehgmg
2023-02-10 21:56:17 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 252 seconds)
2023-02-10 21:59:15 +0100foul_owl(~kerry@157.97.134.60) (Ping timeout: 268 seconds)
2023-02-10 22:04:11 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-02-10 22:05:17 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Remote host closed the connection)
2023-02-10 22:05:51 +0100pavonia(~user@user/siracusa)
2023-02-10 22:06:31 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-02-10 22:08:00 +0100takuan_dozo(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-02-10 22:12:48 +0100foul_owl(~kerry@193.29.61.35)
2023-02-10 22:14:54 +0100mastarija(~mastarija@2a05:4f46:e03:6000:4eb2:bb7f:1ccf:de1a) (Quit: WeeChat 3.7.1)
2023-02-10 22:17:08 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-02-10 22:18:59 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Ping timeout: 260 seconds)
2023-02-10 22:19:54 +0100mjs2600(~mjs2600@143.244.44.172)
2023-02-10 22:23:11 +0100mjs2600_(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2023-02-10 22:23:20 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 246 seconds)
2023-02-10 22:24:15 +0100mjs2600(~mjs2600@143.244.44.172) (Ping timeout: 248 seconds)
2023-02-10 22:31:09 +0100 <stefan-_> when I have an list of values where I need to (often) swap two values at given indices, would be IOArray or Data.Vector better?
2023-02-10 22:33:32 +0100 <c_wraith> if "often" is enough, both are slow and you should be using primops and the primitive types those libraries use. I've had to do that before.
2023-02-10 22:34:02 +0100 <c_wraith> But for most use cases, either is fine.
2023-02-10 22:34:22 +0100 <c_wraith> So long as you stick to a mutable api, anyway. pick whichever you like more
2023-02-10 22:35:17 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-02-10 22:37:14 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-02-10 22:38:42 +0100telser(~quassel@user/telser)
2023-02-10 22:39:17 +0100 <stefan-_> c_wraith, ok, thanks, IOArray is actually fast enough for my purposes
2023-02-10 22:39:44 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-02-10 22:40:33 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Quit: beteigeuze)
2023-02-10 22:41:36 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Remote host closed the connection)
2023-02-10 22:41:54 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-02-10 22:42:26 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-02-10 22:42:45 +0100 <c_wraith> man... when did I have to do that? Oh! It was implementing pbkdf2. The only library that had it back then was wrong, because the author misunderstood the spec.
2023-02-10 22:43:16 +0100 <c_wraith> pbkdf2 is supposed to be slow, but your implementation is not supposed to be slower than everyone else's
2023-02-10 22:51:54 +0100jonathanx_(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
2023-02-10 22:52:28 +0100jonathanx(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Remote host closed the connection)
2023-02-10 22:58:06 +0100accord(uid568320@id-568320.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 23:00:01 +0100Guest51(~Guest51@205.175.106.161)
2023-02-10 23:01:06 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de)
2023-02-10 23:14:41 +0100hpc(~juzz@ip98-169-35-163.dc.dc.cox.net) (Ping timeout: 252 seconds)
2023-02-10 23:14:42 +0100rburkholder(~blurb@96.45.2.121)
2023-02-10 23:17:35 +0100mncheck(~mncheck@193.224.205.254) (Ping timeout: 246 seconds)
2023-02-10 23:20:18 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Remote host closed the connection)
2023-02-10 23:22:12 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-02-10 23:25:32 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de) (Remote host closed the connection)
2023-02-10 23:25:54 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de)
2023-02-10 23:29:35 +0100forell_(~forell@host-178-216-90-220.sta.tvknaszapraca.pl) (Quit: ZNC - https://znc.in)
2023-02-10 23:29:53 +0100forell(~forell@user/forell)
2023-02-10 23:32:33 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl)
2023-02-10 23:35:50 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 23:37:08 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 23:37:30 +0100merijn(~merijn@c-001-001-010.client.esciencecenter.eduvpn.nl) (Ping timeout: 260 seconds)
2023-02-10 23:37:36 +0100son0p(~ff@181.136.122.143) (Remote host closed the connection)
2023-02-10 23:38:12 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-02-10 23:38:49 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-02-10 23:39:09 +0100gurkenglas(~gurkengla@dynamic-046-114-182-197.46.114.pool.telefonica.de) (Ping timeout: 268 seconds)
2023-02-10 23:41:47 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 248 seconds)
2023-02-10 23:45:24 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Quit: beteigeuze)
2023-02-10 23:47:13 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-02-10 23:49:15 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea) (Remote host closed the connection)
2023-02-10 23:54:37 +0100 <DigitalKiwi> lmao
2023-02-10 23:54:45 +0100freeside(~mengwong@103.252.202.170)
2023-02-10 23:56:10 +0100 <EvanR> stefan-_, relevant to the question of optimizing this is the size of the array and the probability distribution on the indices
2023-02-10 23:56:21 +0100 <EvanR> weighted toward 0 or uniform
2023-02-10 23:56:58 +0100 <EvanR> (in case there's something better than a mutable array)
2023-02-10 23:57:27 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:54db:de44:4607:1cea)
2023-02-10 23:57:59 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-02-10 23:59:02 +0100freeside(~mengwong@103.252.202.170) (Ping timeout: 252 seconds)