IRCBrowse

2023/12/23

2023-12-23 00:05:12 +0100shapr(~user@2600:1700:c640:3100:3c85:be55:684a:fbc3) (Remote host closed the connection)
2023-12-23 00:05:26 +0100shapr(~user@2600:1700:c640:3100:948d:4ec3:e021:6ffd)
2023-12-23 00:15:18 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-12-23 00:18:51 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-23 00:22:27 +0100chiselfu1e(~chiselfus@user/chiselfuse)
2023-12-23 00:22:31 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 240 seconds)
2023-12-23 00:23:41 +0100acidjnk(~acidjnk@p200300d6e72b93454924925d6b33a65b.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-12-23 00:42:21 +0100 <juri_> how do i make hlint happy, when running against something that uses MachDeps.h and the C pre-processor? I have an "#error" for a case i can't support, and hlint is breaking on this.
2023-12-23 00:45:22 +0100chiselfu1e(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-12-23 00:46:01 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-12-23 00:49:36 +0100mreh(~mreh@94.5.253.65) (Ping timeout: 250 seconds)
2023-12-23 00:56:52 +0100michalz(~michalz@185.246.204.125) (Quit: ZNC 1.8.2 - https://znc.in)
2023-12-23 00:57:55 +0100 <fvr> juri_: do you want to ignore the entire file? you can place {-# HLINT_IGNORE #-} on top of the file
2023-12-23 01:06:30 +0100_xor0(~xor@72.49.195.41)
2023-12-23 01:07:51 +0100_xor(~xor@72.49.195.41) (Ping timeout: 245 seconds)
2023-12-23 01:07:51 +0100_xor0_xor
2023-12-23 01:08:31 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-12-23 01:12:55 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-23 01:19:32 +0100_xor2(~xor@72.49.195.41)
2023-12-23 01:21:04 +0100_xor(~xor@72.49.195.41) (Ping timeout: 246 seconds)
2023-12-23 01:21:04 +0100_xor2_xor
2023-12-23 01:24:46 +0100gdown-(~gavin@h69-11-149-109.kndrid.broadband.dynamic.tds.net) (Remote host closed the connection)
2023-12-23 01:28:35 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 260 seconds)
2023-12-23 01:29:31 +0100myme(~myme@2a01:799:d60:e400:6489:87d4:bbd5:b8cc) (Ping timeout: 260 seconds)
2023-12-23 01:30:16 +0100myme(~myme@2a01:799:d60:e400:5e72:30ce:3add:bd7c)
2023-12-23 01:30:54 +0100noir2002(~user@c-73-249-65-61.hsd1.ct.comcast.net)
2023-12-23 01:31:53 +0100noir2002(~user@c-73-249-65-61.hsd1.ct.comcast.net) ()
2023-12-23 01:35:41 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 240 seconds)
2023-12-23 01:57:45 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (Quit: _)
2023-12-23 01:58:07 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2023-12-23 02:10:32 +0100 <juri_> I'd rather just ignore the section, or have some sort of a define i can look for.
2023-12-23 02:12:01 +0100Tuplanolla(~Tuplanoll@91-159-69-171.elisa-laajakaista.fi) (Ping timeout: 255 seconds)
2023-12-23 02:12:29 +0100 <juri_> sinch hlint can't find MachDeps.h, is there something in there i can key off of, to determine i'm in hlint, when writing conditionals?
2023-12-23 02:13:20 +0100jmorris(uid604645@id-604645.hampstead.irccloud.com)
2023-12-23 02:13:41 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 245 seconds)
2023-12-23 02:14:04 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-12-23 02:20:10 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d)
2023-12-23 02:21:32 +0100Guest61(~Guest61@c-24-147-249-131.hsd1.ma.comcast.net)
2023-12-23 02:25:30 +0100taupiqueur(~taupiqueu@2a02-8440-3340-945d-781f-ca70-2fe9-9e3e.rev.sfr.net)
2023-12-23 02:25:49 +0100Guest61(~Guest61@c-24-147-249-131.hsd1.ma.comcast.net) (Client Quit)
2023-12-23 02:37:11 +0100asdfhjk1(~asdfhjk1@2605:59c8:514c:8110::389) (Ping timeout: 260 seconds)
2023-12-23 02:38:25 +0100 <fvr> juri_: you can use the __HLINT__ preprocessor definition to hide
2023-12-23 02:38:49 +0100 <fvr> you can find an example for it in the README https://github.com/ndmitchell/hlint/
2023-12-23 02:42:29 +0100alexherbo2(~alexherbo@2a02-8440-3340-945d-781f-ca70-2fe9-9e3e.rev.sfr.net)
2023-12-23 02:58:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d10d:1886:daa0:a45) (Remote host closed the connection)
2023-12-23 02:58:21 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5)
2023-12-23 03:17:31 +0100rosco(~rosco@113.188.179.201)
2023-12-23 03:22:56 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-12-23 03:24:49 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com) (Remote host closed the connection)
2023-12-23 03:28:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-12-23 03:31:58 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 276 seconds)
2023-12-23 03:50:21 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 245 seconds)
2023-12-23 03:58:53 +0100shapr(~user@2600:1700:c640:3100:948d:4ec3:e021:6ffd) (Remote host closed the connection)
2023-12-23 03:59:07 +0100shapr(~user@2600:1700:c640:3100:d824:2759:aace:bffe)
2023-12-23 04:12:25 +0100araujo(~araujo@45.131.194.46) (Ping timeout: 256 seconds)
2023-12-23 04:14:56 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 245 seconds)
2023-12-23 04:16:50 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-12-23 04:17:03 +0100rosco(~rosco@113.188.179.201) (Ping timeout: 252 seconds)
2023-12-23 04:26:09 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-23 04:27:30 +0100not_reserved(~not_reser@185.199.102.168)
2023-12-23 04:27:54 +0100rosco(~rosco@113.188.179.201)
2023-12-23 04:30:37 +0100alexherbo2(~alexherbo@2a02-8440-3340-945d-781f-ca70-2fe9-9e3e.rev.sfr.net) (Remote host closed the connection)
2023-12-23 04:36:29 +0100td_(~td@i53870925.versanet.de) (Ping timeout: 240 seconds)
2023-12-23 04:38:29 +0100td_(~td@i5387090C.versanet.de)
2023-12-23 04:44:59 +0100rosco(~rosco@113.188.179.201) (Quit: Lost terminal)
2023-12-23 04:57:24 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-12-23 04:57:24 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-12-23 04:57:24 +0100finn_elijaFinnElija
2023-12-23 05:06:23 +0100Axman6(~Axman6@user/axman6)
2023-12-23 05:08:01 +0100_xor0(~xor@72.49.195.41)
2023-12-23 05:08:13 +0100Axma68424(~Axman6@user/axman6) (Ping timeout: 244 seconds)
2023-12-23 05:09:31 +0100_xor(~xor@72.49.195.41) (Ping timeout: 245 seconds)
2023-12-23 05:09:31 +0100_xor0_xor
2023-12-23 05:19:01 +0100_xor2(~xor@72.49.195.41)
2023-12-23 05:19:12 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-12-23 05:20:21 +0100_xor(~xor@72.49.195.41) (Ping timeout: 245 seconds)
2023-12-23 05:20:21 +0100_xor2_xor
2023-12-23 05:20:23 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-12-23 05:22:17 +0100ania123(~ania123@94-43-231-47.dsl.utg.ge)
2023-12-23 05:22:55 +0100_xor(~xor@72.49.195.41)
2023-12-23 05:26:15 +0100aforemny(~aforemny@i59F516C5.versanet.de)
2023-12-23 05:27:01 +0100aforemny_(~aforemny@2001:9e8:6cc6:3d00:5ecd:52b3:2188:c8ee) (Ping timeout: 276 seconds)
2023-12-23 05:28:38 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-12-23 05:30:35 +0100Inrayzex(~Inrayzex@176.254.244.83) (Ping timeout: 264 seconds)
2023-12-23 05:31:15 +0100_xor(~xor@72.49.195.41)
2023-12-23 05:34:01 +0100gawen_(~gawen@user/gawen) (Quit: cya)
2023-12-23 05:35:21 +0100gawen(~gawen@user/gawen)
2023-12-23 05:35:22 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-12-23 05:38:15 +0100_xor(~xor@72.49.195.41)
2023-12-23 05:39:34 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-12-23 05:40:48 +0100notzmv(~zmv@user/notzmv)
2023-12-23 05:42:24 +0100_xor(~xor@72.49.195.41)
2023-12-23 05:44:22 +0100zzz(~z@user/zero)
2023-12-23 05:47:29 +0100zero(~z@user/zero) (Ping timeout: 256 seconds)
2023-12-23 05:47:30 +0100zzzzero
2023-12-23 05:53:41 +0100foul_owl(~kerry@185.219.141.160) (Ping timeout: 245 seconds)
2023-12-23 05:56:10 +0100foul_owl(~kerry@174-21-148-34.tukw.qwest.net)
2023-12-23 05:56:25 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-12-23 06:00:11 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 260 seconds)
2023-12-23 06:11:20 +0100igemnace(~ian@user/igemnace)
2023-12-23 06:11:52 +0100igemnace(~ian@user/igemnace) (Remote host closed the connection)
2023-12-23 06:22:36 +0100emmanuelux_(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-12-23 06:27:12 +0100infinity0_(~infinity0@pwned.gg)
2023-12-23 06:27:13 +0100infinity0(~infinity0@pwned.gg) (Killed (erbium.libera.chat (Nickname regained by services)))
2023-12-23 06:27:13 +0100infinity0_infinity0
2023-12-23 06:47:39 +0100Lycurgus(~georg@li1192-118.members.linode.com)
2023-12-23 06:47:39 +0100Lycurgus(~georg@li1192-118.members.linode.com) (Changing host)
2023-12-23 06:47:39 +0100Lycurgus(~georg@user/Lycurgus)
2023-12-23 06:58:12 +0100ania123(~ania123@94-43-231-47.dsl.utg.ge) (Quit: Client closed)
2023-12-23 07:07:57 +0100trev(~trev@user/trev)
2023-12-23 07:09:02 +0100oxide(~lambda@user/oxide)
2023-12-23 07:12:27 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-12-23 07:22:12 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-12-23 07:29:11 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Quit: peterbecich)
2023-12-23 07:29:52 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-23 07:33:08 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-12-23 07:35:28 +0100lisbeths_(uid135845@id-135845.lymington.irccloud.com)
2023-12-23 07:35:46 +0100oxide(~lambda@user/oxide) (Ping timeout: 256 seconds)
2023-12-23 07:48:41 +0100shapr(~user@2600:1700:c640:3100:d824:2759:aace:bffe) (Ping timeout: 245 seconds)
2023-12-23 07:53:16 +0100LispTyro(~pepsi@129.159.85.69)
2023-12-23 07:55:46 +0100bcmiller_(~bm3719@66.42.95.185) (Quit: leaving)
2023-12-23 08:08:46 +0100billchenchina(~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe)
2023-12-23 08:14:35 +0100bcmiller(~bm3719@66.42.95.185)
2023-12-23 08:26:04 +0100misterfish(~misterfis@84.53.85.146)
2023-12-23 08:27:08 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b)
2023-12-23 08:31:23 +0100bcmiller(~bm3719@66.42.95.185) (Ping timeout: 260 seconds)
2023-12-23 08:56:26 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 252 seconds)
2023-12-23 08:59:43 +0100YoungFrog(~youngfrog@39.129-180-91.adsl-dyn.isp.belgacom.be) (Ping timeout: 256 seconds)
2023-12-23 09:02:38 +0100phma(phma@2001:5b0:211f:86f8:38e2:2efc:badb:31e3) (Read error: Connection reset by peer)
2023-12-23 09:03:19 +0100phma(~phma@host-67-44-208-18.hnremote.net)
2023-12-23 09:04:16 +0100majestic(~majestic@176.254.244.83)
2023-12-23 09:05:33 +0100YoungFrog(~youngfrog@39.129-180-91.adsl-dyn.isp.belgacom.be)
2023-12-23 09:22:29 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1)
2023-12-23 09:34:23 +0100christiaanb(uid84827@id-84827.lymington.irccloud.com)
2023-12-23 09:37:39 +0100chomwitt(~chomwitt@2a02:587:7a09:c300:1ac0:4dff:fedb:a3f1) (Ping timeout: 260 seconds)
2023-12-23 09:44:13 +0100acidjnk(~acidjnk@p200300d6e72b93974924925d6b33a65b.dip0.t-ipconnect.de)
2023-12-23 09:44:42 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5) (Remote host closed the connection)
2023-12-23 09:45:21 +0100billchenchina(~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe) (Ping timeout: 245 seconds)
2023-12-23 09:55:45 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-12-23 10:00:53 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-23 10:01:01 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2023-12-23 10:02:54 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-12-23 10:07:10 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 276 seconds)
2023-12-23 10:11:51 +0100misterfish(~misterfis@84.53.85.146)
2023-12-23 10:14:42 +0100target_i(~target_i@217.175.14.39)
2023-12-23 10:17:23 +0100billchenchina(~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe)
2023-12-23 10:18:36 +0100Axman6(~Axman6@user/axman6) (Remote host closed the connection)
2023-12-23 10:19:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5)
2023-12-23 10:23:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5) (Ping timeout: 260 seconds)
2023-12-23 10:24:45 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-12-23 10:24:53 +0100Sgeo_(~Sgeo@user/sgeo)
2023-12-23 10:25:42 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-12-23 10:26:01 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 276 seconds)
2023-12-23 10:49:06 +0100Tuplanolla(~Tuplanoll@91-159-69-171.elisa-laajakaista.fi)
2023-12-23 11:04:27 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 11:07:24 +0100not_reserved(~not_reser@185.199.102.168) (Quit: Client closed)
2023-12-23 11:08:26 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b) (Quit: Leaving)
2023-12-23 11:09:17 +0100igemnace(~ian@user/igemnace)
2023-12-23 11:12:24 +0100danza(~danza@151.57.182.71)
2023-12-23 11:12:43 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5)
2023-12-23 11:15:20 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-12-23 11:15:22 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-12-23 11:30:45 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d) (Quit: Konversation terminated!)
2023-12-23 11:31:10 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d)
2023-12-23 11:32:44 +0100phma_(~phma@2001:5b0:211f:5c08:7509:960c:b2df:3c16)
2023-12-23 11:36:35 +0100phma(~phma@host-67-44-208-18.hnremote.net) (Ping timeout: 264 seconds)
2023-12-23 11:38:19 +0100zer0bitz_zer0bitz
2023-12-23 11:39:19 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-12-23 11:39:58 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-12-23 11:43:55 +0100christiaanb(uid84827@id-84827.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 11:48:04 +0100oxide(~lambda@user/oxide)
2023-12-23 11:49:31 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Ping timeout: 245 seconds)
2023-12-23 11:50:53 +0100sawilagar(~sawilagar@user/sawilagar)
2023-12-23 11:52:53 +0100mikess(~sam@user/mikess) (Ping timeout: 268 seconds)
2023-12-23 11:53:04 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-12-23 11:56:28 +0100xdminsy(~xdminsy@117.147.71.169)
2023-12-23 12:02:58 +0100billchenchina(~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe) (Remote host closed the connection)
2023-12-23 12:05:07 +0100taupiqueur(~taupiqueu@2a02-8440-3340-945d-781f-ca70-2fe9-9e3e.rev.sfr.net) (Ping timeout: 255 seconds)
2023-12-23 12:05:46 +0100oxide(~lambda@user/oxide) (Ping timeout: 245 seconds)
2023-12-23 12:07:00 +0100igemnace(~ian@user/igemnace) (Quit: WeeChat 4.1.2)
2023-12-23 12:08:21 +0100oxide(~lambda@user/oxide)
2023-12-23 12:10:43 +0100Axman6(~Axman6@user/axman6)
2023-12-23 12:18:33 +0100__monty__(~toonn@user/toonn)
2023-12-23 12:31:24 +0100xdminsy(~xdminsy@117.147.71.169) (Remote host closed the connection)
2023-12-23 12:31:50 +0100xdminsy(~xdminsy@117.147.71.169)
2023-12-23 12:32:54 +0100Inst(~Inst@120.244.192.23) (Remote host closed the connection)
2023-12-23 12:42:01 +0100raym(~ray@user/raym) (Ping timeout: 255 seconds)
2023-12-23 12:43:15 +0100raym(~ray@user/raym)
2023-12-23 12:49:31 +0100danza(~danza@151.57.182.71) (Quit: Leaving)
2023-12-23 12:50:44 +0100misterfish(~misterfis@84.53.85.146)
2023-12-23 12:53:08 +0100jmorris(uid604645@id-604645.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 13:04:31 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 255 seconds)
2023-12-23 13:08:54 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-12-23 13:09:47 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-12-23 13:12:37 +0100ht_(~Thunderbi@194.110.115.56)
2023-12-23 13:14:23 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Ping timeout: 264 seconds)
2023-12-23 13:14:23 +0100ht__ht
2023-12-23 13:28:18 +0100phma_phma
2023-12-23 13:30:48 +0100mreh(~mreh@94.5.253.65)
2023-12-23 13:31:04 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 256 seconds)
2023-12-23 13:33:02 +0100Sgeo_(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-12-23 13:35:09 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d) (Read error: Connection reset by peer)
2023-12-23 13:35:29 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d)
2023-12-23 13:38:30 +0100actioninja(~actioninj@user/actioninja)
2023-12-23 13:43:28 +0100 <haskellbridge> 15<J​ade> does anyone know if you can send abitrary commands to the mpd server using `libmpd`?
2023-12-23 13:43:29 +0100 <haskellbridge> 15<J​ade> `Network.MPD.Applicative` exports `runCommand` and the `Command` type, but not its constructor which is required
2023-12-23 13:44:26 +0100 <haskellbridge> 15<J​ade> `Command` is a newtype around `String` so I could `coerce` but that seems .... not idiomatic? It feels like they simply forgot to export the constructor of `Command`, unless im overseeing something
2023-12-23 13:46:07 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-12-23 13:47:22 +0100 <haskellbridge> 15<J​ade> nvm it's not a newtype, i was looking at something else
2023-12-23 13:52:21 +0100foul_owl(~kerry@174-21-148-34.tukw.qwest.net) (Ping timeout: 252 seconds)
2023-12-23 13:54:23 +0100AlexZenon(~alzenon@94.233.240.140) (Ping timeout: 256 seconds)
2023-12-23 13:56:32 +0100mreh(~mreh@94.5.253.65) (Ping timeout: 250 seconds)
2023-12-23 13:58:30 +0100AlexZenon(~alzenon@94.233.240.140)
2023-12-23 14:00:16 +0100 <haskellbridge> 15<J​ade> nvm there's `getResponse`
2023-12-23 14:01:09 +0100califax_(~califax@user/califx)
2023-12-23 14:01:19 +0100califax(~califax@user/califx) (Ping timeout: 240 seconds)
2023-12-23 14:02:25 +0100califax_califax
2023-12-23 14:03:50 +0100taupiqueur(~taupiqueu@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 14:06:48 +0100foul_owl(~kerry@157.97.134.166)
2023-12-23 14:23:37 +0100lisbeths_(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 14:30:40 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 246 seconds)
2023-12-23 14:45:40 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 14:58:32 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Read error: Connection reset by peer)
2023-12-23 14:59:33 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-12-23 15:07:38 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-12-23 15:18:31 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 276 seconds)
2023-12-23 15:21:07 +0100son0p(~ff@181.136.122.143) (Remote host closed the connection)
2023-12-23 15:36:55 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-12-23 15:37:20 +0100califax(~califax@user/califx)
2023-12-23 15:37:46 +0100mreh(~mreh@94.5.253.65)
2023-12-23 15:38:02 +0100shOkEy(~shOkEy@84-236-122-36.pool.digikabel.hu) (Ping timeout: 260 seconds)
2023-12-23 15:39:46 +0100shOkEy(~shOkEy@94-21-108-35.pool.digikabel.hu)
2023-12-23 15:40:41 +0100eggplant_(~Eggplanta@2600:1700:38c5:d800:bd66:57bc:8aed:5e26)
2023-12-23 15:44:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:e122:966d:46d8:51e5) (Ping timeout: 245 seconds)
2023-12-23 15:44:29 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-12-23 15:48:54 +0100trev(~trev@user/trev) (Read error: Connection reset by peer)
2023-12-23 15:49:14 +0100trev(~trev@user/trev)
2023-12-23 15:52:11 +0100son0p(~ff@181.136.122.143)
2023-12-23 15:52:22 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net) (Remote host closed the connection)
2023-12-23 15:52:41 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 16:00:18 +0100hippoid(~hippoid@user/hippoid) (Read error: Connection reset by peer)
2023-12-23 16:01:18 +0100megaTherion(~therion@unix.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-12-23 16:02:24 +0100megaTherion(~therion@unix.io)
2023-12-23 16:04:28 +0100hippoid(~hippoid@c-98-213-162-40.hsd1.il.comcast.net)
2023-12-23 16:09:20 +0100megaTherion(~therion@unix.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-12-23 16:10:24 +0100megaTherion(~therion@unix.io)
2023-12-23 16:13:26 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-12-23 16:15:29 +0100ht_(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-12-23 16:17:11 +0100_ht(~Thunderbi@194.110.115.56) (Ping timeout: 256 seconds)
2023-12-23 16:17:11 +0100ht__ht
2023-12-23 16:21:42 +0100rovaughn86(~rovaughn@2a09:bac2:a620:197d::28a:a)
2023-12-23 16:25:59 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net) (Remote host closed the connection)
2023-12-23 16:26:01 +0100rovaughn86(~rovaughn@2a09:bac2:a620:197d::28a:a) (Client Quit)
2023-12-23 16:26:18 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 16:26:26 +0100rovaughn(~alec@066-065-097-119.res.spectrum.com) (Quit: leaving)
2023-12-23 16:27:01 +0100rovaughn(~rovaughn@2a09:bac3:a621:6e::b:29e)
2023-12-23 16:27:48 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection)
2023-12-23 16:28:47 +0100hamster(~ham@user/ham) (Ping timeout: 260 seconds)
2023-12-23 16:30:07 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-12-23 16:40:39 +0100rovaughn(~rovaughn@2a09:bac3:a621:6e::b:29e) (Quit: Client closed)
2023-12-23 16:43:04 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-12-23 16:46:45 +0100rovaughn(~rovaughn@2a09:bac3:a623:6e::b:255)
2023-12-23 16:47:17 +0100rovaughn(~rovaughn@2a09:bac3:a623:6e::b:255) (Client Quit)
2023-12-23 16:48:09 +0100hamster(~ham@user/ham)
2023-12-23 16:50:41 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-12-23 16:52:46 +0100notzmv(~zmv@user/notzmv)
2023-12-23 16:55:22 +0100Tlsx(~rscastilh@189.61.140.215)
2023-12-23 16:56:54 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-23 16:59:05 +0100Xyloes(~wyx@2400:dd01:103a:1012:d681:d7ff:fedb:298d) (Remote host closed the connection)
2023-12-23 17:02:56 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net) (Remote host closed the connection)
2023-12-23 17:17:51 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-12-23 17:18:40 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-12-23 17:20:05 +0100not_reserved(~not_reser@154.16.157.96)
2023-12-23 17:20:48 +0100misterfish(~misterfis@84.53.85.146)
2023-12-23 17:21:17 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920)
2023-12-23 17:24:06 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-12-23 17:24:57 +0100 <myclm_> hello, i have one question regarding functional programing in general, maybe someone here can answer this. It referes to something i read about func progr: it does not contain loops just functions, however i thought loops esp for loop, but probably also while loop are mathematical functions, written in the big sigma sign or the Pi sign thus making this very well, in the mathematical sence functions, or am i mistaken here?
2023-12-23 17:28:49 +0100 <enikar> often big sigma are folds, I guess
2023-12-23 17:29:45 +0100 <enikar> there are many way to express loops in haskell.
2023-12-23 17:31:17 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 240 seconds)
2023-12-23 17:32:29 +0100 <myclm_> so this claim is just wrong, that loops do not exist in functional programing?
2023-12-23 17:33:54 +0100 <enikar> the loops are not expressed in the same way as in imperative language, but they exist
2023-12-23 17:34:19 +0100 <not_reserved> myclm_:  think it would be much more instructive to work through some very simple example code rather than read vague general descriptions of the differences
2023-12-23 17:34:31 +0100 <not_reserved> e.g. look up "how to do x in haskell' where x ordinarily requires a loop
2023-12-23 17:37:44 +0100 <myclm_> yes, thanks for the input!
2023-12-23 17:38:24 +0100Inst(~Inst@120.244.192.23)
2023-12-23 17:39:25 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2023-12-23 17:39:25 +0100 <haskellbridge> 06<s​m> There's no looping construct built in to the language, but we certainly "loop" in haskell programs. Either by writing recursive functions, or by using library functions which do recursion under the hood.
2023-12-23 17:42:24 +0100 <haskellbridge> 06<s​m> eg ghc -e "import Control.Monad" -e "forM_ [1..10] print"
2023-12-23 17:45:51 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 17:46:38 +0100taupiqueur(~taupiqueu@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net) (Quit: WeeChat 4.1.2)
2023-12-23 17:52:01 +0100 <haskellbridge> 06<s​m> or without IO: ghc -e "import Data.Traversable" -e "for [1..10] $ \i -> pure (i*2)"
2023-12-23 17:56:54 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-12-23 17:57:00 +0100 <enikar> why not merely: ghc -e "map (*2) [1..10]"
2023-12-23 18:00:21 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 245 seconds)
2023-12-23 18:04:35 +0100LispTyro(~pepsi@129.159.85.69) (Remote host closed the connection)
2023-12-23 18:10:31 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-12-23 18:16:05 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920) (Ping timeout: 240 seconds)
2023-12-23 18:20:33 +0100eggplant_(~Eggplanta@2600:1700:38c5:d800:bd66:57bc:8aed:5e26) (Remote host closed the connection)
2023-12-23 18:20:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:bd66:57bc:8aed:5e26)
2023-12-23 18:29:53 +0100pukeGuest8923
2023-12-23 18:29:53 +0100pyooque(~puke@user/puke)
2023-12-23 18:29:53 +0100Guest8923(~puke@user/puke) (Killed (calcium.libera.chat (Nickname regained by services)))
2023-12-23 18:29:53 +0100pyooquepuke
2023-12-23 18:31:08 +0100 <haskellbridge> 15<J​ade> `join (+) <$> [1..10]`
2023-12-23 18:31:45 +0100puke(~puke@user/puke) (Max SendQ exceeded)
2023-12-23 18:32:16 +0100puke(~puke@user/puke)
2023-12-23 18:33:36 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-12-23 18:33:58 +0100_xor(~xor@72.49.195.41) (Ping timeout: 260 seconds)
2023-12-23 18:39:15 +0100 <monochrom> not_reserved++
2023-12-23 18:39:52 +0100 <monochrom> We should never answer beginner-level general abstract questions.
2023-12-23 18:42:58 +0100mreh(~mreh@94.5.253.65) (Ping timeout: 250 seconds)
2023-12-23 18:58:36 +0100trev(~trev@user/trev) (Quit: trev)
2023-12-23 18:58:53 +0100trev(~trev@user/trev)
2023-12-23 19:06:49 +0100sawilagar(~sawilagar@user/sawilagar)
2023-12-23 19:08:39 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-12-23 19:08:46 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-12-23 19:09:30 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-12-23 19:12:02 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-12-23 19:13:18 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-12-23 19:17:55 +0100shriekingnoise_(~shrieking@186.137.175.87)
2023-12-23 19:18:07 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 268 seconds)
2023-12-23 19:19:53 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920)
2023-12-23 19:32:55 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 240 seconds)
2023-12-23 19:33:32 +0100Tisoxin(~Ikosit@user/ikosit) (Ping timeout: 268 seconds)
2023-12-23 19:33:59 +0100Tisoxin(~Ikosit@user/ikosit)
2023-12-23 19:35:28 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-12-23 19:35:32 +0100mikess(~sam@user/mikess)
2023-12-23 19:37:31 +0100 <c_wraith> A few hours late, but.. Haskell has a built-in looping structure. The name of a definition is available within its body. That's a general-purpose one!
2023-12-23 19:38:55 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920) (Ping timeout: 256 seconds)
2023-12-23 19:40:54 +0100misterfish(~misterfis@84.53.85.146)
2023-12-23 19:41:20 +0100 <tomsmeding> never say never (monochrom) but I also agree with not_reserved: haskell basically lets you build your own control flow structures (such as loops), but this is interesting to only very few beginners. Most beginners are interested in doing the thing they want to do, which involves not the generic control-flow machinery (i.e. function calls and recursion), but ready-made _loops_ such as mapM_, map,
2023-12-23 19:41:20 +0100 <tomsmeding> etc.
2023-12-23 19:41:50 +0100 <tomsmeding> so to most people, the answer should be: yes, haskell has loops
2023-12-23 19:42:07 +0100 <tomsmeding> only to some the more precise answer is interesting and/or useful
2023-12-23 19:42:20 +0100 <haskellbridge> 06<s​m> yup
2023-12-23 19:43:56 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2023-12-23 19:49:37 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-12-23 19:49:50 +0100akshitkr(~user@49.205.47.187)
2023-12-23 19:50:46 +0100 <akshitkr> hey, i solved an advent of code problem recently: https://pastebin.com/T39Mci1R but was wondering if there is a better way to go about it instead of hard coding the reverse of the first 9 numbers spelt out
2023-12-23 19:51:19 +0100 <tomsmeding> akshitkr: have you tried using a Map?
2023-12-23 19:51:30 +0100__monty__(~toonn@user/toonn) (Ping timeout: 252 seconds)
2023-12-23 19:51:47 +0100 <tomsmeding> or, hm
2023-12-23 19:52:05 +0100 <c_wraith> akshitkr: there are other solutions to that one, but none are strictly better than that approach
2023-12-23 19:53:10 +0100 <akshitkr> tomsmeding: where exactly?
2023-12-23 19:53:15 +0100 <tomsmeding> yeah no, ignore
2023-12-23 19:53:17 +0100 <c_wraith> akshitkr: or if you really just mean the spelling out part, you can make top-level definitions for the strings, then call reverse on them
2023-12-23 19:53:59 +0100 <akshitkr> c_wraith: that makes sense, how do i go about making a gaurd for the entire list of strings
2023-12-23 19:54:21 +0100 <akshitkr> since right now i have created a guards for each one of them manually
2023-12-23 19:54:55 +0100 <akshitkr> I have a feeling I am missing something very fundamental since there is probably a better way to do this
2023-12-23 19:55:25 +0100 <c_wraith> you can use `any'
2023-12-23 19:55:28 +0100 <c_wraith> :t any
2023-12-23 19:55:29 +0100 <lambdabot> Foldable t => (a -> Bool) -> t a -> Bool
2023-12-23 19:55:58 +0100 <tomsmeding> you also need the number that it maps to
2023-12-23 19:56:10 +0100 <akshitkr> interesting, I'll look into this
2023-12-23 19:56:11 +0100 <tomsmeding> :t find
2023-12-23 19:56:12 +0100 <lambdabot> Foldable t => (a -> Bool) -> t a -> Maybe a
2023-12-23 19:56:19 +0100 <tomsmeding> that feels more appropriate
2023-12-23 19:56:27 +0100 <tomsmeding> (Data.List.find)
2023-12-23 19:56:43 +0100 <c_wraith> ugh, then you'd have to match against it again?
2023-12-23 19:57:01 +0100 <c_wraith> Well, I guess you could use lookup
2023-12-23 19:57:09 +0100 <tomsmeding> list of (string, value) pairs, use find ((`T.isPrefixOf` string) . fst)
2023-12-23 19:57:26 +0100 <c_wraith> now you're just reinventing lookup
2023-12-23 19:57:27 +0100 <akshitkr> also: is there a good reference for Data.Text considering I've almost always used [Char] instead
2023-12-23 19:57:28 +0100 <c_wraith> :t lookup
2023-12-23 19:57:29 +0100 <lambdabot> Eq a => a -> [(a, b)] -> Maybe b
2023-12-23 19:57:35 +0100 <tomsmeding> it's isPrefixOf, not (==)
2023-12-23 19:57:35 +0100 <c_wraith> :t lookupBy
2023-12-23 19:57:36 +0100 <lambdabot> error:
2023-12-23 19:57:36 +0100 <lambdabot> • Variable not in scope: lookupBy
2023-12-23 19:57:36 +0100 <lambdabot> • Perhaps you meant one of these:
2023-12-23 19:58:17 +0100 <tomsmeding> akshitkr: in addition to the module documentation? https://hackage.haskell.org/package/text-2.1/docs/Data-Text.html
2023-12-23 19:58:27 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-12-23 19:58:31 +0100 <c_wraith> Huh, I really though there was a predicate version of lookup.
2023-12-23 19:58:42 +0100 <tomsmeding> isn't that, like, literally 'find'
2023-12-23 19:58:48 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-12-23 19:58:54 +0100 <tomsmeding> ah, I guess the pair handling is not built-in
2023-12-23 19:59:22 +0100 <tomsmeding> hoogle seems to find some
2023-12-23 19:59:30 +0100 <c_wraith> well, not important.
2023-12-23 19:59:30 +0100 <tomsmeding> well, _one_
2023-12-23 19:59:47 +0100 <akshitkr> tomsmeding: yeah, if there is something you'd have in mind
2023-12-23 20:00:10 +0100 <akshitkr> i'm not quite sure how any would work though
2023-12-23 20:00:25 +0100 <tomsmeding> as I said, I think 'any' is not strong enough here, you need Data.List.find
2023-12-23 20:00:28 +0100 <akshitkr> so do i create a hof which returns a guard and then map it over the strings
2023-12-23 20:00:51 +0100 <akshitkr> right
2023-12-23 20:03:14 +0100 <c_wraith> this problem isn't *nearly* complex enough to need it, but it's a decently fun exercise for introducing optimized string search algorithms, where you use partial matches to skip later comparisons.
2023-12-23 20:03:55 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-12-23 20:08:01 +0100 <c_wraith> like if the string you're looking at starts with "onq", and the first thing you compare against in "one", you use the partial match and your knowledge of the contents of the target set to skip over all those characters to continue searching. (This is like a variant of KMP)
2023-12-23 20:08:33 +0100asivitz(uid178348@id-178348.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-12-23 20:09:03 +0100 <akshitkr> i understand the concept but i can't really think of a functional way to do it
2023-12-23 20:09:23 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920)
2023-12-23 20:09:33 +0100 <akshitkr> all i *can* think of is an imperative loop which breaks on mismatch
2023-12-23 20:09:41 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-12-23 20:10:03 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-12-23 20:10:05 +0100 <tomsmeding> (makes me think of the previous discussion lol)
2023-12-23 20:10:28 +0100 <c_wraith> yeah, don't worry about that. It's complicated. :)
2023-12-23 20:10:44 +0100 <akshitkr> of course
2023-12-23 20:10:54 +0100 <tomsmeding> (look up "knuth-morris-pratt" if you feel curious)
2023-12-23 20:10:55 +0100 <akshitkr> but is it called something specific
2023-12-23 20:11:03 +0100 <akshitkr> thanks, was looking for that
2023-12-23 20:11:03 +0100 <tomsmeding> (that's what the KMP was referring to)
2023-12-23 20:11:06 +0100 <c_wraith> I mean, it's a state machine
2023-12-23 20:11:19 +0100 <tomsmeding> which can you code just fine in haskell
2023-12-23 20:11:39 +0100 <c_wraith> But the algorithm as a whole is complex
2023-12-23 20:12:29 +0100 <akshitkr> i think i've written this algorithm in C
2023-12-23 20:12:45 +0100 <akshitkr> but yeah, i dont really know how state machines work in haskell or how I'd go about writing one
2023-12-23 20:12:51 +0100 <c_wraith> It's not quite the same algorithm when you are searching for multiple possible strings
2023-12-23 20:12:55 +0100 <monochrom> "loop but breaks out on condition" = "recursion but don't recurse on condition"
2023-12-23 20:13:24 +0100 <akshitkr> makes sense
2023-12-23 20:16:14 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-12-23 20:18:46 +0100Tlsx(~rscastilh@189.61.140.215) (Ping timeout: 255 seconds)
2023-12-23 20:20:54 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 20:23:48 +0100__monty__(~toonn@user/toonn)
2023-12-23 20:24:00 +0100Tlsx(~rscastilh@189.61.140.215)
2023-12-23 20:30:53 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net) (Remote host closed the connection)
2023-12-23 20:30:54 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2023-12-23 20:31:48 +0100 <tri> hi folks, is there any Semigroup/Monoid of Maybe, that when <> with a Nothing, will result in Nothing?
2023-12-23 20:32:17 +0100 <tri> like Just "a" <> Nothing = Nothing
2023-12-23 20:32:55 +0100 <juri_> that doesn't sound like semigroup. seems like you're wanting a short circuting function.
2023-12-23 20:33:12 +0100alexherbo2(~alexherbo@2a02-8440-3240-b2fd-f530-3e50-7734-7ced.rev.sfr.net)
2023-12-23 20:34:00 +0100 <tri> because im learning about Applicative, and the book says that Applicative is a Monoidic Functor, i.e. the structure is a Monoid
2023-12-23 20:34:19 +0100 <tri> so Just "a" <*> Nothing is Nothing
2023-12-23 20:34:58 +0100 <tri> in this case, looking at the structure i.e. Maybe, which is a Monoid, it goes from Just <> Nothing -> Nothing
2023-12-23 20:35:21 +0100 <tri> i mean the result of Just <> Nothing is Nothing
2023-12-23 20:35:21 +0100 <c_wraith> That's what Maybe's Monoid instance already does...
2023-12-23 20:35:34 +0100 <ncf> no it's not, but you can certainly define it that way
2023-12-23 20:35:47 +0100 <tri> c_wraith: no, Monoid of Maybe is Just "a" <> Nothing is Just "a"
2023-12-23 20:35:52 +0100 <c_wraith> Oh. Wow, I misread that.
2023-12-23 20:36:06 +0100 <ncf> > Ap (Just "a") <> Ap Nothing
2023-12-23 20:36:07 +0100 <lambdabot> Ap {getAp = Nothing}
2023-12-23 20:36:13 +0100 <ncf> > Ap (Just "a") <> Ap (Just "b")
2023-12-23 20:36:14 +0100 <lambdabot> Ap {getAp = Just "ab"}
2023-12-23 20:36:27 +0100 <tri> ncf: yes i certainly can write a wrapper for Maybe, of a Semigroup, to have Just "a" <> Nothing = Nothing
2023-12-23 20:36:33 +0100 <ncf> this just lifts the monoidal structure on the *functor* Maybe (which is what you want), to a monoid on values
2023-12-23 20:37:20 +0100 <EvanR> Applicative could have been defined as unit :: f (), <,> :: f a -> f b -> f (a,b), with monoid-like laws
2023-12-23 20:37:22 +0100 <c_wraith> well.. the Applicative for Maybe. As the name Ap implies
2023-12-23 20:37:37 +0100 <EvanR> it's equivalent in power to our Applicative, but less convenient
2023-12-23 20:37:44 +0100 <ncf> applicatives are best seen as monoidal functors in this context
2023-12-23 20:38:50 +0100 <akshitkr> hello again, so i went ahead with using find, but kinda stuck trying to implement it
2023-12-23 20:38:55 +0100 <ncf> and an equivalent way to define those is unit :: Monoid a => f a; (<<>>) :: Monoid a => f a -> f a -> f a
2023-12-23 20:39:04 +0100 <c_wraith> It's worth pointing out that Ap (Maybe a)'s behavior when both values are Just is determined by the Monoid instance for a
2023-12-23 20:39:06 +0100 <ncf> (in other words, Monoid a => Monoid (f a))
2023-12-23 20:39:16 +0100 <akshitkr> using something like this inside the "first" function: find (\(ind, x) -> x `T.isPrefixOf` string) spell = ??
2023-12-23 20:40:00 +0100 <akshitkr> but i'm not really sure how to use the result of find as a boolean for the gaurd and then use the result itself as the final function output
2023-12-23 20:40:12 +0100 <c_wraith> akshitkr: the lambda can't return x. by the type of find, it needs to return a Boolean
2023-12-23 20:40:51 +0100 <c_wraith> akshitkr: wow, my reading is bad today. nevermind that. ok, what are your pairs?
2023-12-23 20:41:02 +0100 <akshitkr> spell = zip [1.. ] ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
2023-12-23 20:41:43 +0100 <c_wraith> so that find is going to return a pair and you need... what from it?
2023-12-23 20:42:15 +0100 <akshitkr> so i want a boolean indicating if the "find" call actually found something
2023-12-23 20:42:24 +0100 <akshitkr> and the first element of the pair itself
2023-12-23 20:42:30 +0100 <c_wraith> :t find
2023-12-23 20:42:31 +0100 <lambdabot> Foldable t => (a -> Bool) -> t a -> Maybe a
2023-12-23 20:42:39 +0100 <c_wraith> hey, how about that! it returns a Maybe!
2023-12-23 20:42:59 +0100 <c_wraith> That tells you whether or not it succeeded and if it did, what it found!
2023-12-23 20:43:43 +0100 <c_wraith> you should do a case on the return value
2023-12-23 20:44:09 +0100 <akshitkr> makes sense
2023-12-23 20:44:20 +0100 <akshitkr> thanks!
2023-12-23 20:44:26 +0100 <EvanR> find even (let ones = 1:ones in ones) -- the answer depends on who you ask, the computer or any non-sleeping student
2023-12-23 20:45:08 +0100 <tri> ncf: is this correct? https://paste.tomsmeding.com/iUyWRWuF
2023-12-23 20:45:47 +0100 <tri> ncf: sorry getAP isn't a sensible name, i forgot to change that
2023-12-23 20:46:41 +0100 <eugenrh> Hi, this works fine: filterM doesFileExist ["file1", "file2"] . But, I want the opposite: those files that don't exist. How do I negate that, please?
2023-12-23 20:47:11 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2023-12-23 20:47:27 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2023-12-23 20:47:28 +0100 <geekosaur> filterM (not <$> doesFileExist)
2023-12-23 20:47:52 +0100 <c_wraith> I don't think that works...
2023-12-23 20:48:20 +0100 <c_wraith> yeah, doesFileExist is a function, so it gets the wrong functor instance
2023-12-23 20:50:11 +0100 <EvanR> define doesFileNotExist as a separate action
2023-12-23 20:50:18 +0100 <EvanR> then substitute
2023-12-23 20:50:31 +0100 <EvanR> unless you wanna @pl it
2023-12-23 20:50:42 +0100 <geekosaur> mm, right
2023-12-23 20:51:15 +0100 <geekosaur> fmap not . doesFileExist
2023-12-23 20:51:29 +0100 <c_wraith> Honestly, I want an operator for that. Some variant of <=<
2023-12-23 20:51:33 +0100 <EvanR> the horrors of pointless form!
2023-12-23 20:53:35 +0100 <eugenrh> geekosaur: yes, thank you! I was trying that but without the dot.
2023-12-23 20:53:52 +0100 <monochrom> fmap (fmap not) doesFileExist >:)
2023-12-23 20:54:05 +0100 <c_wraith> monochrom: oh no! you did the thing!
2023-12-23 20:55:38 +0100 <eugenrh> I'm too tired now, but on another day, I'll try to understand it.. why it works that way..
2023-12-23 20:56:25 +0100 <monochrom> Oh simply because fmap for the (->)X functor is (.)
2023-12-23 20:56:32 +0100 <geekosaur> because it's pointfree
2023-12-23 20:56:50 +0100 <geekosaur> which is the part I missed at first
2023-12-23 21:02:55 +0100wand(~user@gateway/tor-sasl/wand) (Ping timeout: 240 seconds)
2023-12-23 21:04:30 +0100 <akshitkr> is there something wrong with this gaurd?
2023-12-23 21:04:38 +0100 <akshitkr> | isNothing result = fst (fromJust result)
2023-12-23 21:04:44 +0100 <akshitkr> where
2023-12-23 21:04:44 +0100 <akshitkr> result = find (\(ind, x) -> x `T.isPrefixOf` string) spell
2023-12-23 21:05:02 +0100 <akshitkr> getting: Maybe.fromJust: Nothing
2023-12-23 21:05:11 +0100 <akshitkr> even though I am checking for Nothing
2023-12-23 21:05:49 +0100 <monochrom> isNothing? isJust?
2023-12-23 21:06:11 +0100 <geekosaur> you have one of those backwards, that guard says to do fromJust only if it's Nothing
2023-12-23 21:06:14 +0100 <akshitkr> of course, thank you.
2023-12-23 21:06:38 +0100Dhopper(~mateus@user/Dhopper)
2023-12-23 21:07:23 +0100Dhopper(~mateus@user/Dhopper) (Client Quit)
2023-12-23 21:07:23 +0100 <[exa]> akshitkr: btw you can patternmatch right away to avoid partial functions, such as: | Just x <- find (...) spell = fst x
2023-12-23 21:08:28 +0100 <akshitkr> ah right, forgot about that
2023-12-23 21:09:36 +0100 <akshitkr> wait
2023-12-23 21:09:37 +0100 <ncf> tri: sure, but you could simplify the last two cases into one: Wrapper _ <> Wrapper _ = Wrapper Nothing
2023-12-23 21:10:00 +0100 <akshitkr> how does Just x <- ... work
2023-12-23 21:10:03 +0100 <akshitkr> not quite sure
2023-12-23 21:10:12 +0100 <akshitkr> does Just ... return a boolean
2023-12-23 21:10:13 +0100 <akshitkr> :t Just
2023-12-23 21:10:14 +0100 <lambdabot> a -> Maybe a
2023-12-23 21:10:33 +0100 <[exa]> akshitkr: it is special syntax, basically the same as used in list comprehensions
2023-12-23 21:10:42 +0100 <akshitkr> I see
2023-12-23 21:11:17 +0100trev(~trev@user/trev) (Quit: trev)
2023-12-23 21:11:49 +0100 <[exa]> not sure how precisely that thing gets compiled but you could imagine some soft implementation with `fail` for matches and `guard` for booleans
2023-12-23 21:13:54 +0100 <akshitkr> interesting
2023-12-23 21:14:09 +0100 <akshitkr> just syntactic sugar then
2023-12-23 21:14:16 +0100Tlsx(~rscastilh@189.61.140.215) (Remote host closed the connection)
2023-12-23 21:17:13 +0100 <[exa]> like, manually you should be able to do the same by inserting choice/pure/guard in the right places, roughly: fromJust $ choice [ do {pattern <- pure something; guard $ condition; pure value ;}, do {otherpattern <- pure ... } ]
2023-12-23 21:17:34 +0100 <[exa]> the compiled version will be ofc better, no actual Maybes in the way etc.
2023-12-23 21:20:55 +0100 <akshitkr> hmm
2023-12-23 21:21:04 +0100 <akshitkr> certainly cleaner
2023-12-23 21:21:33 +0100 <akshitkr> cut down by a lot: https://paste.tomsmeding.com/OP0gEoq5
2023-12-23 21:22:14 +0100 <akshitkr> still some potential to refactor the first and final into one higher order function i guess
2023-12-23 21:25:22 +0100 <[exa]> looks sufficiently good to me
2023-12-23 21:25:30 +0100 <[exa]> like, there could be uncurry
2023-12-23 21:26:31 +0100 <akshitkr> uncurry?
2023-12-23 21:26:38 +0100 <[exa]> there could be list comprehension to replace the find (but that ain't gonna be much faster)
2023-12-23 21:26:48 +0100 <akshitkr> ah
2023-12-23 21:27:26 +0100 <[exa]> re uncurry, '(\(ind, x) -> x `T.isPrefixOf` string)' should be afaik the same as 'uncurry (flip T.isPrefixOf)'
2023-12-23 21:28:04 +0100 <[exa]> (in some libraries there's a conveniently pre-flipped hasPrefix version but not sure if in Text :D )
2023-12-23 21:29:32 +0100 <akshitkr> :t uncurry
2023-12-23 21:29:33 +0100 <lambdabot> (a -> b -> c) -> (a, b) -> c
2023-12-23 21:29:46 +0100 <akshitkr> oh right
2023-12-23 21:31:37 +0100son0p(~ff@181.136.122.143) (Ping timeout: 276 seconds)
2023-12-23 21:43:20 +0100son0p(~ff@181.136.122.143)
2023-12-23 21:44:34 +0100misterfish(~misterfis@84.53.85.146) (Ping timeout: 268 seconds)
2023-12-23 21:46:01 +0100Sgeo(~Sgeo@user/sgeo)
2023-12-23 22:00:40 +0100jargon(~jargon@15.sub-174-205-161.myvzw.com)
2023-12-23 22:01:31 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-12-23 22:07:54 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-12-23 22:13:05 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-12-23 22:13:41 +0100akshitkr(~user@49.205.47.187) (Ping timeout: 240 seconds)
2023-12-23 22:21:08 +0100petrichor(~znc-user@user/petrichor) (Quit: ZNC 1.8.2 - https://znc.in)
2023-12-23 22:38:18 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2023-12-23 22:53:36 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2023-12-23 22:57:29 +0100falafel(~falafel@12.50.119.139)
2023-12-23 22:59:27 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection)
2023-12-23 22:59:55 +0100qqq(~qqq@92.43.167.61)
2023-12-23 23:11:50 +0100falafel_(~falafel@173-245-203-52.iad.as54203.net)
2023-12-23 23:14:06 +0100falafel(~falafel@12.50.119.139) (Ping timeout: 245 seconds)
2023-12-23 23:17:23 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920) (Ping timeout: 268 seconds)
2023-12-23 23:27:10 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-12-23 23:33:17 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-12-23 23:34:02 +0100stef204(~stef204@user/stef204)
2023-12-23 23:41:23 +0100mxs(~mxs@user/mxs) (Ping timeout: 260 seconds)
2023-12-23 23:42:51 +0100APic(apic@apic.name) (Ping timeout: 245 seconds)
2023-12-23 23:42:54 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 260 seconds)
2023-12-23 23:43:32 +0100stef204(~stef204@user/stef204) (Quit: WeeChat 4.1.2)
2023-12-23 23:44:29 +0100son0p(~ff@181.136.122.143) (Ping timeout: 240 seconds)
2023-12-23 23:46:46 +0100myclm_(~myclm_@2a02:810d:8200:1628::8920)
2023-12-23 23:47:08 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2023-12-23 23:48:55 +0100xdminsy(~xdminsy@117.147.71.169) (Ping timeout: 255 seconds)
2023-12-23 23:49:01 +0100son0p(~ff@181.136.122.143)
2023-12-23 23:52:18 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2023-12-23 23:57:26 +0100son0p(~ff@181.136.122.143) (Ping timeout: 245 seconds)
2023-12-23 23:57:51 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 245 seconds)
2023-12-23 23:59:55 +0100emmanuelux(~emmanuelu@user/emmanuelux)