IRCBrowse

2023/11/13

2023-11-13 00:00:44 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-13 00:03:55 +0100_73(~anon_73__@2600:4040:5205:d800:21e8:9777:49a5:db28)
2023-11-13 00:06:41 +0100lhpitn_(~tn@mail.lebenshilfe-pi.de)
2023-11-13 00:06:43 +0100slac52794(~slack1256@2800:150:151:1a42:c06e:b7d:d50e:d5f6) (Remote host closed the connection)
2023-11-13 00:06:46 +0100_73(~anon_73__@2600:4040:5205:d800:21e8:9777:49a5:db28) (WeeChat 4.1.1)
2023-11-13 00:09:11 +0100Inst(~Inst@120.244.192.250)
2023-11-13 00:10:10 +0100lhpitn(~tn@mail.lebenshilfe-pi.de) (Ping timeout: 272 seconds)
2023-11-13 00:12:52 +0100zetef(~quassel@5.2.182.98) (Remote host closed the connection)
2023-11-13 00:15:47 +0100justache(~justache@user/justache) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-13 00:16:37 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-13 00:20:32 +0100justache(~justache@user/justache)
2023-11-13 00:20:48 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-11-13 00:21:18 +0100mechap(~mechap@user/mechap) (Ping timeout: 255 seconds)
2023-11-13 00:25:56 +0100 <zero> :t \f g -> uncurry g . (id &&& f)
2023-11-13 00:25:57 +0100 <lambdabot> (a -> b) -> (a -> b -> c) -> a -> c
2023-11-13 00:26:43 +0100 <zero> :t (<*>)
2023-11-13 00:26:44 +0100 <lambdabot> Applicative f => f (a -> b) -> f a -> f b
2023-11-13 00:26:47 +0100justache(~justache@user/justache) (Remote host closed the connection)
2023-11-13 00:27:20 +0100 <zero> :t \f g -> g <*> f
2023-11-13 00:27:21 +0100 <lambdabot> Applicative f => f a -> f (a -> b) -> f b
2023-11-13 00:27:25 +0100slack1256(~slack1256@191.126.186.232)
2023-11-13 00:29:32 +0100 <zero> how do you do that type application thing?
2023-11-13 00:30:51 +0100 <dsal> You mean just use type applications? You put a @T in for each of the type variables you want to specify from left to right.
2023-11-13 00:30:58 +0100 <dsal> You can ignore some with @_
2023-11-13 00:31:47 +0100 <zero> hmm
2023-11-13 00:31:55 +0100justache(~justache@user/justache)
2023-11-13 00:32:06 +0100 <zero> :t (<*>) @((->) r)
2023-11-13 00:32:35 +0100 <dsal> I'm not sure if lambdabot understands type applications.
2023-11-13 00:33:06 +0100 <zero> :t (<*>) @((->) Int)
2023-11-13 00:33:06 +0100 <lambdabot> error: parse error on input ‘->’
2023-11-13 00:33:14 +0100 <zero> oh
2023-11-13 00:33:36 +0100ft(~ft@p4fc2a529.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2023-11-13 00:33:40 +0100 <zero> well sorry for the noise then
2023-11-13 00:33:47 +0100 <dsal> % :t (<*>) @((->) _)
2023-11-13 00:33:47 +0100 <yahb2> (<*>) @((->) _) :: (w -> (a -> b)) -> (w -> a) -> w -> b
2023-11-13 00:34:01 +0100 <zero> dsal: that's it! ty
2023-11-13 00:34:59 +0100ft(~ft@p508db3bc.dip0.t-ipconnect.de)
2023-11-13 00:35:45 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-13 00:36:35 +0100sdz(~sdz@user/sdz) (Ping timeout: 260 seconds)
2023-11-13 00:37:05 +0100Jackneill(~Jackneill@20014C4E1E058A00F5A2357F979DDCC7.dsl.pool.telekom.hu) (Ping timeout: 252 seconds)
2023-11-13 00:38:06 +0100sdz(~sdz@user/sdz)
2023-11-13 00:40:53 +0100 <zero> % :t \f g h -> uncurry f . (g &&& h)
2023-11-13 00:40:53 +0100 <yahb2> <interactive>:1:26: error: ; • Variable not in scope: (&&&) :: t -> t1 -> a1 -> (a, b) ; • Perhaps you meant ‘&&’ (imported from Prelude)
2023-11-13 00:40:57 +0100 <zero> :t \f g h -> uncurry f . (g &&& h)
2023-11-13 00:40:58 +0100 <lambdabot> (a1 -> b -> c) -> (a2 -> a1) -> (a2 -> b) -> a2 -> c
2023-11-13 00:41:13 +0100 <zero> % :t liftA2 @((->) _)
2023-11-13 00:41:13 +0100 <yahb2> <interactive>:1:1: error: ; • Variable not in scope: liftA2 ; • Perhaps you meant one of these: ; ‘liftM2’ (imported from Control.Monad.State), ; ‘liftM’ (imported from Cont...
2023-11-13 00:41:25 +0100 <zero> % :t Control.Applicative.liftA2 @((->) _)
2023-11-13 00:41:25 +0100 <yahb2> Control.Applicative.liftA2 @((->) _) ; :: (a -> b -> c) -> (w -> a) -> (w -> b) -> w -> c
2023-11-13 00:45:15 +0100 <zero> ok so `f <*> g` === `liftA2 f id g`
2023-11-13 00:45:52 +0100 <ski> @type \f g h -> uncurry f . (g &&& h)
2023-11-13 00:45:53 +0100 <lambdabot> (a1 -> b -> c) -> (a2 -> a1) -> (a2 -> b) -> a2 -> c
2023-11-13 00:46:30 +0100 <ski> zero : rather `liftA2 id f g'
2023-11-13 00:48:00 +0100 <zero> that can't be right
2023-11-13 00:49:16 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 264 seconds)
2023-11-13 00:49:38 +0100 <zero> oh, i see my mistake
2023-11-13 00:50:02 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-13 00:50:09 +0100 <zero> wait
2023-11-13 00:50:37 +0100 <zero> ah, i see
2023-11-13 00:50:50 +0100 <zero> liftA2 q f g x = q (f x) (g x)
2023-11-13 00:51:15 +0100 <zero> id (f x) === f (id x)
2023-11-13 00:53:08 +0100 <ski> oh, i guess both works
2023-11-13 00:53:13 +0100 <zero> yes
2023-11-13 00:53:26 +0100 <zero> liftA2 id === flip liftA2 id
2023-11-13 00:53:28 +0100 <zero> is this right?
2023-11-13 00:55:02 +0100notzmv(~zmv@user/notzmv)
2023-11-13 00:55:24 +0100 <zero> i guess it is :)
2023-11-13 01:02:21 +0100tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2023-11-13 01:03:46 +0100 <ph88> Could someone give me some pointers on this non-compiling pseudo code? i have an idea about the types https://bpa.st/HA2Q perhaps getCompose can help but i'm not sure how to use that
2023-11-13 01:05:10 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-11-13 01:05:39 +0100 <Axman6> That's not how you use the State constructor
2023-11-13 01:05:53 +0100 <Axman6> I can't tell what you're actually trying to do
2023-11-13 01:08:12 +0100 <Axman6> Hmmm, maybe I can see - Compose might help, you can turn the State .. (Either .. a) into Compose (State ..) (Either ..) a using the Compose constructor, then you could use something like intersperse (pure $ Right Qux) $ map Compose [...], and then you probably want sequence before calling getCompose?
2023-11-13 01:09:02 +0100 <Axman6> :t \xs -> getCompose . sequence . intersperse (pure (Right True)) $ map Compose xs
2023-11-13 01:09:03 +0100 <lambdabot> forall k1 (f :: k1 -> *) (g :: * -> k1) a. Monad (Compose f g) => [f (g (Either a Bool))] -> f (g [Either a Bool])
2023-11-13 01:09:27 +0100 <[Leary]> :t \x -> getCompose . traverse Compose . intersperse x
2023-11-13 01:09:28 +0100 <lambdabot> forall k1 (f :: k1 -> *) (g :: * -> k1) b. Applicative (Compose f g) => f (g b) -> [f (g b)] -> f (g [b])
2023-11-13 01:10:09 +0100 <Axman6> surprised that monad constraint appeared in mine
2023-11-13 01:10:20 +0100 <[Leary]> Because sequence
2023-11-13 01:10:23 +0100 <Axman6> :t traverse Compose
2023-11-13 01:10:24 +0100 <lambdabot> forall k (t :: * -> *) (f :: k -> *) (g :: * -> k) b. (Traversable t, Applicative (Compose f g)) => t (f (g b)) -> Compose f g (t b)
2023-11-13 01:10:42 +0100 <Axman6> :t getCompose . traverse Compose
2023-11-13 01:10:43 +0100 <lambdabot> forall k1 (t :: * -> *) (f :: k1 -> *) (g :: * -> k1) b. (Traversable t, Applicative (Compose f g)) => t (f (g b)) -> f (g (t b))
2023-11-13 01:11:20 +0100ec_(~ec@gateway/tor-sasl/ec)
2023-11-13 01:11:26 +0100 <jackdk> % :m + Control.Lens Data.Functor.Compose
2023-11-13 01:11:26 +0100 <yahb2> <no location info>: error: ; Could not find module ‘Control.Lens’ ; It is not a module in the current program, or in any known package.
2023-11-13 01:11:28 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 264 seconds)
2023-11-13 01:11:39 +0100 <Axman6> :(
2023-11-13 01:12:33 +0100 <jackdk> alas. Anyway, `lens` gives you `ala Compose traverse :: (Traversable t, Applicative f, Applicative g) => t (f (g a)) -> f (g (t a))`
2023-11-13 01:13:46 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-13 01:15:10 +0100khumba(~khumba@user/khumba)
2023-11-13 01:15:13 +0100picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur) (Ping timeout: 258 seconds)
2023-11-13 01:15:49 +0100 <ph88> thanks Axman6 [Leary] .. is there any way that it can done more easily perhaps with pattern matching or do notation? i'm not familiar the compose
2023-11-13 01:18:19 +0100 <ph88> maybe i
2023-11-13 01:18:26 +0100 <ph88> maybe i'm using State in the wrong way
2023-11-13 01:18:31 +0100 <ph88> and i should do it inside of State
2023-11-13 01:18:32 +0100YoungFrog(~youngfrog@39.129-180-91.adsl-dyn.isp.belgacom.be) (Ping timeout: 255 seconds)
2023-11-13 01:18:34 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-11-13 01:22:29 +0100 <[Leary]> :t \x -> fmap sequenceA . sequenceA . intersperse x
2023-11-13 01:22:30 +0100 <lambdabot> (Applicative f1, Applicative f2) => f2 (f1 a) -> [f2 (f1 a)] -> f2 (f1 [a])
2023-11-13 01:22:38 +0100YoungFrog(~youngfrog@2a02:a03f:ca07:f900:b240:4be0:6188:1692)
2023-11-13 01:22:38 +0100 <[Leary]> :t \x -> runExceptT . traverse ExceptT . intersperse x
2023-11-13 01:22:39 +0100 <lambdabot> Monad m => m (Either e b) -> [m (Either e b)] -> m (Either e [b])
2023-11-13 01:25:42 +0100 <[Leary]> ph88: There are various ways, but they're pretty much all the same. I suggest you get familiar with Compose or EitherT; there's nothing particularly complicated or sophisticated going on there.
2023-11-13 01:26:41 +0100 <ski> (s/EitherT/ExceptT/)
2023-11-13 01:27:29 +0100 <[Leary]> Ah, yeah. EitherT/ExceptT/ErrorT; I can't even remember which ones happened and which is a figment of my imagination.
2023-11-13 01:28:15 +0100YoungFrog(~youngfrog@2a02:a03f:ca07:f900:b240:4be0:6188:1692) (Ping timeout: 240 seconds)
2023-11-13 01:28:16 +0100lottaquestions(~nick@2607:fa49:503d:b200:135c:2e9a:d788:4186) (Server closed connection)
2023-11-13 01:28:43 +0100lottaquestions(~nick@2607:fa49:503d:b200:bc96:53f6:bf3c:8b64)
2023-11-13 01:28:56 +0100_73(~anon_73@2600:4040:5205:d800:21e8:9777:49a5:db28)
2023-11-13 01:30:14 +0100 <geekosaur> iirc EitherT happened early and was removed in favor of ErrorT, then ExceptT was added and ErrorT was deprecated but apparently still exists
2023-11-13 01:31:17 +0100YuutaW(~YuutaW@2404:f4c0:f9c3:502::100:17b7) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-13 01:31:44 +0100YuutaW(~YuutaW@mail.yuuta.moe)
2023-11-13 01:33:05 +0100picnoir(~picnoir@about/aquilenet/vodoo/NinjaTrappeur)
2023-11-13 01:33:59 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 260 seconds)
2023-11-13 01:35:36 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-11-13 01:37:09 +0100_73(~anon_73@2600:4040:5205:d800:21e8:9777:49a5:db28) (Quit: Leaving)
2023-11-13 01:37:55 +0100_73(~anon_73@2600:4040:5205:d800:21e8:9777:49a5:db28)
2023-11-13 01:38:44 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a) (Remote host closed the connection)
2023-11-13 01:46:41 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 240 seconds)
2023-11-13 01:48:25 +0100zmt00(~zmt00@user/zmt00) (Server closed connection)
2023-11-13 01:48:50 +0100zmt00(~zmt00@user/zmt00)
2023-11-13 01:57:15 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-11-13 01:57:56 +0100alphastate_(~alphastat@176.254.244.83)
2023-11-13 01:59:41 +0100sudden(~cat@user/sudden) (Server closed connection)
2023-11-13 01:59:57 +0100sudden(~cat@user/sudden)
2023-11-13 02:00:01 +0100alphastate(~alphastat@176.254.244.83) (Ping timeout: 240 seconds)
2023-11-13 02:02:52 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-13 02:02:59 +0100yosef`(~yosef`@user/yosef/x-2947716)
2023-11-13 02:05:04 +0100img(~img@user/img)
2023-11-13 02:05:09 +0100ph88^(~ph88@2a02:8109:9e26:c800::302a)
2023-11-13 02:05:27 +0100yosef`(~yosef`@user/yosef/x-2947716) (Client Quit)
2023-11-13 02:05:33 +0100 <ph88^> somehow i got disconnected o_O
2023-11-13 02:06:22 +0100 <ph88^> thanks for the alternatives [Leary] i will try to study it
2023-11-13 02:06:59 +0100seeg123456(~seeg12345@64.176.64.83) (Server closed connection)
2023-11-13 02:10:11 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a)
2023-11-13 02:17:16 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 255 seconds)
2023-11-13 02:17:25 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-11-13 02:18:49 +0100Lord_of_Life_Lord_of_Life
2023-11-13 02:27:10 +0100yvan-sraka(sid419690@id-419690.lymington.irccloud.com) (Server closed connection)
2023-11-13 02:27:22 +0100yvan-sraka(sid419690@id-419690.lymington.irccloud.com)
2023-11-13 02:28:04 +0100 <EvanR> ExceptT for the sake of everyone coalescing around the same instance of a dumb type
2023-11-13 02:31:51 +0100lexi-lambda(sid92601@id-92601.hampstead.irccloud.com) (Server closed connection)
2023-11-13 02:32:00 +0100lexi-lambda(sid92601@id-92601.hampstead.irccloud.com)
2023-11-13 02:35:04 +0100dsal(sid13060@id-13060.lymington.irccloud.com) (Server closed connection)
2023-11-13 02:35:14 +0100dsal(sid13060@id-13060.lymington.irccloud.com)
2023-11-13 02:36:58 +0100euleritian(~euleritia@dynamic-046-114-207-173.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 02:37:16 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 02:46:47 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a) (Remote host closed the connection)
2023-11-13 02:47:02 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-11-13 02:48:31 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 264 seconds)
2023-11-13 02:48:51 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-11-13 02:52:23 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 02:58:49 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-13 03:00:01 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-11-13 03:00:41 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-11-13 03:01:28 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-13 03:07:36 +0100_xor(~xor@72.49.195.41)
2023-11-13 03:15:46 +0100otto_s(~user@p5b044554.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-11-13 03:16:34 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-11-13 03:17:03 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 03:17:21 +0100otto_s(~user@p5b044659.dip0.t-ipconnect.de)
2023-11-13 03:19:04 +0100_xor(~xor@72.49.195.41)
2023-11-13 03:27:37 +0100jinsun(~jinsun@user/jinsun) (Server closed connection)
2023-11-13 03:27:54 +0100jinsun(~jinsun@user/jinsun)
2023-11-13 03:30:45 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 255 seconds)
2023-11-13 03:31:41 +0100haskl(~haskl@user/haskl) (Ping timeout: 258 seconds)
2023-11-13 03:34:27 +0100Inst(~Inst@120.244.192.250)
2023-11-13 03:35:22 +0100haskl(~haskl@user/haskl)
2023-11-13 03:37:03 +0100CAT_S(apic@brezn3.muc.ccc.de) (Server closed connection)
2023-11-13 03:37:14 +0100CAT_S(apic@brezn3.muc.ccc.de)
2023-11-13 03:43:19 +0100slack1256(~slack1256@191.126.186.232) (Remote host closed the connection)
2023-11-13 03:49:18 +0100YoungFrog(~youngfrog@2a02:a03f:ca07:f900:b240:4be0:6188:1692)
2023-11-13 03:56:59 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 258 seconds)
2023-11-13 03:58:37 +0100ouroboros(~ouroboros@user/ouroboros) (Server closed connection)
2023-11-13 03:59:23 +0100ouroboros(~ouroboros@user/ouroboros)
2023-11-13 04:02:20 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-13 04:02:20 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-13 04:02:20 +0100finn_elijaFinnElija
2023-11-13 04:14:15 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 240 seconds)
2023-11-13 04:19:01 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2023-11-13 04:20:07 +0100td_(~td@i53870938.versanet.de) (Ping timeout: 255 seconds)
2023-11-13 04:22:01 +0100td_(~td@i5387093F.versanet.de)
2023-11-13 04:28:31 +0100nrr______(sid20938@id-20938.lymington.irccloud.com) (Server closed connection)
2023-11-13 04:28:49 +0100nrr______(sid20938@id-20938.lymington.irccloud.com)
2023-11-13 04:43:30 +0100hc(~hc@ip-185-104-142-44.hosts-fiberone.de) (Remote host closed the connection)
2023-11-13 04:51:05 +0100ec_(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-11-13 04:51:12 +0100razetime(~quassel@49.207.197.207)
2023-11-13 04:51:45 +0100ec(~ec@gateway/tor-sasl/ec)
2023-11-13 04:54:10 +0100razetime(~quassel@49.207.197.207) (Read error: Connection reset by peer)
2023-11-13 04:59:53 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-13 04:59:53 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-13 04:59:53 +0100finn_elijaFinnElija
2023-11-13 05:00:00 +0100Taneb(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (Quit: I seem to have stopped.)
2023-11-13 05:01:06 +0100Taneb(~Taneb@runciman.hacksoc.org)
2023-11-13 05:13:23 +0100aforemny_(~aforemny@2001:9e8:6ce5:8e00:9c3e:9c3b:5b8a:f18d)
2023-11-13 05:13:24 +0100poscat0x04(~poscat@user/poscat) (Ping timeout: 240 seconds)
2023-11-13 05:13:51 +0100poscat(~poscat@user/poscat)
2023-11-13 05:14:19 +0100aforemny(~aforemny@i59F516D8.versanet.de) (Ping timeout: 246 seconds)
2023-11-13 05:15:59 +0100 <Inst> It's way harder, I think, to get meta-guides on libraries, right?
2023-11-13 05:16:13 +0100 <Inst> In the sense of, how is a library designed, what interfaces are used, and so on?
2023-11-13 05:20:46 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-11-13 05:32:33 +0100poscat(~poscat@user/poscat) (Quit: Bye)
2023-11-13 05:39:43 +0100poscat(~poscat@user/poscat)
2023-11-13 05:41:56 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-13 05:42:23 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-13 05:50:01 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 246 seconds)
2023-11-13 05:51:44 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-13 06:00:01 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 255 seconds)
2023-11-13 06:02:08 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 252 seconds)
2023-11-13 06:03:42 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-13 06:04:05 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-11-13 06:04:09 +0100Inst(~Inst@120.244.192.250)
2023-11-13 06:05:43 +0100tabemann_(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net) (Server closed connection)
2023-11-13 06:06:16 +0100tabemann_(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net)
2023-11-13 06:07:19 +0100notzmv(~zmv@user/notzmv)
2023-11-13 06:11:27 +0100lightandlight(sid135476@id-135476.helmsley.irccloud.com) (Server closed connection)
2023-11-13 06:11:40 +0100lightandlight(sid135476@id-135476.helmsley.irccloud.com)
2023-11-13 06:19:30 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-13 06:19:53 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-13 06:20:07 +0100trev(~trev@user/trev)
2023-11-13 06:23:27 +0100juri_(~juri@84-19-175-187.pool.ovpn.com) (Server closed connection)
2023-11-13 06:23:43 +0100juri_(~juri@84-19-175-187.pool.ovpn.com)
2023-11-13 06:29:09 +0100fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-13 06:33:14 +0100michalz(~michalz@185.246.207.201)
2023-11-13 06:39:12 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1)
2023-11-13 06:39:37 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 255 seconds)
2023-11-13 06:47:47 +0100seeg123456(~seeg12345@64.176.64.83)
2023-11-13 07:03:27 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-11-13 07:03:45 +0100hc(~hc@ip-185-104-142-44.hosts-fiberone.de)
2023-11-13 07:13:45 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de)
2023-11-13 07:20:44 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-13 07:22:56 +0100acidjnk(~acidjnk@p200300d6e72b933384d06dff6b3ba200.dip0.t-ipconnect.de)
2023-11-13 07:23:45 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-11-13 07:25:56 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-13 07:27:28 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2023-11-13 07:28:39 +0100dmj`(sid72307@id-72307.hampstead.irccloud.com) (Server closed connection)
2023-11-13 07:29:04 +0100dmj`(sid72307@id-72307.hampstead.irccloud.com)
2023-11-13 07:32:01 +0100zaquest(~notzaques@5.130.79.72)
2023-11-13 07:34:12 +0100khumba(~khumba@user/khumba) ()
2023-11-13 07:36:30 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-11-13 07:40:51 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 258 seconds)
2023-11-13 07:47:02 +0100jjhoo(~jahakala@user/jjhoo) (Remote host closed the connection)
2023-11-13 07:57:36 +0100nshepperd2(nshepperd@2600:3c03::f03c:92ff:fe28:92c9) (Server closed connection)
2023-11-13 07:57:50 +0100nshepperd2(nshepperd@2600:3c03::f03c:92ff:fe28:92c9)
2023-11-13 07:59:46 +0100gmg(~user@user/gehmehgeh)
2023-11-13 08:03:15 +0100zetef(~quassel@95.77.17.251)
2023-11-13 08:16:10 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 08:18:31 +0100yosef`(~yosef`@user/yosef/x-2947716)
2023-11-13 08:19:47 +0100tengu1(~tengu1@2603-80a0-1600-004c-61b1-92ae-b4b5-d35d.res6.spectrum.com)
2023-11-13 08:21:00 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-13 08:26:49 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 246 seconds)
2023-11-13 08:27:34 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-11-13 08:28:19 +0100pie_(~pie_bnc@user/pie/x-2818909) (Server closed connection)
2023-11-13 08:28:29 +0100pie_(~pie_bnc@user/pie/x-2818909)
2023-11-13 08:31:04 +0100acidjnk(~acidjnk@p200300d6e72b933384d06dff6b3ba200.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-13 08:35:09 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-13 08:35:47 +0100jjhoo(~jahakala@user/jjhoo)
2023-11-13 08:37:12 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-13 08:45:10 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:7ba1:f09f:8b3c:2811)
2023-11-13 08:45:40 +0100sdz_(~sdz@user/sdz)
2023-11-13 08:45:55 +0100glguy_glguy
2023-11-13 08:46:24 +0100sdz(~sdz@user/sdz) (Ping timeout: 258 seconds)
2023-11-13 09:08:14 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5)
2023-11-13 09:10:56 +0100misterfish(~misterfis@g250100.upc-g.chello.nl)
2023-11-13 09:11:47 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 09:12:10 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de)
2023-11-13 09:12:23 +0100[_][`itchyjunk`]
2023-11-13 09:13:08 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 09:13:25 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 09:17:01 +0100ivan__(~ivan__@2001:818:ea58:9200:959a:5da9:e3a0:5e1e)
2023-11-13 09:18:01 +0100ACuriousMoose(~ACuriousM@142.166.18.53) (Server closed connection)
2023-11-13 09:18:21 +0100ACuriousMoose(~ACuriousM@142.166.18.53)
2023-11-13 09:18:36 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 258 seconds)
2023-11-13 09:19:32 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de)
2023-11-13 09:29:42 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-13 09:33:29 +0100ivan__(~ivan__@2001:818:ea58:9200:959a:5da9:e3a0:5e1e) (Remote host closed the connection)
2023-11-13 09:36:58 +0100ivan__(~ivan__@2001:818:ea58:9200:959a:5da9:e3a0:5e1e)
2023-11-13 09:38:31 +0100fendor(~fendor@2a02:8388:1640:be00:ca17:ceee:5bbe:1594)
2023-11-13 09:46:55 +0100ivan__(~ivan__@2001:818:ea58:9200:959a:5da9:e3a0:5e1e) (Remote host closed the connection)
2023-11-13 09:53:24 +0100landonf(landonf@mac68k.info) (Server closed connection)
2023-11-13 09:53:34 +0100landonf(landonf@mac68k.info)
2023-11-13 09:54:11 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-13 09:54:29 +0100kimiamania46(~b4f4a2ab@user/kimiamania) (Quit: Ping timeout (120 seconds))
2023-11-13 09:54:55 +0100kimiamania46(~b4f4a2ab@user/kimiamania)
2023-11-13 09:58:58 +0100 <haskellbridge> 12<C​elestial> Does anyone have that article which talked about why recursion is introduced badly a lot of times?
2023-11-13 09:59:05 +0100 <haskellbridge> 12<C​elestial> I believe that was here somewhere
2023-11-13 10:07:39 +0100siw5ohs0(~aiw5ohs0@user/aiw5ohs0)
2023-11-13 10:08:42 +0100siw5ohs0(~aiw5ohs0@user/aiw5ohs0) (Leaving)
2023-11-13 10:08:52 +0100euleritian(~euleritia@dynamic-046-114-203-037.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 10:09:09 +0100euleritian(~euleritia@77.22.252.56)
2023-11-13 10:11:15 +0100kuribas(~user@2a02:1808:7:44f1:c2bd:6ec:bd3b:9ae0)
2023-11-13 10:14:15 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-11-13 10:16:01 +0100Jackneill(~Jackneill@20014C4E1E058A00375EBC4DD70FB6A2.dsl.pool.telekom.hu)
2023-11-13 10:16:48 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-11-13 10:20:30 +0100dunj3(~dunj3@kingdread.de)
2023-11-13 10:21:47 +0100zetef(~quassel@95.77.17.251)
2023-11-13 10:24:00 +0100kuribas`(~user@ip-188-118-57-242.reverse.destiny.be)
2023-11-13 10:26:19 +0100kuribas(~user@2a02:1808:7:44f1:c2bd:6ec:bd3b:9ae0) (Ping timeout: 264 seconds)
2023-11-13 10:26:44 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-13 10:28:02 +0100ft(~ft@p508db3bc.dip0.t-ipconnect.de) (Quit: leaving)
2023-11-13 10:36:22 +0100yosef`(~yosef`@user/yosef/x-2947716) (Ping timeout: 250 seconds)
2023-11-13 10:39:03 +0100misterfish(~misterfis@g250100.upc-g.chello.nl) (Ping timeout: 260 seconds)
2023-11-13 10:42:13 +0100danse-nr3(~danse@151.35.192.83)
2023-11-13 10:46:40 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-11-13 10:48:40 +0100ec(~ec@gateway/tor-sasl/ec) (Read error: Connection reset by peer)
2023-11-13 10:49:02 +0100ec(~ec@gateway/tor-sasl/ec)
2023-11-13 10:49:42 +0100tengu1(~tengu1@2603-80a0-1600-004c-61b1-92ae-b4b5-d35d.res6.spectrum.com) (Quit: Client closed)
2023-11-13 10:54:37 +0100misterfish(~misterfis@87.215.131.102)
2023-11-13 10:55:12 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 258 seconds)
2023-11-13 10:57:54 +0100__monty__(~toonn@user/toonn)
2023-11-13 11:00:00 +0100cyphase(~cyphase@user/cyphase)
2023-11-13 11:03:05 +0100califax_(~califax@user/califx)
2023-11-13 11:03:40 +0100califax(~califax@user/califx) (Ping timeout: 264 seconds)
2023-11-13 11:04:24 +0100califax_califax
2023-11-13 11:06:13 +0100gmg(~user@user/gehmehgeh) (Read error: Connection reset by peer)
2023-11-13 11:06:14 +0100jpds1(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-13 11:06:33 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-13 11:06:43 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-13 11:06:55 +0100gmg(~user@user/gehmehgeh)
2023-11-13 11:10:01 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 260 seconds)
2023-11-13 11:11:01 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com) (Remote host closed the connection)
2023-11-13 11:13:01 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-13 11:14:36 +0100cyphase(~cyphase@user/cyphase)
2023-11-13 11:16:10 +0100Lycurgus_(~georg@li1192-118.members.linode.com)
2023-11-13 11:16:46 +0100chele(~chele@user/chele)
2023-11-13 11:18:39 +0100Lycurgus_(~georg@li1192-118.members.linode.com) (Client Quit)
2023-11-13 11:20:17 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-13 11:23:10 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-13 11:24:20 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-11-13 11:26:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 11:28:42 +0100nilradical(~nilradica@user/naso)
2023-11-13 11:29:14 +0100nilradical(~nilradica@user/naso) (Client Quit)
2023-11-13 11:30:25 +0100hc_(~hc@mail.hce.li)
2023-11-13 11:30:28 +0100hc(~hc@ip-185-104-142-44.hosts-fiberone.de) (Quit: leaving)
2023-11-13 11:30:33 +0100hc_hc
2023-11-13 11:30:55 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 246 seconds)
2023-11-13 11:31:43 +0100sdz_(~sdz@user/sdz) (Ping timeout: 264 seconds)
2023-11-13 11:38:34 +0100sdz(~sdz@user/sdz)
2023-11-13 11:39:40 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 264 seconds)
2023-11-13 11:41:51 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-11-13 11:45:28 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-13 11:51:33 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-13 11:55:55 +0100billchenchina(~billchenc@2a0d:2580:ff0c:1:e3c9:c52b:a429:5bfe)
2023-11-13 11:58:51 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-11-13 11:59:12 +0100califax(~califax@user/califx)
2023-11-13 11:59:36 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:7ba1:f09f:8b3c:2811) (Ping timeout: 258 seconds)
2023-11-13 12:00:04 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-11-13 12:00:29 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-11-13 12:04:09 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 260 seconds)
2023-11-13 12:05:23 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5) (Ping timeout: 260 seconds)
2023-11-13 12:07:36 +0100mhatta(~mhatta@www21123ui.sakura.ne.jp)
2023-11-13 12:17:41 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 12:22:39 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-13 12:36:41 +0100 <danse-nr3> friday evening: interesting problem, it will be nice to look at it with fresh eyes!
2023-11-13 12:36:41 +0100 <danse-nr3> monday morning: where do i start from?
2023-11-13 12:36:41 +0100 <danse-nr3> in between: most local brain cache was wiped
2023-11-13 12:38:59 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1) (Ping timeout: 260 seconds)
2023-11-13 12:39:28 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5)
2023-11-13 12:42:08 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:b8cc:9457:893c:f87e)
2023-11-13 12:42:16 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2023-11-13 12:43:53 +0100Angelz(Angelz@2605:6400:30:fc15:d55b:fa6c:bd14:9973) (Server closed connection)
2023-11-13 13:00:52 +0100Angelz(Angelz@2605:6400:30:fc15:9bd1:2217:41cd:bb15)
2023-11-13 13:06:49 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Ping timeout: 246 seconds)
2023-11-13 13:08:13 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 246 seconds)
2023-11-13 13:08:55 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de)
2023-11-13 13:09:32 +0100danse-nr3(~danse@151.35.192.83) (Ping timeout: 255 seconds)
2023-11-13 13:10:21 +0100danse-nr3(~danse@151.47.236.20)
2023-11-13 13:12:24 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-13 13:12:51 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 13:13:08 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 13:14:57 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-13 13:15:11 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Server closed connection)
2023-11-13 13:18:54 +0100 <ph88^> [Leary], Axman6 i was able to solve it with sequenceA i used more intermediate steps and put type annotations to see what changes step by step https://bpa.st/AMCQ
2023-11-13 13:19:44 +0100 <danse-nr3> this of adding intermediate annotations is a life saver at times
2023-11-13 13:21:12 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-13 13:26:51 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1)
2023-11-13 13:28:04 +0100lottaquestions(~nick@2607:fa49:503d:b200:bc96:53f6:bf3c:8b64) (Quit: Konversation terminated!)
2023-11-13 13:30:14 +0100lottaquestions(~nick@2607:fa49:503d:b200:6f8c:dc97:9c02:d6b9)
2023-11-13 13:31:51 +0100 <[Leary]> :t \x -> getCompose . getAp . foldMap (Ap . Compose) . intersperse x
2023-11-13 13:31:52 +0100 <lambdabot> forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). Monoid (Ap (Compose f g) a) => f (g a) -> [f (g a)] -> f (g a)
2023-11-13 13:32:18 +0100 <[Leary]> ph88^: Since you want to fold it down, you can actually skip the `sequenceA`s and do it all at once. ^
2023-11-13 13:38:29 +0100 <ph88^> [Leary], you mean with that line you just posted? Such lines are hard to read for me, i tried before i always have to break them down in steps
2023-11-13 13:40:11 +0100 <ph88^> i could learn Ap and Compose, but should i ? is the only benefit to be able to write one liners ?
2023-11-13 13:40:20 +0100zerozzz
2023-11-13 13:42:22 +0100anpad(~pandeyan@user/anpad) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-13 13:44:23 +0100anpad(~pandeyan@user/anpad)
2023-11-13 13:44:54 +0100 <danse-nr3> haskell's efforts for abstraction are knowingly geared towards writing oneliners
2023-11-13 13:45:50 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-13 13:47:30 +0100 <sshine> you make it sound hacky :P
2023-11-13 13:48:05 +0100edr(~edr@user/edr)
2023-11-13 13:53:04 +0100phma(phma@2001:5b0:210b:a318:44a0:81b9:3949:19d6) (Read error: Connection reset by peer)
2023-11-13 13:53:59 +0100phma(phma@2001:5b0:211f:6428:acc1:d82a:ec2e:4fd2)
2023-11-13 13:55:28 +0100 <[Leary]> ph88^: In a fraction of the time you've already spent on this problem, you could have learnt the purpose and use of both `Ap` and `Compose`. You'd then have two fine new tools in your toolbox, ready to help you easily solve not just this one problem, but an endless host of similar problems.
2023-11-13 13:55:48 +0100 <[Leary]> That said, all they're doing is lifting Applicative and Monoid over Applicative. You can do it manually:
2023-11-13 13:55:51 +0100 <[Leary]> :t \x -> foldr (liftA2 (liftA2 (<>))) (pure (pure mempty)) . intersperse x
2023-11-13 13:55:52 +0100 <lambdabot> (Applicative f1, Applicative f2, Monoid c) => f1 (f2 c) -> [f1 (f2 c)] -> f1 (f2 c)
2023-11-13 13:56:11 +0100 <danse-nr3> % :i Ap
2023-11-13 13:56:11 +0100 <yahb2> <interactive>:1:1: error: Not in scope: ‘Ap’
2023-11-13 13:56:22 +0100 <danse-nr3> @hoogle Ap
2023-11-13 13:56:22 +0100 <lambdabot> Data.Monoid newtype Ap f a
2023-11-13 13:56:22 +0100 <lambdabot> Data.Monoid Ap :: f a -> Ap f a
2023-11-13 13:56:22 +0100 <lambdabot> Test.Tasty.Runners newtype Ap f a
2023-11-13 13:56:31 +0100 <danse-nr3> % :i Data.Monoid.Ap
2023-11-13 13:56:31 +0100 <yahb2> type role Data.Monoid.Ap representational nominal ; type Data.Monoid.Ap :: forall {k}. (k -> *) -> k -> * ; newtype Data.Monoid.Ap f a ; = Data.Monoid.Ap {Data.Monoid.getAp :: f a} ; -- Define...
2023-11-13 13:56:59 +0100 <danse-nr3> /type role/... fancy
2023-11-13 13:59:42 +0100 <ph88^> [Leary], thanks !
2023-11-13 13:59:51 +0100 <ph88^> danse-nr3, thanks too
2023-11-13 14:00:10 +0100danse-nr3did nothing once again ^^
2023-11-13 14:00:26 +0100 <danse-nr3> but you are welcome :P
2023-11-13 14:06:04 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 264 seconds)
2023-11-13 14:06:59 +0100kiriakos(~kiriakos@p57b64ab9.dip0.t-ipconnect.de)
2023-11-13 14:07:29 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-11-13 14:08:30 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-11-13 14:08:52 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-11-13 14:10:09 +0100danse-nr3(~danse@151.47.236.20) (Ping timeout: 260 seconds)
2023-11-13 14:11:55 +0100 <Athas> tomsmeding: is there an up-to-date guide for how to set up Accelerate with GPU execution?
2023-11-13 14:12:06 +0100 <Athas> I need a specific version of GHC, right? And what about LLVM?
2023-11-13 14:15:23 +0100 <Athas> Oh, there's a stack.yaml here...
2023-11-13 14:16:18 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-13 14:16:18 +0100ChanServ+v haskellbridge
2023-11-13 14:17:11 +0100zetef(~quassel@95.77.17.251)
2023-11-13 14:17:35 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-13 14:17:59 +0100zetef(~quassel@95.77.17.251) (Remote host closed the connection)
2023-11-13 14:18:39 +0100zetef(~quassel@95.77.17.251)
2023-11-13 14:24:11 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-13 14:25:33 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-11-13 14:25:51 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de)
2023-11-13 14:28:57 +0100 <ph88^> hi Athas
2023-11-13 14:29:15 +0100 <Athas> Hi ph88^
2023-11-13 14:32:23 +0100michalz(~michalz@185.246.207.201) (Remote host closed the connection)
2023-11-13 14:32:58 +0100michalz(~michalz@185.246.207.217)
2023-11-13 14:33:15 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Server closed connection)
2023-11-13 14:33:23 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru)
2023-11-13 14:35:48 +0100srk(~sorki@user/srk) (Ping timeout: 240 seconds)
2023-11-13 14:41:55 +0100danse-nr3(~danse@151.47.236.20)
2023-11-13 14:47:11 +0100misterfish(~misterfis@87.215.131.102) (Ping timeout: 255 seconds)
2023-11-13 14:50:16 +0100 <ph88^> [State Foo Bar] how can i filter this list on Bar ?
2023-11-13 14:50:32 +0100 <bwe> I've isolated two functions to consume majority of execution time. What's the go to way to profile their inner workings? I want to hunt down those things that consume major chunks of time.
2023-11-13 14:51:23 +0100 <Athas> ph88^: it's sort of weird to have a list of monadic actions, and strictly speaking you cannot filter it. You can use 'sequence' to turn it into 'State Foo [Bar]', and then you can just filter it.
2023-11-13 14:51:43 +0100 <ph88^> bwe, you can add cost centres on parts of your functions with annotations
2023-11-13 14:53:15 +0100 <ph88^> Athas, how come it is weird to have a list of monadic actions ?
2023-11-13 14:53:40 +0100 <Athas> ph88^: how do you create them? What do you end up doing with them?
2023-11-13 14:53:58 +0100 <Athas> There are cases where it makes sense, but often it's just a symptom that you used 'map' instead of 'mapM'.
2023-11-13 14:54:25 +0100 <bwe> ph88^: how can I run `cabal repl` with RTS enabled?
2023-11-13 14:54:55 +0100 <ph88^> bwe, https://well-typed.com/blog/2023/03/prof-late/ https://downloads.haskell.org/ghc/latest/docs/users_guide/profiling.html#cost-centres-and-cost-cen… https://www.tweag.io/blog/2020-01-30-haskell-profiling/
2023-11-13 14:55:08 +0100 <danse-nr3> % minimum $ sort [0..100_000_000]
2023-11-13 14:55:08 +0100 <yahb2> <interactive>:85:11: error: ; • Variable not in scope: sort :: [a0] -> t0 a ; • Perhaps you meant ‘sqrt’ (imported from Prelude)
2023-11-13 14:55:31 +0100 <danse-nr3> % minimum [0..100_000_000]
2023-11-13 14:55:33 +0100 <yahb2> <timeout>
2023-11-13 14:56:09 +0100 <ph88^> bwe, do you mean rts options? i don't get your question
2023-11-13 14:56:53 +0100 <bwe> ph88^: yes
2023-11-13 14:57:57 +0100 <ph88^> bwe, i'm not sure. what option do you want to pass and what command did you try ?
2023-11-13 15:00:32 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-11-13 15:01:30 +0100 <bwe> ph88^: I'd like to run `cabal repl` with +RTS -p options, like https://downloads.haskell.org/~ghc/9.0.1/docs/html/users_guide/profiling.html#cost-centres-and-cos… specifies
2023-11-13 15:01:58 +0100 <bwe> (I'd like to run the function and create the profile report within a cabal repl session
2023-11-13 15:04:35 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 15:05:19 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 264 seconds)
2023-11-13 15:05:25 +0100terrorjack(~terrorjac@2a01:4f8:c17:87f8::) (Server closed connection)
2023-11-13 15:05:31 +0100 <ph88^> bwe, https://github.com/haskell/cabal/issues/8641
2023-11-13 15:06:25 +0100terrorjack(~terrorjac@2a01:4f8:c17:87f8::)
2023-11-13 15:06:41 +0100dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 240 seconds)
2023-11-13 15:06:56 +0100 <ph88^> when you run cabal you can pass rts options to cabal, ghc, ghci/program 3 different things to pass options too ^^
2023-11-13 15:07:29 +0100friendshipaka(~Friendshi@user/Friendship)
2023-11-13 15:08:15 +0100Friendship(~Friendshi@user/Friendship) (Ping timeout: 255 seconds)
2023-11-13 15:32:23 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-11-13 15:34:09 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5) (Ping timeout: 260 seconds)
2023-11-13 15:34:43 +0100CiaoSen(~Jura@5.83.177.67)
2023-11-13 15:35:39 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 15:35:58 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 15:39:43 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-13 15:41:21 +0100srk(~sorki@user/srk)
2023-11-13 15:44:32 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-11-13 15:44:53 +0100 <bwe> now I've got a profiling report, however it does not show the specific calls within function `f` I want to profile. How can I focus only on that function's inner workings?
2023-11-13 15:49:43 +0100fweht(uid404746@id-404746.lymington.irccloud.com)
2023-11-13 15:53:03 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-13 15:54:13 +0100danse-nr3(~danse@151.47.236.20) (Ping timeout: 260 seconds)
2023-11-13 15:56:37 +0100Inst(~Inst@120.244.192.250)
2023-11-13 15:59:04 +0100dibblego(~dibblego@122-199-1-93.ip4.superloop.au)
2023-11-13 15:59:04 +0100dibblego(~dibblego@122-199-1-93.ip4.superloop.au) (Changing host)
2023-11-13 15:59:04 +0100dibblego(~dibblego@haskell/developer/dibblego)
2023-11-13 16:00:17 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-13 16:00:51 +0100danse-nr3(~danse@151.47.236.20)
2023-11-13 16:01:33 +0100dibblego(~dibblego@haskell/developer/dibblego) (Excess Flood)
2023-11-13 16:01:50 +0100dibblego(~dibblego@122-199-1-93.ip4.superloop.au)
2023-11-13 16:01:51 +0100dibblego(~dibblego@122-199-1-93.ip4.superloop.au) (Changing host)
2023-11-13 16:01:51 +0100dibblego(~dibblego@haskell/developer/dibblego)
2023-11-13 16:02:38 +0100Desyt(~Desyt@145.136.157.47)
2023-11-13 16:05:01 +0100Shock_(~shOkEy@77-234-80-134.pool.digikabel.hu) (Ping timeout: 240 seconds)
2023-11-13 16:07:02 +0100Shock_(~shOkEy@178-164-235-249.pool.digikabel.hu)
2023-11-13 16:10:18 +0100kiriakos(~kiriakos@p57b64ab9.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-13 16:19:10 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 16:24:05 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-11-13 16:24:24 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-13 16:36:20 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-13 16:36:31 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-11-13 16:36:49 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de)
2023-11-13 16:37:25 +0100euleritian(~euleritia@dynamic-046-114-206-152.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 16:37:42 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 16:44:27 +0100CiaoSen(~Jura@5.83.177.67) (Ping timeout: 260 seconds)
2023-11-13 16:49:29 +0100danse-nr3(~danse@151.47.236.20) (Read error: Connection reset by peer)
2023-11-13 16:50:04 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (Quit: WeeChat 4.1.1)
2023-11-13 16:50:09 +0100danse-nr3(~danse@151.47.236.20)
2023-11-13 16:53:25 +0100alp(~alp@2001:861:5e02:eff0:bb06:f56f:3244:15c0)
2023-11-13 16:53:41 +0100alp(~alp@2001:861:5e02:eff0:bb06:f56f:3244:15c0) (Changing host)
2023-11-13 16:53:41 +0100alp(~alp@user/alp)
2023-11-13 16:53:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Remote host closed the connection)
2023-11-13 16:54:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-13 16:54:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 16:56:58 +0100Desyt(~Desyt@145.136.157.47) (Quit: Client closed)
2023-11-13 16:57:29 +0100mechap(~mechap@user/mechap)
2023-11-13 16:58:34 +0100 <Inst> hope this isn't too trollish
2023-11-13 16:58:35 +0100 <Inst> http://blog.ezyang.com/2010/10/rapid-prototyping-in-haskell/
2023-11-13 17:01:29 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:b8cc:9457:893c:f87e) (Quit: WeeChat 3.5)
2023-11-13 17:04:19 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5)
2023-11-13 17:04:53 +0100absence(torgeihe@hildring.pvv.ntnu.no) (Ping timeout: 252 seconds)
2023-11-13 17:06:57 +0100danse-nr3(~danse@151.47.236.20) (Read error: Connection reset by peer)
2023-11-13 17:07:54 +0100danse-nr3(~danse@151.35.241.49)
2023-11-13 17:09:05 +0100 <danse-nr3> i do not find it trolling, nor too convincing. But then i am also not sure that scripting should be considered such a specific coding activity
2023-11-13 17:11:19 +0100sabino(~sabino@user/sabino)
2023-11-13 17:15:02 +0100acidjnk(~acidjnk@p200300d6e72b933384d06dff6b3ba200.dip0.t-ipconnect.de)
2023-11-13 17:16:32 +0100notzmv(~zmv@user/notzmv)
2023-11-13 17:18:35 +0100 <Inst> It was just something interesting I found, I'm not willing to back it up, and should write Haskell more before I try to argue for Haskell used / abused in this manner.
2023-11-13 17:19:38 +0100 <danse-nr3> why would it be abused? Also, you seem to be quite advanced in haskell. More than a beginner for sure
2023-11-13 17:21:29 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 260 seconds)
2023-11-13 17:22:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Remote host closed the connection)
2023-11-13 17:25:24 +0100justache(~justache@user/justache) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-13 17:26:21 +0100justache(~justache@user/justache)
2023-11-13 17:27:16 +0100 <Inst> I'm actually a beginner in Haskell
2023-11-13 17:27:26 +0100 <Inst> I just hung around people to learn all the weird hacks and tricks too much
2023-11-13 17:27:53 +0100caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-11-13 17:29:21 +0100justache(~justache@user/justache) (Remote host closed the connection)
2023-11-13 17:30:03 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-13 17:30:49 +0100 <danse-nr3> so you said, writing more would make you feel beyond beginner? Which % of haskell do you use at work?
2023-11-13 17:31:04 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 246 seconds)
2023-11-13 17:32:31 +0100justache(~justache@user/justache)
2023-11-13 17:36:09 +0100 <Inst> I'm not a professional, just a beginner :(
2023-11-13 17:36:12 +0100 <Inst> Hobbyist
2023-11-13 17:36:31 +0100 <Inst> danse-nr3: the theory I'm entertaining is that all the crazies who are pushing for unidiomatic Haskell, there is actually a place for them
2023-11-13 17:36:39 +0100 <Inst> It's called small-scale script
2023-11-13 17:37:04 +0100 <Inst> That's why I'm trying to consider scripting as a specific coding activity, i.e, if it's a small-scale, single-use script that's not intended to be reused, sure, go crazy, be unidiomatic
2023-11-13 17:37:14 +0100 <Inst> but beyond that scale and specific use case, please write idiomatic Haskell
2023-11-13 17:37:36 +0100 <Inst> And then everyone is at peace.
2023-11-13 17:39:41 +0100Shock_(~shOkEy@178-164-235-249.pool.digikabel.hu) (Ping timeout: 240 seconds)
2023-11-13 17:40:37 +0100 <danse-nr3> makes sense to me. Scripting is a way to start, one never knows where it will end
2023-11-13 17:41:48 +0100Shock_(~shOkEy@84-236-21-62.pool.digikabel.hu)
2023-11-13 17:48:10 +0100 <ddellacosta> I dunno, I feel like you have to have a good grasp of Haskell to script in it effectively, and furthermore it's a different enough mode of using Haskell that you'd fail, as a beginner, to gain insight into some of Haskell's greatest strengths, like how useful a typechecker can be in refactoring when you leverage Haskell's type system effectively. But at the same time maybe there's value in
2023-11-13 17:48:12 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-13 17:48:12 +0100 <ddellacosta> learning how to pipe together commands in IO to get code running before you start really learning the language "for real?" I dunno
2023-11-13 17:49:41 +0100 <ddellacosta> I mean, I suppose it depends on who exactly we're talking about here, not sure I know who the crazies are under discussion
2023-11-13 17:50:21 +0100 <danse-nr3> huh maybe i missed some really ugly pattern in there, just skimmed through it to be honest. What is this? Can you make an instance with the interpreter?
2023-11-13 17:51:02 +0100 <danse-nr3> or just paste a snippet?
2023-11-13 17:51:04 +0100justachejustThanks
2023-11-13 17:53:43 +0100m5zs7k(aquares@web10.mydevil.net) (Ping timeout: 255 seconds)
2023-11-13 17:54:20 +0100m5zs7k(aquares@web10.mydevil.net)
2023-11-13 17:57:38 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 17:59:51 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-11-13 18:01:37 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5) (Ping timeout: 260 seconds)
2023-11-13 18:03:17 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-13 18:06:17 +0100AlexNoo_(~AlexNoo@178.34.162.228)
2023-11-13 18:06:59 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-11-13 18:09:34 +0100AlexZenon(~alzenon@94.233.241.129) (Ping timeout: 246 seconds)
2023-11-13 18:09:34 +0100AlexNoo(~AlexNoo@94.233.241.129) (Ping timeout: 246 seconds)
2023-11-13 18:12:53 +0100 <kaol> @pl \f -> (f <$> pure 1 <*> pure 2)
2023-11-13 18:12:53 +0100 <lambdabot> (<$> pure 1 <*> pure 2)
2023-11-13 18:13:04 +0100 <kaol> Which extension makes that valid syntax?
2023-11-13 18:14:16 +0100 <ski> none, i think
2023-11-13 18:14:19 +0100 <ski> (unfortunately)
2023-11-13 18:14:31 +0100sdz(~sdz@user/sdz) (Ping timeout: 260 seconds)
2023-11-13 18:14:55 +0100 <ski> (`pl' may be confused about the precedence levels, there)
2023-11-13 18:15:27 +0100 <dolio> Yeah, it seems to think it's (f <$> (pure 1 <*> pure 2))
2023-11-13 18:16:11 +0100 <geekosaur> it doesn't know about <$> or <*> at all
2023-11-13 18:16:16 +0100 <ski> (i've previously thought such "extended/chained sections" could be nice)
2023-11-13 18:16:33 +0100 <dolio> Yeah, I've definitely wanted them before.
2023-11-13 18:16:45 +0100 <geekosaur> so have I once or twice
2023-11-13 18:17:00 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 240 seconds)
2023-11-13 18:17:19 +0100 <danse-nr3> % :t \f -> f <$> pure 1 <*> pure 2
2023-11-13 18:17:20 +0100 <yahb2> \f -> f <$> pure 1 <*> pure 2 ; :: (Applicative f, Num a1, Num a2) => (a1 -> a2 -> b) -> f b
2023-11-13 18:17:38 +0100 <kaol> I'm writing some parsec code and it'd be nice to do "try (SomeType <$> foo <*> bar) >>= (<$> bar <*> asfd)"
2023-11-13 18:17:46 +0100 <ski> yahb2's parsing it correctly (of course)
2023-11-13 18:18:26 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-11-13 18:18:43 +0100 <dolio> Is that really much better than introducing the variable?
2023-11-13 18:19:05 +0100 <kaol> No, but it's admitting defeat.
2023-11-13 18:20:34 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-13 18:21:46 +0100hippoid(~hippoid@user/hippoid)
2023-11-13 18:22:04 +0100Square(~Square@user/square)
2023-11-13 18:23:14 +0100 <mauke> @pl \f -> (f <$> pure 1) <*> pure 2
2023-11-13 18:23:14 +0100 <lambdabot> (<*> pure 2) . (<$> pure 1)
2023-11-13 18:23:18 +0100AlexZenon(~alzenon@178.34.162.228)
2023-11-13 18:23:57 +0100 <mauke> wait, >>= into fmap? how does that make sense
2023-11-13 18:24:18 +0100ski. o O ( `[> [< try [> SomeType [<foo>] [<bar>] <] >] [<bar>] [<asfd>] <]' )
2023-11-13 18:24:25 +0100 <mauke> shouldn't it be try (...) <*> bar <*> asfd?
2023-11-13 18:24:37 +0100 <dminuoso> Which black magic lens operator turned a function into a lens again?
2023-11-13 18:24:46 +0100 <dminuoso> Or well, s/operator/combinator/
2023-11-13 18:24:47 +0100 <dolio> I wonder why pl defaults to infixr.
2023-11-13 18:28:05 +0100 <kaol> mauke: Thanks. Now I feel silly for not spotting that.
2023-11-13 18:29:42 +0100 <ski> @type \mf ma mb -> Text.Parsec.try mf >>= \f -> f <$> ma <*> mb
2023-11-13 18:29:43 +0100 <lambdabot> Text.Parsec.Prim.ParsecT s u m (a1 -> a2 -> b) -> Text.Parsec.Prim.ParsecT s u m a1 -> Text.Parsec.Prim.ParsecT s u m a2 -> Text.Parsec.Prim.ParsecT s u m b
2023-11-13 18:29:44 +0100 <ski> @type \mf ma mb -> Text.Parsec.try mf <*> ma <*> mb
2023-11-13 18:29:45 +0100 <lambdabot> Text.Parsec.Prim.ParsecT s u m (a1 -> a2 -> b) -> Text.Parsec.Prim.ParsecT s u m a1 -> Text.Parsec.Prim.ParsecT s u m a2 -> Text.Parsec.Prim.ParsecT s u m b
2023-11-13 18:35:05 +0100thegeekinside(~thegeekin@189.141.80.123)
2023-11-13 18:41:38 +0100n0den1te(~aaaa@223.178.83.62)
2023-11-13 18:46:48 +0100n0den1te(~aaaa@223.178.83.62) (Remote host closed the connection)
2023-11-13 18:49:12 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-13 18:49:49 +0100 <ddellacosta> dminuoso: were you thinking of https://hackage.haskell.org/package/lens-5.2.3/docs/Control-Lens-Combinators.html#v:to ?
2023-11-13 18:50:29 +0100kuribas`(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-11-13 18:51:10 +0100 <mauke> that looks insufficiently evil
2023-11-13 18:51:10 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-13 18:51:31 +0100 <tomsmeding> Athas: no good pre-made guide unfortunately
2023-11-13 18:51:32 +0100 <ddellacosta> haha
2023-11-13 18:51:54 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-11-13 18:51:57 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 18:51:58 +0100 <tomsmeding> I think I gave an overview a couple of days ago, did that work? Or are you looking for something for students (or CFAL)?
2023-11-13 18:53:56 +0100_xor(~xor@72.49.195.41)
2023-11-13 18:54:11 +0100 <Athas> tomsmeding: yeah, this is CFAL. I managed to at least get it to compile (with stack), but it crashes with an internal error.
2023-11-13 18:54:24 +0100 <Athas> I guess I'll post on the mailing list and ask for advice.
2023-11-13 18:54:57 +0100fendor(~fendor@2a02:8388:1640:be00:ca17:ceee:5bbe:1594) (Remote host closed the connection)
2023-11-13 18:56:34 +0100 <tomsmeding> Athas: yeah, if you post exactly what error you get, I suspect we'll know precisely what to do
2023-11-13 18:56:43 +0100 <tomsmeding> this UX is something we should fix :p
2023-11-13 18:57:31 +0100 <Athas> Well, you depend on some seriously intricate moving parts.
2023-11-13 18:57:35 +0100 <Athas> I recommend a shell.nix!
2023-11-13 18:58:02 +0100 <tomsmeding> (none of us use nix... :P)
2023-11-13 18:58:26 +0100 <Athas> How do you manage the specific LLVM and CUDA versions that Accelerate needs?
2023-11-13 18:58:34 +0100 <Athas> Ah, you must be Guix users!
2023-11-13 19:02:03 +0100 <tomsmeding> by having folk knowledge of what versions to use, oops
2023-11-13 19:02:38 +0100 <tomsmeding> the versions we need are not so old that the linux package managers we use don't have them :p
2023-11-13 19:03:13 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-11-13 19:03:53 +0100qqq(~qqq@92.43.167.61)
2023-11-13 19:04:01 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 19:05:33 +0100danse-nr3(~danse@151.35.241.49) (Ping timeout: 260 seconds)
2023-11-13 19:05:54 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-13 19:06:29 +0100_xor(~xor@72.49.195.41) (Quit: Ping timeout (120 seconds))
2023-11-13 19:07:04 +0100_xor(~xor@72.49.195.41)
2023-11-13 19:11:27 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Remote host closed the connection)
2023-11-13 19:12:21 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-13 19:14:26 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-11-13 19:22:05 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-13 19:22:14 +0100 <ph88^> where can i find the regex tdfa supported patterns ?
2023-11-13 19:24:17 +0100 <geekosaur> "This regex-tdfa package implements, correctly, POSIX extended regular expressions." (in haddock for Text.Regex.TDFA)
2023-11-13 19:24:39 +0100 <geekosaur> so if you want a precise specification you can check the POSIX standard
2023-11-13 19:24:59 +0100 <kaol> man 7 regex
2023-11-13 19:25:36 +0100 <haskellbridge> 06<s​m> https://hledger.org/1.31/hledger.html#regular-expressions should be pretty accurate also
2023-11-13 19:27:27 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-13 19:27:47 +0100euleritian(~euleritia@x5271790e.dyn.telefonica.de)
2023-11-13 19:32:24 +0100Teacup(~teacup@user/teacup) (Server closed connection)
2023-11-13 19:32:35 +0100Teacup(~teacup@user/teacup)
2023-11-13 19:36:42 +0100notzmv(~zmv@user/notzmv)
2023-11-13 19:41:52 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5)
2023-11-13 19:49:04 +0100 <ph88^> thx :)
2023-11-13 19:51:06 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Remote host closed the connection)
2023-11-13 19:51:21 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 19:52:06 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-13 19:56:52 +0100 <tomsmeding> it's nice that they explicitly state that they do it "correctly"
2023-11-13 19:57:12 +0100 <tomsmeding> as opposed to... other implementations that also claim to support POSIX extended but don't do it correctly? or something?
2023-11-13 19:57:35 +0100 <monochrom> :) :(
2023-11-13 19:58:17 +0100 <monochrom> because of the potential for: the minority is correct but the incorrect majority is mainstream.
2023-11-13 20:00:58 +0100 <monochrom> https://swtch.com/~rsc/regexp/regexp1.html This one is not so much about correctness, but if the mainstream is slow, no one takes it seriously when someone says it could be fast.
2023-11-13 20:01:28 +0100 <haskellbridge> 14<m​auke> Posix regexes aren't very useful because in practice everyone just follows what Perl does
2023-11-13 20:01:28 +0100 <dolio> The next sentence is: "It is highly unlikely that the regex-posix package on your operating system is correct..."
2023-11-13 20:02:59 +0100 <haskellbridge> 14<m​auke> ^that page annoys me because it's basically sleight-of-hand
2023-11-13 20:05:04 +0100 <haskellbridge> 14<m​auke> "no pathological patterns" he promises, and then doesn't implement all the nice features you want
2023-11-13 20:05:22 +0100 <glguy> Maybe the nice features are pathological!
2023-11-13 20:05:29 +0100 <dolio> Which nice features?
2023-11-13 20:05:46 +0100 <haskellbridge> 14<m​auke> including some very basic things like {m,n} quantifiers
2023-11-13 20:05:49 +0100 <glguy> irregular expressions
2023-11-13 20:06:07 +0100 <glguy> or at that point are they just "expressions"?
2023-11-13 20:06:36 +0100target_i(~target_i@217.175.14.39)
2023-11-13 20:08:21 +0100 <haskellbridge> 14<m​auke> Bounded repetition is still regular. In backtracking implementations it's just a loop, but in his version you'd get exponential space usage, best as I can tell
2023-11-13 20:08:33 +0100alp(~alp@user/alp) (Ping timeout: 260 seconds)
2023-11-13 20:08:54 +0100 <glguy> I don't mean bounded repetition is not regular, just that it seems like most people don't want the regular part of regular expressions
2023-11-13 20:09:09 +0100 <haskellbridge> 14<m​auke> True
2023-11-13 20:10:27 +0100 <EvanR> I mean how are you supposed to parse HTML with regular regular expression
2023-11-13 20:10:33 +0100 <EvanR> sheesh!
2023-11-13 20:10:41 +0100 <dolio> Yeah, not having {m,n} is a bummer.
2023-11-13 20:10:48 +0100 <dolio> That's in posix.
2023-11-13 20:11:00 +0100deriamis(deriamis@2600:1f14:1251:ba02:2994:f9dc:75a8:113b) (Server closed connection)
2023-11-13 20:11:16 +0100deriamis(deriamis@2600:1f14:1251:ba02:2994:f9dc:75a8:113b)
2023-11-13 20:12:42 +0100 <haskellbridge> 14<m​auke> I mean, the lexical grammar of script tags is technically regular :-D
2023-11-13 20:13:44 +0100 <EvanR> good point, which is all you can hope for when "parsing" html anyway
2023-11-13 20:13:50 +0100 <EvanR> tag soup
2023-11-13 20:14:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-11-13 20:16:50 +0100AlexNoo_AlexNoo
2023-11-13 20:17:13 +0100 <haskellbridge> 14<m​auke> Back to my original point: I think Perl syntax won because it is more, uh, regular
2023-11-13 20:18:16 +0100 <haskellbridge> 14<m​auke> E.g. you can backslash escape any punctuation character and it will match itself literally. That's not true in POSIX
2023-11-13 20:19:31 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-11-13 20:20:21 +0100 <monochrom> Yeah I do think when I saw Perl regex a long time ago my impression was "this is pretty uniform" and later POSIX was "this is unusually many special cases".
2023-11-13 20:20:39 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-13 20:22:06 +0100 <monochrom> In other news, I have come up with a great pun.
2023-11-13 20:22:21 +0100 <monochrom> Recursion is my recurring interest. I'm fixated on fixed points.
2023-11-13 20:23:47 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-13 20:23:48 +0100 <monochrom> (I am recently learning recursion and inductive types in Lean, or generally Curry-Howard-isomorphic systems.)
2023-11-13 20:25:49 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-11-13 20:26:26 +0100 <dolio> I could believe perl has better syntax for them. The problem with perl regexes are some of the features.
2023-11-13 20:28:15 +0100 <geekosaur> POSIX regexps were an attempt to rationalize a shitton of different regex codebases all with their own idiosyncrasies
2023-11-13 20:29:28 +0100 <dolio> The problems mentioned by the tdfa package are the meanings of various regexes.
2023-11-13 20:31:09 +0100 <dolio> Like, not outputting the captures as specified in posix. I didn't read in detail, but it's possible you could get different capture information on different platforms for some regexes.
2023-11-13 20:31:38 +0100 <geekosaur> yeh, I saw that
2023-11-13 20:31:56 +0100roosterphant(~roosterph@user/roosterphant)
2023-11-13 20:33:21 +0100 <dolio> In a way that's already going beyond 'regular expression.' Because that kind of ambiguity doesn't really matter when you're just recognizing the whole string.
2023-11-13 20:33:51 +0100CiaoSen(~Jura@2a05:5800:2ad:5900:2a3a:4dff:fe84:dbd5) (Ping timeout: 240 seconds)
2023-11-13 20:34:53 +0100CiaoSen(~Jura@5.83.177.67)
2023-11-13 20:35:41 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-13 20:37:57 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (K-Lined)
2023-11-13 20:38:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Remote host closed the connection)
2023-11-13 20:39:03 +0100[`itchyjunk`](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 240 seconds)
2023-11-13 20:40:46 +0100 <John_Ivan> I have a question regarding "IO". The function I'm wrapping is getCurrentDirectory as :: IO String
2023-11-13 20:41:19 +0100 <John_Ivan> I'm trying to do "putStrLn get_c_dir" which is my wrapper but I get an error saying that it cannot convert from IO to String
2023-11-13 20:41:35 +0100 <John_Ivan> I know I can do "var <- get_c_dir" and then "putStrLn var"
2023-11-13 20:41:51 +0100 <John_Ivan> but is it not possible otherwise to directly get a value and pipe it to putStrLn?
2023-11-13 20:41:56 +0100 <geekosaur> @where iotut
2023-11-13 20:41:57 +0100 <lambdabot> https://www.vex.net/~trebla/haskell/IO.xhtml
2023-11-13 20:42:02 +0100 <geekosaur> it is not possible
2023-11-13 20:42:02 +0100 <monochrom> >>=
2023-11-13 20:42:27 +0100 <geekosaur> getCurrentDirectory contains a String in the same way that /bin/'ls contains a list of files
2023-11-13 20:42:33 +0100 <geekosaur> -`
2023-11-13 20:42:51 +0100 <John_Ivan> I see. I guess that's what I wanted to know. "is it possible or not". I'll have a read of that page. thanks.
2023-11-13 20:42:55 +0100 <geekosaur> it is an action that must be run using `>>=`
2023-11-13 20:43:05 +0100 <John_Ivan> ahh
2023-11-13 20:43:10 +0100 <John_Ivan> wait
2023-11-13 20:43:34 +0100Pickchea(~private@user/pickchea)
2023-11-13 20:43:38 +0100 <kaol> I like to make the distinction: >>= is a bind, not running it. The RTS runs it.
2023-11-13 20:43:52 +0100danza(~francesco@151.35.224.181)
2023-11-13 20:44:05 +0100 <John_Ivan> geekosaur, but what stops me from doing the "binding" inside get_c_dir wrapper and still signaturing it as ":: String" ?
2023-11-13 20:44:10 +0100 <monochrom> This is why a formula is worth a thousand pictures (therefore a million words). >:)
2023-11-13 20:44:33 +0100 <John_Ivan> but just merely returning the string
2023-11-13 20:44:39 +0100 <geekosaur> you have to put it back in IO afterward
2023-11-13 20:44:47 +0100 <geekosaur> read the IO tutorial I linked
2023-11-13 20:44:49 +0100 <monochrom> What is get_c_dir?
2023-11-13 20:44:52 +0100 <John_Ivan> ok thanks
2023-11-13 20:45:10 +0100 <kaol> You can't escape IO. Even if you do it inside a function the return type has to have IO on it.
2023-11-13 20:45:30 +0100 <geekosaur> once in IO, always in IO
2023-11-13 20:45:47 +0100 <geekosaur> you can temporarily pull it out but you must put it back
2023-11-13 20:45:54 +0100 <kaol> STD of type system.
2023-11-13 20:46:39 +0100sudden(~cat@user/sudden) (Ping timeout: 255 seconds)
2023-11-13 20:47:17 +0100sudden(~cat@user/sudden)
2023-11-13 20:48:42 +0100 <EvanR> you also can't escape Maybe a, you can't necessarily get `a'. The difference between Maybe and IO is that IO is abstract, you can't (normally) pattern match deconstruct it
2023-11-13 20:49:30 +0100 <EvanR> alternatively, what does escape mean if not that
2023-11-13 20:50:31 +0100 <haskellbridge> 14<m​auke> What stops you, technically, is the type checker
2023-11-13 20:50:36 +0100 <ncf> cursed thought: IO is "morally State RealWorld", but has anyone considered Reader RealWorld and Writer RealWorld?
2023-11-13 20:51:23 +0100 <haskellbridge> 14<m​auke> What's the real world mappend?
2023-11-13 20:51:24 +0100 <monochrom> No, because IO is not morally State RealWorld.
2023-11-13 20:51:49 +0100 <ncf> i mean it's more than morally
2023-11-13 20:51:57 +0100 <monochrom> But perhaps s/morally/naïvely/ may work.
2023-11-13 20:53:13 +0100 <monochrom> unsafePerformIO is Reader RealWorld.
2023-11-13 20:53:42 +0100 <EvanR> world1 <> world2 is a(n ill concieved) many worlds multiversal split point
2023-11-13 20:53:43 +0100 <ncf> not really
2023-11-13 20:54:04 +0100 <ski> (you could use monadic I/O (as the only form of I/O) in a dynamically typed language)
2023-11-13 20:54:13 +0100 <monochrom> This is very cursed and I am only interested in recursion, not cursion. >:)
2023-11-13 20:55:19 +0100 <EvanR> world1 <> world2 is 0.707*world1 + 0.707*world2
2023-11-13 20:55:48 +0100 <haskellbridge> 12<C​elestial> _re_ (re cursive)
2023-11-13 20:56:06 +0100 <ncf> Reader RealWorld would allow the compiler to interleave actions that are guaranteed to only read from the world and not change it, so it'd be more like unsafeInterleaveIO i guess
2023-11-13 20:56:06 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-13 20:56:52 +0100 <EvanR> I passively read the system clock, it doesn't change anything right
2023-11-13 20:57:22 +0100 <ncf> i mean of course in practice reading anything might change it so this would be a very frail abstraction
2023-11-13 20:57:25 +0100 <haskellbridge> 12<C​elestial> quantum physics disagrees (sort of)
2023-11-13 20:57:48 +0100 <monochrom> This is madness.
2023-11-13 20:58:06 +0100 <EvanR> you could set up the clock as a continuous wave coming in, whoever sends it won't know what we do with it (until much later technically)
2023-11-13 20:58:09 +0100 <ski> Mercury has an impurity system (mostly intended for FFI, so that you can code more of the provided functionality in (impure) Mercury before wrapping it up in a (desiredly) pure interface). it distinguishes between `pure', `semipure', and `impure'. `semipure' calls commute with each other, but can't be moved across `impure' ones
2023-11-13 20:58:18 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-13 20:58:48 +0100alp(~alp@2001:861:5e02:eff0:18d6:86ab:73b8:9572)
2023-11-13 20:59:22 +0100 <ncf> i guess both read-only and write-only segments would be a kind of semipure (but they wouldn't commute past each other)
2023-11-13 20:59:42 +0100 <ski> (there's also the notion of "unique input", where you pass the unique reference to a data structure to a predicate, so that it can inspect it, but then hands it back (and it's immutable), so that calls that are handed that unique reference can then be commuted wrt each other)
2023-11-13 21:00:12 +0100 <ncf> er, write-only wouldn't commute at all
2023-11-13 21:00:17 +0100 <EvanR> what is "semipure"
2023-11-13 21:00:37 +0100 <ski> EvanR : typical example would be "reading the current value of a mutable location"
2023-11-13 21:03:56 +0100 <ski> (the uniqueness stuff is all pure and declarative, though. used to be able to use update-in-place under the covers, when taking a (the unique reference to a) structure as input and computing (a unique reference to) an updated structure. used e.g. for arrays, hashmaps, but also the world state (for general I/O). most similar to uniqueness in Clean)
2023-11-13 21:03:59 +0100yoyofreeman(~yoyofreem@176.97.76.178)
2023-11-13 21:11:46 +0100monochromfeels like Unpopular Sarcastic Opinion: Post "Let's remove all senses of humour from Hackage" on discourse.haskell.org
2023-11-13 21:12:13 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 21:13:20 +0100 <probie> The "remove acme-everything" post?
2023-11-13 21:13:54 +0100 <monochrom> Yeah.
2023-11-13 21:13:59 +0100 <EvanR> what happens when hackage policy "remove nothing" collides with the "remove everything" movement
2023-11-13 21:14:54 +0100 <EvanR> an epic amount of "something", I guess xD
2023-11-13 21:15:17 +0100 <monochrom> You're very quantum today. :)
2023-11-13 21:16:42 +0100 <mauke> reminds me of gcc function attributes
2023-11-13 21:16:52 +0100 <probie> I think we need more humour on Hackage, like acme-default. acme-everything happens to sit in a place where it's funny, but also a slight inconvenience
2023-11-13 21:17:25 +0100 <mauke> __attribute__((const)), which marks a function as pure, and __attribute__((pure)), which marks a function as not modifying global state
2023-11-13 21:18:10 +0100 <monochrom> I can sympathize with the specific issue "acme-everything is ruining reverse dependency analyses". But I am put off by the OP's authoritative tone.
2023-11-13 21:19:24 +0100 <EvanR> when you don't like the results of analysis, you edit the data source?
2023-11-13 21:19:44 +0100 <monochrom> and the carpet-bombing attitude "if it doesn't have a use case then it doesn't deserve to live".
2023-11-13 21:20:04 +0100 <EvanR> that's consistent with the quantum principle that you can't do a totally detached analysis with no effect on the system xD
2023-11-13 21:21:12 +0100sadmax(~user@67.22.210.152)
2023-11-13 21:21:21 +0100 <mauke> how is it ruining analyses?
2023-11-13 21:22:07 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-13 21:22:21 +0100 <probie> It's a reverse dependency of every package
2023-11-13 21:22:27 +0100 <monochrom> Every package has acme-everything as a reverse dependency. That is annoying.
2023-11-13 21:22:37 +0100 <mauke> I don't see the problem
2023-11-13 21:23:03 +0100 <EvanR> it makes your package look like a joke!
2023-11-13 21:23:35 +0100 <Clint> is my package a joke? we'll never know
2023-11-13 21:24:05 +0100 <Athas> I check reverse dependencies sometimes, and I don't think I have ever been annoyed about acme-everything.
2023-11-13 21:24:11 +0100 <monochrom> Right, so maerwald points out obvious "you can script up a filter to filter it out". I am ambivalent on that because it is annoying but you are right that it is not a big fuss.
2023-11-13 21:24:33 +0100 <Athas> Since Hackage technically doesn't allow package removal, isn't that the end of the discussion?
2023-11-13 21:24:45 +0100 <Athas> Is it overloading the Hackage software?
2023-11-13 21:24:45 +0100 <EvanR> yes
2023-11-13 21:24:54 +0100 <EvanR> that thread was closed
2023-11-13 21:25:52 +0100 <monochrom> Well, the thread was closed because of "discussion too heated", not because "on the technical pretext that it is purely hypothetical" >:)
2023-11-13 21:29:34 +0100 <probie> We should make a new package archive called "NoFun" that only allows the most serious of packages
2023-11-13 21:30:12 +0100 <EvanR> and a complementary 3rd archive which is nothing but joke packages
2023-11-13 21:30:15 +0100 <Rembane> probie: +1
2023-11-13 21:30:25 +0100 <EvanR> if the humor level is too low, it's laughed off the island
2023-11-13 21:31:00 +0100 <Rembane> Shouldn't all good package indices have some humour packages for good luck? IIRC CPAN have loads for them.
2023-11-13 21:31:26 +0100 <probie> I wonder where things like recursion-schemes sit? It's mostly serious, but then also has `zygoHistoPrepro`
2023-11-13 21:32:11 +0100ubert(~Thunderbi@178.115.54.161.wireless.dyn.drei.com) (Ping timeout: 252 seconds)
2023-11-13 21:32:11 +0100 <Rembane> Is that a humorous name?
2023-11-13 21:32:14 +0100 <geekosaur> we already have an acme category in homage to CPAN
2023-11-13 21:32:24 +0100ubert(~Thunderbi@178.165.177.1.wireless.dyn.drei.com)
2023-11-13 21:32:25 +0100sadmax`(~user@67.22.210.152)
2023-11-13 21:32:26 +0100 <geekosaur> Rembane, 9it's a meme
2023-11-13 21:33:00 +0100sadmax(~user@67.22.210.152) (Read error: No route to host)
2023-11-13 21:33:04 +0100 <mauke> nothing funny about zygohistomorphic prepromorphisms
2023-11-13 21:33:55 +0100Maxlelyonai(~Maxlelyon@178.237.232.145)
2023-11-13 21:33:56 +0100 <Maxlelyonai> Hallo hallo
2023-11-13 21:34:21 +0100 <Maxlelyonai> Does someone know if there is a haskell library, where you can use Naive Bayes?
2023-11-13 21:35:39 +0100 <Rembane> geekosaur: Yeah, but I thought it was something at least slightly serious starting out in a paper and then it kinda got out of hand.
2023-11-13 21:36:21 +0100 <geekosaur> well, it's a real recursion scheme, just one without a lot of practical use and a somewhat ridiculously convoluted name so it took on a life of its own
2023-11-13 21:36:25 +0100 <geekosaur> so, yes
2023-11-13 21:37:06 +0100 <monochrom> Each individual ingredient started out serious. Certain combinations too.
2023-11-13 21:37:37 +0100 <monochrom> Then let combinations -> out of hand. :)
2023-11-13 21:37:43 +0100 <Rembane> I didn't know that. Thank you. :D
2023-11-13 21:37:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17) (Ping timeout: 260 seconds)
2023-11-13 21:39:04 +0100 <Axman6> Maxlelyonai: https://hackage.haskell.org/packages/search?terms=Bayes turnes up a few results but I don't know enough to say if they do what you want
2023-11-13 21:39:19 +0100caryhartline(~caryhartl@168.182.58.169)
2023-11-13 21:39:41 +0100 <Maxlelyonai> ahh
2023-11-13 21:39:48 +0100 <Maxlelyonai> i didn't know you can do that
2023-11-13 21:39:49 +0100 <Maxlelyonai> thx
2023-11-13 21:40:03 +0100 <monochrom> For certain monads, I also find "M (M (M a))" funny and getting out of hand. :) (Unfortunately, it is pretty much seriously necessary to state the laws of join.)
2023-11-13 21:40:37 +0100 <Axman6> the big kiss of the monad laws, mmma!
2023-11-13 21:40:53 +0100 <probie> `[[[a]]]` considered harmful
2023-11-13 21:41:14 +0100 <Axman6> or at least very indirect
2023-11-13 21:41:47 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-11-13 21:42:49 +0100danza(~francesco@151.35.224.181) (Ping timeout: 260 seconds)
2023-11-13 21:44:16 +0100ski's reminded of "triple star programmers" in C
2023-11-13 21:44:41 +0100 <Rembane> Triple monad programmers ftw!
2023-11-13 21:44:42 +0100 <ski> (where you have `blah_t ***p;')
2023-11-13 21:46:34 +0100 <monochrom> I used triple-star once in C for backprop neural network training. Basically just because passing by reference a dynamically sized array of arrays.
2023-11-13 21:46:54 +0100 <monochrom> I think of it as my crowning achievement in C skills. >:)
2023-11-13 21:47:04 +0100 <probie> Resort to church encoding for triple lists `(((((a -> b -> b) -> b -> b) -> c -> d) -> c -> d) -> e -> f) -> e -> f`
2023-11-13 21:48:03 +0100 <monochrom> "You want [[[a]]]. Let me introduce to you System F and rank-4 polymorphism..." >:)
2023-11-13 21:49:25 +0100 <ski> arbitrarily nested `ContT' (as many levels as the user of the action wants there to be) is fun
2023-11-13 21:49:55 +0100 <EvanR> discussion too heated sounds like an unhumorously realistic future HTTP response
2023-11-13 21:50:20 +0100 <monochrom> hahaha
2023-11-13 21:50:28 +0100caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-11-13 21:52:22 +0100 <ski> (something like `newtype Foo o p m a = MkFoo (forall n. ContStack m n => ContT o (ContT p n))', iirc, where `ContStack m' for some base level monads `m', and also `ContStack m n => ContStack m (ContT o n)')
2023-11-13 21:52:55 +0100 <monochrom> "451 Server Overheat" >:)
2023-11-13 21:54:28 +0100ft(~ft@p508db3bc.dip0.t-ipconnect.de)
2023-11-13 21:54:40 +0100 <monochrom> Can you simplify ContStack to MonadCont?
2023-11-13 21:55:18 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-13 21:56:28 +0100 <ski> i don't think so
2023-11-13 21:56:52 +0100 <ski> perhaps it would be possible to abstract from `ContT' to some type class for continuation monad transformers, though
2023-11-13 21:58:25 +0100 <ski> (practically speaking, `ContStack' has methods for trailing which i need, without committing to a definite number of `ContT' levels)
2023-11-13 21:58:53 +0100 <monochrom> Ah yeah callCC is puny.
2023-11-13 21:59:28 +0100 <monochrom> ContStack can be said to have "stack" "unwinding" haha.
2023-11-13 21:59:38 +0100 <ski> .. in case it's not clear, this is about logic programming, and a notion of "backtracking backtracking" which i came up with, in order to be able to support goal implications (and specifically left-nested goal implications, to an arbitrary nesting level)
2023-11-13 22:00:05 +0100Square(~Square@user/square) (Ping timeout: 260 seconds)
2023-11-13 22:00:12 +0100 <ski> this is also closely related to the Church encoding of addition, multiplication, and especially exponentiation
2023-11-13 22:01:14 +0100 <ski> every time i use goal implication, the number of `ContT' levels increase by once (in the left operand of the implication)
2023-11-13 22:01:24 +0100 <ski> s/once/one/
2023-11-13 22:02:23 +0100 <ski> (top-level run operations start out with two levels, which are also used in most of the other basic operations (that doesn't shift levels) (some only use the top level, though))
2023-11-13 22:03:01 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 246 seconds)
2023-11-13 22:04:17 +0100alp(~alp@2001:861:5e02:eff0:18d6:86ab:73b8:9572) (Ping timeout: 260 seconds)
2023-11-13 22:05:16 +0100 <ski> (m + n) s f = m s (n s f)
2023-11-13 22:05:25 +0100 <ski> (m * n) s f = m (n s) f
2023-11-13 22:05:34 +0100 <ski> (n ^ m) s f = m n s f
2023-11-13 22:05:59 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-11-13 22:06:03 +0100 <ski> where `type ChurchNat = forall o. (o -> o) -> (o -> o)'
2023-11-13 22:06:36 +0100 <ski> first two doesn't actually require rank-2 signatures. the last one (exponentiation) does
2023-11-13 22:07:20 +0100 <ski> (because it's not instantiating the `o' in the type of `m' to the same `o' that's in the type of `n ^ m', instead instantiating it to `o -> o')
2023-11-13 22:07:57 +0100zetef(~quassel@95.77.17.251)
2023-11-13 22:08:16 +0100 <ski> these three are basically my implementations of disjunction (`(<|>)'), conjunction (`(>>=)'), and implication (`(==>)')
2023-11-13 22:08:41 +0100 <EvanR> times :: Enum n => n -> (a -> a) -> a -> a -- haskell base why u no
2023-11-13 22:09:30 +0100 <ski> (there's more extra fluff going on, e.g. to deal with universal quantification (and skolems), and how it interacts with instantiating logic variables. and also allowing the `o' and `p' in `Foo o p m a' to not be trivial, actually using them)
2023-11-13 22:10:01 +0100NemesisD(sid24071@id-24071.lymington.irccloud.com) (Server closed connection)
2023-11-13 22:10:10 +0100NemesisD(sid24071@id-24071.lymington.irccloud.com)
2023-11-13 22:10:12 +0100 <ski> (oh, and being able to do I/O and stuff)
2023-11-13 22:12:12 +0100 <ski> EvanR : yea, that's the basic idea at the bottom
2023-11-13 22:12:31 +0100 <ski> (lists of solutions are pretty similar to natural numbers)
2023-11-13 22:13:36 +0100 <EvanR> list of unit = natural numbers
2023-11-13 22:13:40 +0100mc47(~mc47@xmonad/TheMC47)
2023-11-13 22:13:41 +0100 <ski> yep
2023-11-13 22:13:49 +0100 <EvanR> list of a = uh generalized numbers
2023-11-13 22:14:02 +0100sadmax`(~user@67.22.210.152) (Remote host closed the connection)
2023-11-13 22:14:39 +0100zetef_(~quassel@5.2.182.98)
2023-11-13 22:14:55 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 264 seconds)
2023-11-13 22:15:28 +0100 <Franciman> what do you mean by backtracking backtracking?
2023-11-13 22:15:41 +0100 <Franciman> Doesn't it flatten, because logic is a monad?
2023-11-13 22:17:51 +0100 <ski> now, generalizing from `forall o. (o -> o) -> (o -> o)' to `forall o. (a -> o -> o) -> (o -> o)', we've lists. next step is to go to `forall o. (a -> (p -> o) -> o) -> ((p -> o) -> o)', which is `forall o. ContT p (Cont o) a'. you can also split `p' into `p0' and `p1', going into indexed monads, if you like
2023-11-13 22:18:12 +0100 <ski> Franciman : flatten, how do you mean ?
2023-11-13 22:18:18 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-13 22:18:25 +0100 <Franciman> hm i mean the dumb thing
2023-11-13 22:18:27 +0100 <Franciman> :t join
2023-11-13 22:18:28 +0100 <lambdabot> Monad m => m (m a) -> m a
2023-11-13 22:18:42 +0100 <ski> anyway, one can wonder which data structure `(a -> (p -> o) -> o) -> ((p -> o) -> o)' corresponds to
2023-11-13 22:18:50 +0100Maxlelyonai(~Maxlelyon@178.237.232.145) (Quit: Client closed)
2023-11-13 22:19:19 +0100 <ski> oh, i have `Monad m => Monad (Foo o p m)', sure
2023-11-13 22:19:37 +0100 <Franciman> so join is related to exponentials?
2023-11-13 22:19:47 +0100 <Franciman> makes sense since it looks kinda like weakening
2023-11-13 22:19:52 +0100 <ski> no, not really
2023-11-13 22:20:04 +0100 <Franciman> err contraction*
2023-11-13 22:20:06 +0100 <ski> the `Monad' stuff corresponds to (truth and) conjunction
2023-11-13 22:20:13 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-11-13 22:20:13 +0100 <Franciman> ok cool
2023-11-13 22:20:26 +0100 <ski> (of course there's also `Applicative' instance)
2023-11-13 22:20:31 +0100caryhartline(~caryhartl@168.182.58.169)
2023-11-13 22:20:38 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-11-13 22:20:38 +0100 <ski> while `MonadPlus' (or `Alternative') is disjunction
2023-11-13 22:20:40 +0100 <Franciman> do you have any public code?
2023-11-13 22:20:45 +0100 <Franciman> i'm curious to read
2023-11-13 22:20:49 +0100Francimanis lost
2023-11-13 22:21:02 +0100 <EvanR> > join ["ap", "pl", "e"] -- contraction
2023-11-13 22:21:03 +0100 <lambdabot> "apple"
2023-11-13 22:21:43 +0100 <ski> do you have logic programming experience ? like Prolog ? or maybe Mercury or Oz or something ?
2023-11-13 22:22:00 +0100 <Franciman> yes
2023-11-13 22:22:17 +0100euleritian(~euleritia@x5271790e.dyn.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 22:22:35 +0100euleritian(~euleritia@2a02:810a:b00:1568:db91:81d0:5aee:f30f)
2023-11-13 22:23:15 +0100 <ski> ok, so with a query `?- append(Front,Back,[2,3]).', you have implementations use backtracking to enumerate all solutions (three of them, being `Front = [],Back = [2,3] ; Front = [2],Back = [3] ; Front = [2,3],Back = []')
2023-11-13 22:23:51 +0100 <Franciman> ok clear
2023-11-13 22:24:54 +0100 <ski> it's possible to carry around substitutions for the current (if any) value that a variable is instantiated ("bound") to. (note that logic programming separates the introduction ("lexical scope variable binding") of a variable (which is uninstantiated (think "uninitialized"), to begin with), and the instantiation (actually associating it with a value))
2023-11-13 22:26:14 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-13 22:26:15 +0100 <ski> however, implementations that aim for more efficiency tends to use update-in-place to implement variable instantiation. iow, you overwrite the "uninitialized" value. then, when backtracking, the variable goes back again from instantiated state, to uninstantiated (undoing a path taken in the maze, so that you can then explore another path)
2023-11-13 22:27:19 +0100 <Franciman> ok
2023-11-13 22:27:49 +0100 <ski> typically, "uninitialized" is a specific bit pattern the tun-time can check for. but it's also possible (with some restrictions in flexibility) to statically track the instantiation state, so that uninstantiation is a no-op (Mercury does this. Prolog systems, afaik, don't do this, except *maybe* occasionally as optimization (not sure if any does this))
2023-11-13 22:28:33 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-11-13 22:28:53 +0100 <ski> anyway, keeping track of which variables you need to uninstantiate, on backtracking, is called "trailing". you're putting out "breadcrumbs" when you proceed, so that if you need to go back your path, you can undo what you did
2023-11-13 22:29:25 +0100euleritian(~euleritia@2a02:810a:b00:1568:db91:81d0:5aee:f30f) (Ping timeout: 258 seconds)
2023-11-13 22:30:14 +0100euleritian(~euleritia@x5271790e.dyn.telefonica.de)
2023-11-13 22:30:15 +0100 <ski> now, it's not too uncommon for Prolog implementations to have a predicate `forall(Antecedent,Consequent)' (which is slightly a misnomer, as it's a form of implication)
2023-11-13 22:31:06 +0100caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-11-13 22:31:42 +0100 <ski> e.g. you could state the query `?- forall(member(P,[2,3,5,7]),prime(P)).', and that would succeed, by generating all solutions (for `P') of `member(P,[2,3,5,7])' (`P' takes on, in turn, the value of each of the elements of the list, on backtracking), and checking that `prime(P)' holds for each solution
2023-11-13 22:32:23 +0100 <ski> (it's called forall/2, because of the "happy accident" of `P' here acting as if it was implicitly quantified over the whole call)
2023-11-13 22:32:25 +0100 <Inst> for lists, is there no better version of ( concat . replicate n )?
2023-11-13 22:33:33 +0100 <ski> can't think of any, Inst
2023-11-13 22:33:42 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-13 22:34:08 +0100 <Franciman> ok ski
2023-11-13 22:34:31 +0100 <Inst> it's painful with strings
2023-11-13 22:34:39 +0100 <Inst> foldMap?
2023-11-13 22:35:13 +0100caryhartline(~caryhartl@168.182.58.169)
2023-11-13 22:35:26 +0100 <ski> Franciman : anyway, `forall(A,C)' is implemented as `\+ ( A,\+ C )', where `\+' is "negation-as-failure" (a limited form of negation. if you use it outside of its preconditions, it'll generate results that don't follow logic) (and `,' is conjunction)
2023-11-13 22:35:42 +0100 <ski> (iow `not (a && not c)', in Haskell terms)
2023-11-13 22:36:04 +0100 <Franciman> \+ is nonmonotonic no?
2023-11-13 22:36:15 +0100 <ski> by carefully understanding how negation-as-failure works here, one can check that forall/2 indeed works as intended
2023-11-13 22:36:55 +0100 <ski> however, `\+ G' always either succeeds (once) or fails, but never instantiates any variables. you can't "export" any information from it, apart from this yes/no indication (unless you use side-effects, of course)
2023-11-13 22:37:31 +0100 <ski> so that directly means that forall/2 can also only be used to check conditions, never as a part of computing your output
2023-11-13 22:37:49 +0100 <ski> i wanted to lift this restriction !
2023-11-13 22:38:07 +0100 <Franciman> oh cool
2023-11-13 22:39:03 +0100 <ski> e.g. consider `?- List = [(2,_),(3,_)],( member((X,Y),List) , square(X,Y) ).', i want this to compute `List = [(2,4),(3,9)]' for me
2023-11-13 22:39:08 +0100 <ski> er
2023-11-13 22:39:13 +0100 <ski> e.g. consider `?- List = [(2,_),(3,_)],( member((X,Y),List) => square(X,Y) ).', i want this to compute `List = [(2,4),(3,9)]' for me
2023-11-13 22:39:26 +0100 <ski> (where `=>' is my syntax, replacing forall/2)
2023-11-13 22:39:50 +0100 <EvanR> Inst, concat . replicate n is pretty nice ngl
2023-11-13 22:40:32 +0100 <ski> after the implication goal is done, `X' and `Y' will be uninstantiated. because, after each solution of member/2, we want to uninstantiate them, in preparation for getting the next pair of elements (one initially known/instantiated, and one initially unknown/uninstantiated)
2023-11-13 22:40:48 +0100 <ski> Inst : i suspect it probably fuses nicely
2023-11-13 22:41:33 +0100 <ski> however, despite this, somehow the instantiations that `square(X,Y)' makes to `Y' must still survive `X' and `Y' repeatedly getting uninstantiated and reinstantiated
2023-11-13 22:42:50 +0100 <ski> `Y' will act as a temporary alias of the unknown components of `List', and when square/2 instantiates `Y', it will actually instantiate `List' *through* `Y' (and then the link from `Y' to that component of `List' is broken, but the instantiation remains)
2023-11-13 22:44:01 +0100 <ski> Franciman : note that, to find a single solution of `( A => C )', we will need to enumerate *every* solution of `A' (until there's no more), and for each of these, spawn a new call of `C' (of which we find one solution)
2023-11-13 22:44:18 +0100 <Franciman> hence the forall name :P
2023-11-13 22:44:23 +0100 <Franciman> ok damn cool
2023-11-13 22:44:27 +0100 <Inst> honestly, might as well go to text in this case :(
2023-11-13 22:44:46 +0100 <EvanR> :t sconcat
2023-11-13 22:44:47 +0100 <lambdabot> error:
2023-11-13 22:44:47 +0100 <lambdabot> • Variable not in scope: sconcat
2023-11-13 22:44:47 +0100 <lambdabot> • Perhaps you meant one of these:
2023-11-13 22:44:56 +0100 <ski> we want `List = [(2,_),(3,_)],( member((X,Y),List) => square(X,Y) )' to behave similarly to `List = [(2,Y0),(3,Y1)],square(2,Y0),square(3,Y1)'
2023-11-13 22:45:48 +0100 <EvanR> :t mconcat . replicate n
2023-11-13 22:45:49 +0100 <lambdabot> error:
2023-11-13 22:45:49 +0100 <lambdabot> • Couldn't match expected type ‘Int’ with actual type ‘Expr’
2023-11-13 22:45:49 +0100 <lambdabot> • In the first argument of ‘replicate’, namely ‘n’
2023-11-13 22:46:06 +0100 <EvanR> :t mconcat . replicate (n :: Int)
2023-11-13 22:46:07 +0100 <lambdabot> error:
2023-11-13 22:46:07 +0100 <lambdabot> • Couldn't match expected type ‘Int’ with actual type ‘Expr’
2023-11-13 22:46:07 +0100 <lambdabot> • In the first argument of ‘replicate’, namely ‘(n :: Int)’
2023-11-13 22:46:25 +0100 <EvanR> Inst, it would be basically the same code for Text
2023-11-13 22:46:56 +0100 <Inst> T.replicate is :: Int -> Text -> Text
2023-11-13 22:47:36 +0100alp(~alp@2001:861:5e02:eff0:ab69:69ba:52c5:1a83)
2023-11-13 22:47:37 +0100 <EvanR> there might be fusion for Text too
2023-11-13 22:47:40 +0100 <EvanR> but yeah
2023-11-13 22:48:09 +0100 <Inst> https://hoogle.haskell.org/?hoogle=Int%20-%3E%20%5Ba%5D%20-%3E%20%5Ba%5D
2023-11-13 22:48:10 +0100 <Inst> seriously?
2023-11-13 22:48:12 +0100 <ski> (there's actually a Prolog predicate, foreach/2, in some Prologs, that does this. but the implementation of this first (a) collects all solutions of the antecedent (*copying* them to a place where they won't be disturbed by uninstantiation), *then* (b) generates corresponding specialized calls of the consequence, one for each solution. but this requires first collecting all solutions (and copying), and only
2023-11-13 22:48:12 +0100 <EvanR> if you're trying to optimize you probably want Text anyway
2023-11-13 22:48:18 +0100 <ski> when that's done, do the rest. i don't want this ! i want to naturally interleave these two processes. and i don't want to copy data (which messes up attributed variables, if you have any, which are used for constraint logic programming))
2023-11-13 22:48:38 +0100 <Inst> people are probably thinking, just replicate foo =<<
2023-11-13 22:48:38 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-11-13 22:49:15 +0100 <Inst> but that provides the wrong behavior, i.e, the resulting list of lists has each individual element dumped back into a list of lists
2023-11-13 22:49:34 +0100 <EvanR> good, the simpler code has the right behavior
2023-11-13 22:49:52 +0100 <EvanR> let's be simple and right
2023-11-13 22:49:58 +0100 <ski> Franciman : now, you can think of backtracking as traversing a tree. alternate branches are alternate paths you can take. going deeper means proceeding forward through conjunctions. after reaching a leaf (solutions), when you go back up in order to go down another branch, this is backtracking (and you uninstantiate variables here)
2023-11-13 22:50:46 +0100 <ski> Franciman : now, consider the query `?- List = [(_,4),(_,9)],( member((X,Y),List) => square(X,Y) ).'. i want to get *four* solutions here (because each of the two numbers have two square roots)
2023-11-13 22:50:58 +0100 <Inst> or rather, it works, but the problem is that you end up with the original order not being observed :(
2023-11-13 22:51:22 +0100 <Inst> concat . replicate it is :(
2023-11-13 22:52:12 +0100 <ski> Franciman : so, as before, we generate solutions for member/2, and spawn new calls of square/2 for each of them, getting the first solution for `List' in the end. but then, when we backtrack, we need to backtrack the square/2 calls (naturally). conceptually, we have `square(X0,4),square(X1,9)', and we're backtracking the second square/2 call
2023-11-13 22:53:12 +0100 <ski> Franciman : but to get back to the first square/2 call, we must "backtrack backtracking". make the (single) member/2 call *not* advance to the next solution, but *revisit* an earlier solution (so reinstantiate variables to what they were on a previous search path through the maze/tree)
2023-11-13 22:53:58 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-13 22:54:25 +0100 <ski> that's what i mean by "backtrack backtracking"
2023-11-13 22:54:28 +0100 <ski> it's well known that you can implement backtracking, e.g. for logic programming, with two levels of continuations (`ContT o (ContT p m) a', in Haskell) terms. but to get "backtracking backtracking", i realized that you needed an unbounded number of `ContT' levels
2023-11-13 22:55:42 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-11-13 22:57:01 +0100acidjnk(~acidjnk@p200300d6e72b933384d06dff6b3ba200.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2023-11-13 22:57:03 +0100 <ski> Franciman : makes somewhat more sense, now ?
2023-11-13 22:58:09 +0100 <Franciman> yup!
2023-11-13 22:58:17 +0100 <Franciman> sorry i was away
2023-11-13 22:58:20 +0100 <ski> nw
2023-11-13 22:58:31 +0100 <Franciman> fun, thanks ski
2023-11-13 22:58:31 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-13 22:58:35 +0100jinsun_(~jinsun@user/jinsun)
2023-11-13 22:58:36 +0100jinsunGuest9520
2023-11-13 22:58:36 +0100Guest9520(~jinsun@user/jinsun) (Killed (zinc.libera.chat (Nickname regained by services)))
2023-11-13 22:58:36 +0100jinsun_jinsun
2023-11-13 22:59:05 +0100 <ski> anyway, i did a prototype (as an EDSL) of this in Haskell, years ago
2023-11-13 23:05:00 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1) (Ping timeout: 240 seconds)
2023-11-13 23:06:28 +0100 <ski> Franciman : i haven't put the code up anywhere public, but if you're curious, i could hand you a tarball of it
2023-11-13 23:06:55 +0100 <ski> (i already showed it to someone else as well)
2023-11-13 23:07:20 +0100 <Franciman> would be glad to look at it
2023-11-13 23:07:22 +0100 <Franciman> thanks
2023-11-13 23:08:39 +0100 <ski> (i didn't touch the code for years, and then when i was reminded of it (a couple years ago), i couldn't find the last version (that weeded out a few bugs that made my simple tests of implication fail). so it shouldn't be considered as cleaned up)
2023-11-13 23:09:46 +0100 <ski> (also, when i tried to load it just now, it loads fine with GHC 8.8.4 (adding `-package mtl'), but apparently now not with GHC 9.4.5 ..)
2023-11-13 23:11:34 +0100acidjnk(~acidjnk@p200300d6e72b93217d79895cb809dcc2.dip0.t-ipconnect.de)
2023-11-13 23:12:12 +0100 <ski> ok, PMed you a link
2023-11-13 23:13:13 +0100 <ski> (oh, i should say that i did weed out those bugs again, in this version (after taking some time to read through the code, and try to recall what was the issue))
2023-11-13 23:33:00 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-13 23:34:17 +0100acidjnk(~acidjnk@p200300d6e72b93217d79895cb809dcc2.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-11-13 23:34:47 +0100euleritian(~euleritia@x5271790e.dyn.telefonica.de) (Read error: Connection reset by peer)
2023-11-13 23:35:05 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 23:36:17 +0100Batzy(~quassel@user/batzy)
2023-11-13 23:36:38 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-11-13 23:37:20 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:3080:2ce:4a2:17)
2023-11-13 23:38:37 +0100_73(~anon_73@2600:4040:5205:d800:21e8:9777:49a5:db28) (Remote host closed the connection)
2023-11-13 23:40:08 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-13 23:41:19 +0100Cale(~cale@cpe80d04ade0a03-cm80d04ade0a01.cpe.net.cable.rogers.com) (Read error: Connection reset by peer)
2023-11-13 23:42:05 +0100Sgeo(~Sgeo@user/sgeo)
2023-11-13 23:42:21 +0100_xor(~xor@72.49.195.41) (Quit: Ping timeout (120 seconds))
2023-11-13 23:42:55 +0100_xor(~xor@72.49.195.41)
2023-11-13 23:45:00 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-13 23:45:15 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-13 23:46:42 +0100zetef_(~quassel@5.2.182.98) (Read error: Connection reset by peer)
2023-11-13 23:47:26 +0100zetef(~quassel@5.2.182.98)
2023-11-13 23:52:00 +0100zetef(~quassel@5.2.182.98) (Ping timeout: 245 seconds)
2023-11-13 23:52:48 +0100michalz(~michalz@185.246.207.217) (Remote host closed the connection)
2023-11-13 23:54:17 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-13 23:55:12 +0100caryhartline(~caryhartl@168.182.58.169) (Quit: caryhartline)
2023-11-13 23:55:12 +0100 <Inst> ugh, this is really weird, am i the only user of vty here?
2023-11-13 23:55:13 +0100 <Inst> :(
2023-11-13 23:56:11 +0100 <monochrom> There are others. But IRC is dying in general.
2023-11-13 23:57:00 +0100 <monochrom> There is a Star Trek The Next Generation episode about this feeling. >:)
2023-11-13 23:59:30 +0100 <Inst> which one?
2023-11-13 23:59:33 +0100 <tomsmeding> Inst: vty? vty the haskell library?
2023-11-13 23:59:41 +0100 <Inst> i figured it out, i misread documentation
2023-11-13 23:59:56 +0100 <tomsmeding> ghcup uses brick which uses vty :p