IRCBrowse

2023/11/12

2023-11-12 00:00:38 +0100 <EvanR> too bad we can't base crypto on all these undecidable problems
2023-11-12 00:00:40 +0100alguem(~alguem@45.163.64.23) (Remote host closed the connection)
2023-11-12 00:01:57 +0100 <EvanR> it would be guaranteed unbreakable
2023-11-12 00:02:33 +0100 <int-e> EvanR: https://xkcd.com/538/
2023-11-12 00:02:39 +0100 <EvanR> I send you a lambda term, if it's got a normal form that's a 1, otherwise 0
2023-11-12 00:07:08 +0100arahael_(~arahael@21.127.96.58.static.exetel.com.au)
2023-11-12 00:10:49 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d0e6:54a3:ea5c:7672)
2023-11-12 00:12:28 +0100megaTherion(~therion@unix.io) (Server closed connection)
2023-11-12 00:12:38 +0100megaTherion(~therion@unix.io)
2023-11-12 00:13:42 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-12 00:17:05 +0100masterbuilder(~master@user/masterbuilder)
2023-11-12 00:18:17 +0100 <ph88> i saw in the docs that State takes a single parameter, why do i get this error? Expecting one more argument to ‘State QueryPart’
2023-11-12 00:18:28 +0100Guest45(~Guest45@pub082136073213.dh-hfc.datazug.ch)
2023-11-12 00:19:04 +0100 <EvanR> :k State
2023-11-12 00:19:05 +0100 <lambdabot> * -> * -> *
2023-11-12 00:19:12 +0100 <EvanR> @unmtl State
2023-11-12 00:19:12 +0100 <lambdabot> err: `State' is not applied to enough arguments, giving `/\A B. A -> (B, A)'
2023-11-12 00:19:24 +0100 <ph88> https://hackage.haskell.org/package/transformers-0.6.1.1/docs/Control-Monad-Trans-State-Lazy.html#…
2023-11-12 00:19:40 +0100 <EvanR> StateT takes 3 parameters
2023-11-12 00:19:42 +0100 <ph88> only see `s` as argument
2023-11-12 00:19:53 +0100 <c_wraith> ph88: that's been eta-contracted. For good reasons related to limitations of type aliases
2023-11-12 00:20:06 +0100Guest45(~Guest45@pub082136073213.dh-hfc.datazug.ch) (Client Quit)
2023-11-12 00:20:20 +0100 <ph88> type State s a = StateT s Identity a why didn't they write it like this? it should be the same and much easier to understand
2023-11-12 00:20:29 +0100 <EvanR> wouldn't work, right
2023-11-12 00:20:33 +0100 <EvanR> unfortunately
2023-11-12 00:20:36 +0100masterbuilder(~master@user/masterbuilder) (Quit: Leaving)
2023-11-12 00:20:50 +0100 <c_wraith> ph88: because it would make it illegal to write State s anywhere
2023-11-12 00:21:00 +0100arahael_(~arahael@21.127.96.58.static.exetel.com.au) (Quit: I'm off! Laters!)
2023-11-12 00:21:03 +0100 <c_wraith> ph88: because type aliases must always be fully applied
2023-11-12 00:21:36 +0100 <ph88> hmmm interesting
2023-11-12 00:21:40 +0100 <ph88> thanks
2023-11-12 00:23:16 +0100 <EvanR> that you can get the same effect by defining more type aliases seems suspicious
2023-11-12 00:23:39 +0100 <EvanR> why can't they be auto curried
2023-11-12 00:23:50 +0100 <c_wraith> I guess that limitation exists because otherwise they'd be type lambdas
2023-11-12 00:24:19 +0100 <c_wraith> and type lambdas break a lot of stuff
2023-11-12 00:24:35 +0100 <ph88> how can i write this function? intersperseS :: forall s a. State s a -> [State s a] -> [State s a]
2023-11-12 00:24:57 +0100 <monochrom> could make type inference too difficult.
2023-11-12 00:25:07 +0100 <EvanR> that's just intersperse specialized to State s a right
2023-11-12 00:25:11 +0100 <ph88> yes
2023-11-12 00:25:15 +0100 <geekosaur> looks like it to me
2023-11-12 00:25:22 +0100 <EvanR> did you want State s a -> [State s a] -> State s [a] or something
2023-11-12 00:25:29 +0100 <ph88> no
2023-11-12 00:25:39 +0100 <EvanR> ok so intersperse should just work
2023-11-12 00:25:42 +0100 <ph88> oh ok
2023-11-12 00:25:44 +0100 <ph88> thank you
2023-11-12 00:25:48 +0100 <geekosaur> so what goes wrong if you just use intersperse?
2023-11-12 00:25:52 +0100 <geekosaur> oh, slow me
2023-11-12 00:26:10 +0100 <ski> % :i ReadS
2023-11-12 00:26:10 +0100 <yahb2> type ReadS :: * -> * ; type ReadS a = String -> [(a, String)] ; -- Defined in ‘Text.ParserCombinators.ReadP’
2023-11-12 00:26:18 +0100 <ski> % type Const c a = c
2023-11-12 00:26:18 +0100 <yahb2> <no output>
2023-11-12 00:26:26 +0100 <ski> % :k Const Int ReadS
2023-11-12 00:26:26 +0100 <yahb2> <interactive>:1:1: error: ; The type synonym ‘ReadS’ should have 1 argument, but has been given none
2023-11-12 00:26:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d0e6:54a3:ea5c:7672) (Remote host closed the connection)
2023-11-12 00:26:32 +0100 <ski> % :set -XLiberalTypeSynonyms
2023-11-12 00:26:32 +0100 <yahb2> <no output>
2023-11-12 00:26:35 +0100 <ski> % :k Const Int ReadS
2023-11-12 00:26:35 +0100 <yahb2> Const Int ReadS :: *
2023-11-12 00:26:45 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d0e6:54a3:ea5c:7672)
2023-11-12 00:27:30 +0100 <ski> (apropos "type aliases must always be fully applied")
2023-11-12 00:27:40 +0100masterbuilder(~quassel@user/masterbuilder)
2023-11-12 00:28:46 +0100andrewboltachev(~andrey@178.141.201.173)
2023-11-12 00:28:56 +0100CiaoSen(~Jura@2a05:5800:2b0:5500:2a3a:4dff:fe84:dbd5) (Ping timeout: 252 seconds)
2023-11-12 00:35:28 +0100 <EvanR> does that extension have any downside?
2023-11-12 00:36:01 +0100Buggys(Buggys@shelltalk.net) (Ping timeout: 255 seconds)
2023-11-12 00:36:31 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1) (Ping timeout: 264 seconds)
2023-11-12 00:38:06 +0100 <ski> it delays checking full application of type synonyms until after synonym expansion, so to speak
2023-11-12 00:38:43 +0100gawen(~gawen@user/gawen) (Server closed connection)
2023-11-12 00:39:42 +0100 <ski> (in the above example, `a' is unused in expansion of `Const Int ReadS', and so checking full application of `ReadS' amounts to checking zero things. instead of `type Const c a = c', i could have used `type Foo f = f Int', and then `Foo ReadS' would have been fine as well, since `f' is fully applied (at all occurances))
2023-11-12 00:39:48 +0100gawen(~gawen@user/gawen)
2023-11-12 00:39:52 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-11-12 00:43:59 +0100 <EvanR> is there anyway reason why that shouldn't be enabled by default
2023-11-12 00:44:06 +0100sefidel(~sefidel@user/sefidel)
2023-11-12 00:44:48 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b)
2023-11-12 00:45:54 +0100 <ski> i'm not sure. apart from being conservative
2023-11-12 00:46:20 +0100 <ski> type synonyms are kinda like macros. `LiberalTypeSynonyms' then allow higher-order "type macros"
2023-11-12 00:47:01 +0100Buggys(Buggys@Buggy.shelltalk.net)
2023-11-12 00:50:09 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-11-12 00:54:12 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 01:01:26 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-12 01:02:24 +0100euleritian(~euleritia@dynamic-046-114-201-058.46.114.pool.telefonica.de)
2023-11-12 01:06:49 +0100 <geekosaur> it's somewhat limited, in that it simply defers the check, it doesn't allow actual type lambdas
2023-11-12 01:09:55 +0100 <ph88> anyone have an idea how to write [Either a b] -> Either a [b] and [Either a b] -> Either [a] [b] ? where in case there is an `a` the `a` has preference over all the b's
2023-11-12 01:11:36 +0100 <geekosaur> % :t sequenceA @(Either _)
2023-11-12 01:11:36 +0100 <yahb2> sequenceA @(Either _) ; :: Applicative f => Either w (f a) -> f (Either w a)
2023-11-12 01:12:03 +0100 <geekosaur> wrong one
2023-11-12 01:12:09 +0100 <geekosaur> % :t sequenceA @[] @(Either _)
2023-11-12 01:12:10 +0100 <yahb2> sequenceA @[] @(Either _) ; :: Applicative (Either w) => [Either w a] -> Either w [a]
2023-11-12 01:13:18 +0100 <geekosaur> I'm not sure the second is meaningful, perhaps you want partitionEithers?
2023-11-12 01:16:08 +0100 <geekosaur> (if partitionEithers is not what you want, possibly you want These or Validation or Chronicle in place of Either)
2023-11-12 01:16:13 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-11-12 01:16:30 +0100 <ph88> oh yes i could use partitionEithers and turn it into an Either. Thank you geekosaur
2023-11-12 01:21:52 +0100gdown(~gavin@h69-11-149-109.kndrid.broadband.dynamic.tds.net)
2023-11-12 01:22:21 +0100 <ph88> is there a way to make these functions more general for List and Vector ? https://bpa.st/GFPQ
2023-11-12 01:24:05 +0100 <geekosaur> % :t sequenceA @_ @(Either _)
2023-11-12 01:24:05 +0100 <yahb2> sequenceA @_ @(Either _) ; :: (Traversable w1, Applicative (Either w2)) => ; w1 (Either w2 a) -> Either w2 (w1 a)
2023-11-12 01:24:20 +0100 <geekosaur> sequenceA already is
2023-11-12 01:24:26 +0100 <geekosaur> :t partitionEithers
2023-11-12 01:24:27 +0100 <lambdabot> [Either a b] -> ([a], [b])
2023-11-12 01:24:42 +0100 <geekosaur> not general enough
2023-11-12 01:25:26 +0100 <geekosaur> I wonder if that could be framed in terms of Traversable
2023-11-12 01:42:19 +0100 <ph88> How can i make the following structures ?
2023-11-12 01:42:21 +0100 <ph88> [State Foo (Either Text Bar)] -> State Foo (Either Text [Bar])
2023-11-12 01:42:25 +0100 <ph88> [State Foo (Either Text Bar)] -> Either Text [State [Bar]]
2023-11-12 01:42:53 +0100 <ph88> i'm also not sure which one of the two i want, both seem fine to me. I guess second one is more complicated so perhaps just the first one is okay
2023-11-12 01:43:20 +0100 <ph88> if State was Either i could do second sequenceA
2023-11-12 01:46:18 +0100 <geekosaur> % :t sequenceA @[] @(StateT _ (Either T.Text))
2023-11-12 01:46:18 +0100 <yahb2> sequenceA @[] @(StateT _ (Either T.Text)) ; :: Applicative (StateT w (Either T.Text)) => ; [StateT w (Either T.Text) a] -> StateT w (Either T.Text) [a]
2023-11-12 01:46:45 +0100 <ph88> magic :D
2023-11-12 01:47:09 +0100 <geekosaur> not sure the second one is doable, monads do not commute that way in general
2023-11-12 01:47:33 +0100accord(uid568320@id-568320.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-12 01:48:54 +0100 <ph88> about the first one, is the input actually the same? `[State Foo (Either Text Bar)]` and `[StateT w (Either T.Text) a`
2023-11-12 01:49:10 +0100 <ph88> `[StateT w (Either T.Text) a]`
2023-11-12 01:49:43 +0100 <geekosaur> they're not quite identical, but to use sequenceA you want to treat the Either Text as part of the Applicative structure instead of as part of the value
2023-11-12 01:50:01 +0100 <[Leary]> You can also do `getCompose . sequenceA . Compose` or `fmap sequenceA . sequenceA`.
2023-11-12 01:51:35 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 260 seconds)
2023-11-12 01:52:15 +0100 <c_wraith> :t getCompose . traverse Compose
2023-11-12 01:52:16 +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-12 01:52:23 +0100 <c_wraith> that one looks right
2023-11-12 01:53:23 +0100 <monochrom> Unpopular opinion: They all do different things and it is unclear which one is wanted. Type-driven programming is a lie at this stage.
2023-11-12 01:54:32 +0100 <[Leary]> Oh, I didn't get that quite right. Shouldda tested. <.<
2023-11-12 01:54:43 +0100 <c_wraith> I mean, we were initially presented with two different types that do very different things
2023-11-12 01:54:54 +0100Guest|25(~Guest|25@campus-011-137.ucdavis.edu)
2023-11-12 01:54:55 +0100 <c_wraith> putting State inside or outside the list is a huge difference
2023-11-12 01:55:21 +0100Guest|25(~Guest|25@campus-011-137.ucdavis.edu) (Client Quit)
2023-11-12 02:04:05 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-11-12 02:05:31 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Server closed connection)
2023-11-12 02:05:48 +0100califax(~califax@user/califx)
2023-11-12 02:11:52 +0100MironZ(~MironZ@nat-infra.ehlab.uk) (Server closed connection)
2023-11-12 02:12:11 +0100MironZ(~MironZ@nat-infra.ehlab.uk)
2023-11-12 02:12:37 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-11-12 02:16:37 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 246 seconds)
2023-11-12 02:17:03 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-11-12 02:23:16 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 258 seconds)
2023-11-12 02:23:39 +0100DemonDerg(A_D@libera/staff/dragon) (Quit: ZNC - https://znc.in)
2023-11-12 02:23:57 +0100A_Dragon(A_D@libera/staff/dragon)
2023-11-12 02:24:28 +0100dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Ping timeout: 255 seconds)
2023-11-12 02:29:13 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-12 02:30:01 +0100mmhat(~mmh@p200300f1c7445e4eee086bfffe095315.dip0.t-ipconnect.de)
2023-11-12 02:30:03 +0100mmhat(~mmh@p200300f1c7445e4eee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-11-12 02:33:07 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 260 seconds)
2023-11-12 02:44:28 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-11-12 02:45:14 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-11-12 02:49:52 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 246 seconds)
2023-11-12 02:50:21 +0100A_DragonDemonDerg
2023-11-12 02:50:36 +0100ski(~ski@ext-1-042.eduroam.chalmers.se) (Remote host closed the connection)
2023-11-12 02:51:24 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-12 02:56:07 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-12 02:56:10 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b) (Quit: Leaving)
2023-11-12 02:57:37 +0100dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net)
2023-11-12 02:57:42 +0100yoyofreeman(~yoyofreem@176.97.76.178) (Read error: Connection reset by peer)
2023-11-12 02:58:23 +0100yoyofreeman(~yoyofreem@176.97.76.178)
2023-11-12 02:59:46 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Quit: Disrupting the dragon's slumber one time too often shall eventually bestow upon all an empirical and indiscriminate conflagration that will last for all goddamn eternity.)
2023-11-12 03:00:17 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-12 03:00:41 +0100ski(~ski@ext-1-042.eduroam.chalmers.se)
2023-11-12 03:01:26 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-12 03:06:20 +0100lisphacker(~lisphacke@82.129.118.246)
2023-11-12 03:06:20 +0100lisphacker(~lisphacke@82.129.118.246) (Client Quit)
2023-11-12 03:07:06 +0100mhatta(~mhatta@www21123ui.sakura.ne.jp) (Quit: ZNC 1.8.2+deb3.1 - https://znc.in)
2023-11-12 03:11:28 +0100euleritian(~euleritia@dynamic-046-114-201-058.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-12 03:11:45 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 03:13:39 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 255 seconds)
2023-11-12 03:14:28 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-11-12 03:15:11 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-11-12 03:16:33 +0100otto_s(~user@p5de2f676.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-12 03:18:21 +0100otto_s(~user@p5b044554.dip0.t-ipconnect.de)
2023-11-12 03:19:41 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-11-12 03:20:34 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-12 03:25:51 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 260 seconds)
2023-11-12 03:29:43 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-11-12 03:37:29 +0100Sciencentistguy7(~sciencent@hacksoc/ordinary-member)
2023-11-12 03:39:50 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 255 seconds)
2023-11-12 03:39:50 +0100Sciencentistguy7Sciencentistguy
2023-11-12 04:03:18 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-12 04:03:18 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-12 04:03:18 +0100finn_elijaFinnElija
2023-11-12 04:18:06 +0100Umeaboy(~Umeaboy@94-255-145-133.cust.bredband2.com) (Quit: Leaving)
2023-11-12 04:18:46 +0100nate3(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-11-12 04:21:01 +0100sympt(~sympt@user/sympt) (Server closed connection)
2023-11-12 04:21:13 +0100td_(~td@i5387091C.versanet.de) (Ping timeout: 246 seconds)
2023-11-12 04:21:58 +0100sympt(~sympt@user/sympt)
2023-11-12 04:23:16 +0100td_(~td@i53870938.versanet.de)
2023-11-12 04:29:48 +0100orcus(~orcus@mail.brprice.uk) (Server closed connection)
2023-11-12 04:30:08 +0100orcus(~orcus@mail.brprice.uk)
2023-11-12 04:31:40 +0100sdz(~sdz@user/sdz)
2023-11-12 04:33:59 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 258 seconds)
2023-11-12 04:50:20 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-11-12 05:03:56 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 252 seconds)
2023-11-12 05:05:42 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-11-12 05:12:45 +0100Inst(~Inst@120.244.192.250)
2023-11-12 05:13:50 +0100aforemny_(~aforemny@2001:9e8:6cd8:e200:b35d:4788:701d:c1c7) (Ping timeout: 252 seconds)
2023-11-12 05:13:56 +0100aforemny(~aforemny@i59F516D8.versanet.de)
2023-11-12 05:20:37 +0100xff0x(~xff0x@2405:6580:b080:900:fcad:32c3:a424:90e2) (Quit: xff0x)
2023-11-12 05:25:18 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-11-12 05:29:20 +0100xff0x(~xff0x@2405:6580:b080:900:72e:4231:b28b:9e26)
2023-11-12 05:36:19 +0100Luj(~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Server closed connection)
2023-11-12 05:36:23 +0100Lycurgus(~georg@li1192-118.members.linode.com)
2023-11-12 05:36:23 +0100Lycurgus(~georg@li1192-118.members.linode.com) (Changing host)
2023-11-12 05:36:23 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-12 05:36:37 +0100Luj(~Luj@2a01:e0a:5f9:9681:b46d:d922:28d3:ba58)
2023-11-12 05:40:57 +0100liyang(sid322268@id-322268.uxbridge.irccloud.com) (Server closed connection)
2023-11-12 05:41:05 +0100liyang(sid322268@id-322268.uxbridge.irccloud.com)
2023-11-12 05:49:06 +0100sefidel(~sefidel@user/sefidel) (Remote host closed the connection)
2023-11-12 05:50:13 +0100gaze_____(sid387101@id-387101.helmsley.irccloud.com) (Server closed connection)
2023-11-12 05:50:31 +0100gaze_____(sid387101@id-387101.helmsley.irccloud.com)
2023-11-12 05:52:23 +0100sefidel(~sefidel@user/sefidel)
2023-11-12 05:55:40 +0100 <hololeap> is this a ghc or a Cabal bug?
2023-11-12 05:56:40 +0100 <hololeap> https://gist.github.com/hololeap/aa0311a200bc6a2f7a009a55eed6ba0e#file-build-log-L315-L317
2023-11-12 06:15:57 +0100johnw(~johnw@69.62.242.138)
2023-11-12 06:18:30 +0100bliminse(~bliminse@user/bliminse)
2023-11-12 06:21:51 +0100trev(~trev@user/trev)
2023-11-12 06:26:14 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-12 06:32:03 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-11-12 06:32:33 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2023-11-12 06:32:41 +0100 <sclv> hololeap: looks like the issue is v1-build doesn’t work with internal packages
2023-11-12 06:33:15 +0100 <hololeap> sclv: thanks! I was thinking the same thing, but what makes you say that?
2023-11-12 06:34:16 +0100 <sclv> well its a known shortcoming of v1 build and the log looks similar to the times ive seen that problem bite hackage builder
2023-11-12 06:35:13 +0100TheCatCollective(NyaaTheKit@user/calculuscat) (Server closed connection)
2023-11-12 06:35:26 +0100 <hololeap> I was thinking about splitting the internal package out as a separate package downstream
2023-11-12 06:36:02 +0100TheCatCollective(NyaaTheKit@user/calculuscat)
2023-11-12 06:36:46 +0100leah2(~leah@vuxu.org) (Server closed connection)
2023-11-12 06:37:11 +0100leah2(~leah@vuxu.org)
2023-11-12 06:37:19 +0100Ou42(~Ou42@2600:381:fee0:1e1:9cad:92a7:4b60:aa08)
2023-11-12 06:37:28 +0100 <hololeap> (for pandoc)
2023-11-12 06:38:24 +0100 <hololeap> because we keep hitting this problem with various packages that depend on it, but only like 10% of the time
2023-11-12 06:39:27 +0100 <hololeap> a build-bot hit it recently: https://bugs.gentoo.org/916785
2023-11-12 06:52:38 +0100 <Ou42> Hello. I'm attempting to solve Advent-of-Code-2022-Day 13. I'm stuck getting the input data into a recursive data struct. I'd trying to roll my own, any help?
2023-11-12 06:53:30 +0100 <Ou42> <https://adventofcode.com/2022/day/13>
2023-11-12 06:54:56 +0100 <Ou42> <https://github.com/Ou42/AoC-2022/blob/ecbdb467001174f46d9c5ab9f1d11295a17865ab/days/13/day-13.hs#L…>
2023-11-12 06:55:00 +0100 <Ou42> It outputs:
2023-11-12 06:56:50 +0100 <Ou42> `[[[6,10],4,3,[4]]]` when it should be: `[[[6,10],[4,3,[4]]]]`
2023-11-12 07:01:11 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 258 seconds)
2023-11-12 07:02:12 +0100xff0x(~xff0x@2405:6580:b080:900:72e:4231:b28b:9e26) (Quit: xff0x)
2023-11-12 07:05:57 +0100xff0x(~xff0x@2405:6580:b080:900:a560:5a24:e27a:a22e)
2023-11-12 07:08:21 +0100 <hololeap> Ou42: for any strings like `[1,[2,[3,[4,[5,6,7]]]],8,9]`, you could use `read`
2023-11-12 07:09:07 +0100 <hololeap> wait no... nvm
2023-11-12 07:09:19 +0100 <Ou42> hololeap: can you elaborate? AFAIK, `read` is used to convert text to Int.
2023-11-12 07:09:52 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-11-12 07:10:17 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-12 07:11:59 +0100 <hololeap> Tree seems like the most natural representation here
2023-11-12 07:12:03 +0100 <hololeap> https://hackage.haskell.org/package/containers-0.7/docs/Data-Tree.html
2023-11-12 07:12:03 +0100Square(~Square@user/square)
2023-11-12 07:12:47 +0100 <hololeap> except your root would be a Forest instead of a Tree
2023-11-12 07:13:38 +0100 <Ou42> cool. thanks.
2023-11-12 07:13:38 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 07:14:27 +0100 <monochrom> PacketVals and PacketLists are already trees and forests, and arguably more accurate than Data.Tree for this.
2023-11-12 07:14:43 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Client Quit)
2023-11-12 07:16:01 +0100 <Ou42> I made my own data struct: data PacketVals = Val Int | Nested [PacketVals] deriving Show
2023-11-12 07:16:17 +0100 <Ou42> and: newtype PacketList = Packet [PacketVals] deriving Show
2023-11-12 07:16:35 +0100 <monochrom> There is no mistake in designing the type. You actually have to read the parser code. I am concerned that in the "go (']':c:cs) acc" case, there is a "_ -> [Nested acc]" regardless of whether the _ is '[' or a digit, which aligns with where the parser makes the wrong guess.
2023-11-12 07:16:41 +0100 <Ou42> I will confess I tried to get help from Bing Chat. It failed. Although it's code compiled. Go figure.
2023-11-12 07:17:27 +0100 <Ou42> I figured that's where the issue is, but can't figure it out.
2023-11-12 07:18:17 +0100 <monochrom> More generally I am very skeptic that if you don't go at least "String -> (String, [PacketVals])" you can handle CFG nesting at all.
2023-11-12 07:18:17 +0100 <Ou42> if open sqr bracket '[' then we "descend" right? so it needs to be "Nested", but how to come back up and append if the next char is a ','? that's the reason for the case.
2023-11-12 07:18:47 +0100 <Ou42> what is CFG?
2023-11-12 07:18:51 +0100 <[Leary]> The `go ('[':cs)` case is also bad: the `span` will stop prematurely when the list contains a list. I would write a something like a `parsePacket :: StateT String Maybe PacketVals` and recurse on it in the nested case.
2023-11-12 07:18:55 +0100 <probie> CFG = Context Free Grammar
2023-11-12 07:19:14 +0100 <monochrom> "what is CFG?" is the appropriate kind of question to ask Bing.
2023-11-12 07:19:18 +0100 <monochrom> Coding is not.
2023-11-12 07:20:07 +0100 <Ou42> ha. I did change tack and asked it for tutorials. I don't have GPT, but Bing at least cites its sources.
2023-11-12 07:20:19 +0100 <monochrom> Along with "write a speech for a popularist politician who plots to be a tyrant".
2023-11-12 07:20:49 +0100 <Ou42> I'm running for world dictator in 2042. Vote for me.
2023-11-12 07:22:01 +0100 <Ou42> "String -> (String, [PacketVals])" isn't that rather similar to using an accumulator var?
2023-11-12 07:23:51 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com) (Remote host closed the connection)
2023-11-12 07:25:32 +0100 <Ou42> ... I'm guessing here, but I'm "losing" the past accumulator, but isn't there a way it is saved on the call stack?
2023-11-12 07:26:55 +0100 <hololeap> it needs to be referenced to be "saved"
2023-11-12 07:27:43 +0100 <hololeap> you can pass it as an argument, for instance
2023-11-12 07:28:11 +0100 <Ou42> so acc ( accumulator ) would need to become ... a stack?
2023-11-12 07:28:24 +0100 <Ou42> pop the most recent off etc etc
2023-11-12 07:28:45 +0100 <Ou42> the more I think about this the more i question how it's even compiling
2023-11-12 07:30:11 +0100 <Ou42> one of Bing's suggestions -- no accumulator, that was my idea -- was to look ahead using span until the first ']'. Again, it compiled and ran, but wrong results.
2023-11-12 07:30:31 +0100 <Ou42> it took me a while to see that it needs to read ahead to the *matching* closing sqr bracket.
2023-11-12 07:32:22 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-12 07:35:01 +0100 <mauke> where "cites its sources" = "adds links to its randomly generated output"
2023-11-12 07:35:43 +0100 <monochrom> Oh you mean like this? https://www.vex.net/~trebla/humour/lmcify.html
2023-11-12 07:35:50 +0100 <EvanR> it's funny "saving stuff on the call stack" is sometimes an actual thing, the argument thunks
2023-11-12 07:36:54 +0100 <EvanR> but I don't know how much explanatory power that has for your problem
2023-11-12 07:37:26 +0100 <EvanR> haskell rewards you for using equational reasoning most of the time, not implementation details
2023-11-12 07:39:15 +0100 <hololeap> Ou42: a parsing library such as *pandoc would be useful here
2023-11-12 07:39:30 +0100 <monochrom> wait, pandoc? parsec?
2023-11-12 07:39:32 +0100 <hololeap> s/pandoc/parsec
2023-11-12 07:39:49 +0100 <hololeap> megaparsec, parsec, attoparsec
2023-11-12 07:40:16 +0100 <mauke> monochrom: re: the _ case, I don't think that should ever happen anyway
2023-11-12 07:40:19 +0100 <EvanR> parsec is kind of overkill for that AOC problem, it was pretty easy to just use a recursive algorithm
2023-11-12 07:40:26 +0100 <EvanR> it helps that the input data is well formed
2023-11-12 07:40:47 +0100 <EvanR> so your equations are much simplified at the return type is not a Maybe
2023-11-12 07:42:17 +0100 <monochrom> Sometimes I use ReadP (or even Read and handwrite [ (x5, cs5) | (x1, cs1) <- foo cs, (x2, cs2) <- bar x1 cs1, ... ])
2023-11-12 07:42:20 +0100 <hololeap> I don't think it's overkill. why implement the details yourself when parsec is such a light dep
2023-11-12 07:43:26 +0100 <hololeap> I guess for a beginner parsec might be more confusing than just implementing it yourself
2023-11-12 07:43:27 +0100 <Ou42> baby steps?
2023-11-12 07:43:43 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-12 07:43:56 +0100 <Ou42> I'm not arguing against your suggestions ( parsect, readP ( used it once! ) ) but I just want to level up w/ recursion first.
2023-11-12 07:44:12 +0100 <hololeap> fair enough
2023-11-12 07:44:45 +0100 <monochrom> CFG parsing is confusing no matter how you dice it. Because on top of recursion you are reverse-engineering another recursion.
2023-11-12 07:45:06 +0100gmg(~user@user/gehmehgeh)
2023-11-12 07:45:06 +0100 <mauke> so I tried a few simple examples and it keeps throwing errors at me (non-exhaustive patterns)
2023-11-12 07:45:44 +0100 <mauke> like `go "1" []` or `go "[1,2]" []`
2023-11-12 07:45:45 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com)
2023-11-12 07:47:00 +0100 <Ou42> mauke: ty for trying...
2023-11-12 07:47:06 +0100 <Ou42> i assume it's not well formed.
2023-11-12 07:47:17 +0100 <Ou42> all Packets are surrounded by [ ] 's
2023-11-12 07:48:04 +0100 <mauke> [1,2] is surrounded by [ ]
2023-11-12 07:48:04 +0100 <Ou42> so at the very least, "[]" is required... `go [1,2]` should have worked... how about the go func in parse3?
2023-11-12 07:48:29 +0100 <Ou42> many changes... hard to rem where I'm at. sorry.
2023-11-12 07:49:23 +0100 <Ou42> but it compiled and ran for all 8 examples and even ran on the 150 in the actual (personalized) puzzle input... but that's not parse3... but a predecesor that used span incorrectly.
2023-11-12 07:49:42 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-12 07:50:11 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-12 07:50:12 +0100 <mauke> I don't see how to get anything working with a type like String -> [PacketVals] -> [PacketVals]
2023-11-12 07:50:15 +0100 <hololeap> which `go` are we talking about? there's a few
2023-11-12 07:52:35 +0100 <mauke> the one in bingParse3 looks like it has issues with ']' handling; the one in parseP3 looks identical to parseP4 at first glance
2023-11-12 07:53:25 +0100 <Ou42> it is, wanted a "do not touch" version so as to have something to ask w/o it changing. already forgot and it's not even been an hour.
2023-11-12 07:53:34 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2023-11-12 07:54:06 +0100 <mauke> I think the crucial point is that you need to know where (in the input string) a recursive parse stopped reading so you can continue from that point
2023-11-12 07:54:50 +0100 <mauke> in my very first parser in C, I came up with the idea of using a char ** (pointer-to-pointer, so the recursive calls could modify my string pointer)
2023-11-12 07:55:07 +0100 <mauke> the Haskell equivalent is to return a (String, Result) tuple
2023-11-12 07:55:21 +0100 <mauke> where the first component represents the remaining input
2023-11-12 07:55:38 +0100zaquest(~notzaques@5.130.79.72)
2023-11-12 07:55:45 +0100Inst(~Inst@120.244.192.250) (Read error: Connection reset by peer)
2023-11-12 07:56:20 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com) (Remote host closed the connection)
2023-11-12 07:57:33 +0100gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-11-12 07:58:17 +0100gmg(~user@user/gehmehgeh)
2023-11-12 07:58:26 +0100paddymahoney(~paddymaho@cpe883d24bcf597-cmbc4dfb741f80.cpe.net.cable.rogers.com)
2023-11-12 07:58:38 +0100 <mauke> parseVal :: String -> (String, PacketVal); parseVal (c : cs) | isDigit c = let (num, rest) = span isDigit cs in (rest, Val (read (c : num)))
2023-11-12 07:58:51 +0100gdown(~gavin@h69-11-149-109.kndrid.broadband.dynamic.tds.net) (Ping timeout: 260 seconds)
2023-11-12 07:58:53 +0100bw___(sid2730@id-2730.ilkley.irccloud.com) (Server closed connection)
2023-11-12 07:59:20 +0100bw___(sid2730@id-2730.ilkley.irccloud.com)
2023-11-12 08:02:49 +0100 <Ou42> mauke: tyvm! I need to chew on that.
2023-11-12 08:03:17 +0100 <mauke> parseVal ('[' : cs) = go cs [] where go (']' : rest) acc = (rest, PacketVals acc); go cs acc = let (rest, val) = parseVal cs in (dropWhile (== ',') rest, acc ++ [val])
2023-11-12 08:03:18 +0100 <Ou42> there's something fishy about recursion -- granted it was evil until a recently -- so many it's just messing with me. ;o)
2023-11-12 08:03:20 +0100 <mauke> or something like that
2023-11-12 08:04:10 +0100 <mauke> disclaimer: zero error handling; could be more efficient by building the accumulator with : and reversing at the end
2023-11-12 08:05:25 +0100andrewboltachev(~andrey@178.141.201.173) (Quit: Leaving.)
2023-11-12 08:05:41 +0100 <mauke> and it silently accepts trailing commas anywhere within a list, like perl :-)
2023-11-12 08:06:34 +0100 <mauke> oh, and it's broken: the last clause should call 'go' again, not return a tuple
2023-11-12 08:09:09 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-12 08:10:43 +0100yoyofreeman(~yoyofreem@176.97.76.178) (Remote host closed the connection)
2023-11-12 08:12:24 +0100yoyofreeman(~yoyofreem@176.97.76.178)
2023-11-12 08:12:27 +0100 <Ou42> I keep trying things, it takes longer than expected then I get the "oh yeah, that doesn't work" experience.
2023-11-12 08:12:44 +0100 <Ou42> if it wasn't for short term memory loss, I'd be having a rather bad day.
2023-11-12 08:13:02 +0100 <mauke> y-yay?
2023-11-12 08:19:07 +0100Inst(~Inst@120.244.192.250)
2023-11-12 08:21:13 +0100michalz(~michalz@185.246.207.221)
2023-11-12 08:23:27 +0100 <Ou42> wild ride. I need more time. thanks for the help!
2023-11-12 08:23:39 +0100 <Ou42> gotta call it a night.
2023-11-12 08:23:50 +0100Ou42(~Ou42@2600:381:fee0:1e1:9cad:92a7:4b60:aa08) (Quit: Rick Rolled 1 too many times)
2023-11-12 08:26:14 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2023-11-12 08:30:35 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-11-12 08:41:47 +0100qqq(~qqq@92.43.167.61) (Remote host closed the connection)
2023-11-12 08:47:31 +0100 <phma> Suppose I have four threads. I have a list which is computed by taking [0..] and mapping a really complicated function over it.
2023-11-12 08:49:07 +0100 <phma> Is there a way to compute f(0) in thread 0, f(1) in thread 1, f(2) in thread 2, f(3) in thread 3, f(4) in thread 0 but not overlapping with f(0), and so on?
2023-11-12 08:49:59 +0100 <phma> I tried chunking in Control.Parallel.Strategies but ended up getting the program killed because it used too much memory.
2023-11-12 08:55:59 +0100michalz(~michalz@185.246.207.203)
2023-11-12 08:58:14 +0100sdz(~sdz@user/sdz) (Ping timeout: 252 seconds)
2023-11-12 08:58:41 +0100yoyofreeman(~yoyofreem@176.97.76.178) (Ping timeout: 252 seconds)
2023-11-12 08:58:56 +0100sdz(~sdz@user/sdz)
2023-11-12 08:59:42 +0100catilina(~user@user/catilina) (Ping timeout: 255 seconds)
2023-11-12 09:00:10 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-11-12 09:09:17 +0100Jackneill(~Jackneill@20014C4E1E058A00F5A2357F979DDCC7.dsl.pool.telekom.hu)
2023-11-12 09:11:13 +0100notzmv(~zmv@user/notzmv)
2023-11-12 09:17:48 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 09:29:21 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-12 09:44:15 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-12 09:44:25 +0100qqq(~qqq@92.43.167.61)
2023-11-12 09:45:25 +0100it__(~quassel@v2202212189510211193.supersrv.de) (Server closed connection)
2023-11-12 09:45:34 +0100it_(~quassel@v2202212189510211193.supersrv.de)
2023-11-12 09:51:37 +0100ubert(~Thunderbi@178.165.170.224.wireless.dyn.drei.com)
2023-11-12 09:58:43 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-11-12 09:58:52 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 264 seconds)
2023-11-12 10:06:25 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-12 10:06:49 +0100new-account-2(~new-accou@user/new-account-2)
2023-11-12 10:07:41 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-11-12 10:08:54 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-11-12 10:09:57 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-11-12 10:14:26 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-11-12 10:14:37 +0100mechap(~mechap@user/mechap)
2023-11-12 10:15:28 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-11-12 10:20:11 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 10:20:41 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 10:21:35 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-12 10:22:15 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 240 seconds)
2023-11-12 10:24:30 +0100steew(~steew@user/steew) (Server closed connection)
2023-11-12 10:24:52 +0100ubert(~Thunderbi@178.165.170.224.wireless.dyn.drei.com) (Ping timeout: 246 seconds)
2023-11-12 10:24:58 +0100steew(~steew@user/steew)
2023-11-12 10:34:52 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 264 seconds)
2023-11-12 10:35:23 +0100Inst(~Inst@120.244.192.250) (Remote host closed the connection)
2023-11-12 10:35:43 +0100Inst(~Inst@120.244.192.250)
2023-11-12 10:36:13 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-12 10:44:48 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:d0e6:54a3:ea5c:7672) (Remote host closed the connection)
2023-11-12 10:45:03 +0100acidjnk(~acidjnk@p200300d6e72b9351ac6f5a8b7958b98c.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-11-12 10:45:23 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-11-12 10:49:07 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 10:49:43 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds)
2023-11-12 10:51:15 +0100tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Remote host closed the connection)
2023-11-12 10:51:27 +0100tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2023-11-12 10:59:47 +0100chiselfu1e(~chiselfus@user/chiselfuse)
2023-11-12 11:00:15 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-12 11:00:15 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-11-12 11:00:39 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-12 11:00:46 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-12 11:03:04 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 264 seconds)
2023-11-12 11:04:35 +0100Square(~Square@user/square) (Ping timeout: 260 seconds)
2023-11-12 11:11:07 +0100Taneb(~Taneb@runciman.hacksoc.org) (Server closed connection)
2023-11-12 11:11:22 +0100Taneb(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0)
2023-11-12 11:12:39 +0100sdz(~sdz@user/sdz) (Ping timeout: 240 seconds)
2023-11-12 11:13:40 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-12 11:13:50 +0100sdz(~sdz@user/sdz)
2023-11-12 11:18:32 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a)
2023-11-12 11:21:13 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-12 11:30:47 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-11-12 11:36:17 +0100 <Axman6> phma: You should read PCPH
2023-11-12 11:36:23 +0100 <Axman6> @whre pcph
2023-11-12 11:36:23 +0100 <lambdabot> "Parallel and Concurrent Programming in Haskell" by Simon Marlow in 2013 at <http://community.haskell.org/~simonmar/pcph/>,<http://chimera.labs.oreilly.com/books/1230000000929/>,<https://web.archive.
2023-11-12 11:36:23 +0100 <lambdabot> org/web/20180117194842/http://chimera.labs.oreilly.com/books/1230000000929>,<https://www.oreilly.com/library/view/parallel-and-concurrent/9781449335939/>
2023-11-12 11:51:59 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-12 11:52:20 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-12 12:00:00 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 12:01:05 +0100Me-me(~me-me@2602:ff16:3:0:1:dc:beef:d00d) (Changing host)
2023-11-12 12:01:05 +0100Me-me(~me-me@user/me-me)
2023-11-12 12:12:12 +0100Martin(~Martin@ip-134-003-176-135.um41.pools.vodafone-ip.de)
2023-11-12 12:13:51 +0100Martin2(~Martin2@ip-134-003-176-135.um41.pools.vodafone-ip.de)
2023-11-12 12:14:23 +0100Martin(~Martin@ip-134-003-176-135.um41.pools.vodafone-ip.de) (Client Quit)
2023-11-12 12:14:37 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-12 12:18:10 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-12 12:30:51 +0100mechap(~mechap@user/mechap) (Ping timeout: 258 seconds)
2023-11-12 12:34:19 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-12 12:35:31 +0100ham(~ham@user/ham) (Server closed connection)
2023-11-12 12:35:56 +0100ham(~ham@user/ham)
2023-11-12 12:44:57 +0100sawilagar(~sawilagar@user/sawilagar) (Remote host closed the connection)
2023-11-12 12:45:18 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-12 12:45:58 +0100 <srk> is -threaded a default now?
2023-11-12 12:47:46 +0100 <Hecate> srk: I don't believe so
2023-11-12 12:48:20 +0100 <Inst> add a ghc-options: field in your cabal file / script, I'm not sure what the equivalent workflow is for stack.
2023-11-12 12:48:42 +0100 <srk> hmm. interesting.. something weird changed
2023-11-12 12:49:05 +0100 <srk> I use linux-namespaces in one testsuite and it cannot call unshare in threaded runtime
2023-11-12 12:49:12 +0100 <srk> after clone
2023-11-12 12:50:35 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
2023-11-12 12:50:52 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2023-11-12 12:51:43 +0100 <srk> ghc_ticker? oO
2023-11-12 12:52:07 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-11-12 13:00:13 +0100 <srk> oh yes, that's new.. +RTS -V0 -RTS disables it (Master tick interval in seconds), sounds profiling related
2023-11-12 13:01:01 +0100_73(~Unknown_7@pool-173-76-100-193.bstnma.fios.verizon.net)
2023-11-12 13:02:11 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net) (Ping timeout: 260 seconds)
2023-11-12 13:07:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a) (Ping timeout: 258 seconds)
2023-11-12 13:08:58 +0100glguy_(g@libera/staff/glguy)
2023-11-12 13:09:09 +0100g_(g@libera/staff/glguy)
2023-11-12 13:09:47 +0100mechap(~mechap@user/mechap)
2023-11-12 13:09:53 +0100g(g@libera/staff/glguy) (Read error: Connection reset by peer)
2023-11-12 13:09:53 +0100g_g
2023-11-12 13:10:16 +0100glguy(g@libera/staff/glguy) (Read error: Connection reset by peer)
2023-11-12 13:11:17 +0100PHO`_(~pho@akari.cielonegro.org) (Server closed connection)
2023-11-12 13:11:28 +0100PHO`_(~pho@akari.cielonegro.org)
2023-11-12 13:12:33 +0100 <_73> hey. I'm trying to use JuicyPixels in my stack project. I specified the dependency in my stack.yaml file, and I am able to "stack build" the project successfully. However, if I try to import a module from JuicyPixels (such as Picture.Codec), then stack cannot find the module. Here is the output of an unsuccessful run of "stack build --verbose" https://termbin.com/gs47
2023-11-12 13:12:46 +0100 <_73> Any ideas what I am doing wrong?
2023-11-12 13:15:38 +0100 <srk> _73: try adding JuicyPixels as build-depends for you library in cabal file
2023-11-12 13:17:57 +0100Martin2(~Martin2@ip-134-003-176-135.um41.pools.vodafone-ip.de) (Quit: Connection closed)
2023-11-12 13:18:41 +0100 <_73> srk: I get the same error when I do this and redo the "stack build" command.
2023-11-12 13:22:01 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-12 13:23:39 +0100 <srk> _73: maybe it's coming from executable not from library
2023-11-12 13:24:06 +0100 <srk> exe:hsten-exe suggests so
2023-11-12 13:27:43 +0100tremon(~tremon@83.80.159.219)
2023-11-12 13:28:29 +0100 <_73> Im a bit confused. Doesn't stack produce the .cabal file? After I specify the JuicyPixels dep in the .cabal file (for both the library and executable), I am again left with the original .cabal file again.
2023-11-12 13:30:12 +0100 <srk> I don't know tbh, why use stack? :) is there hpack and package.yaml in play?
2023-11-12 13:32:13 +0100__monty__(~toonn@user/toonn)
2023-11-12 13:33:00 +0100andrewboltachev(~andrey@178.141.201.173)
2023-11-12 13:33:19 +0100Batzy(~quassel@user/batzy) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-11-12 13:38:22 +0100peutri(~peutri@bobo.desast.re) (Server closed connection)
2023-11-12 13:38:31 +0100peutri(~peutri@bobo.desast.re)
2023-11-12 13:39:43 +0100 <_73> specifying the dep in the package.yaml fixed the problem
2023-11-12 13:43:08 +0100Square(~Square@user/square)
2023-11-12 13:43:41 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 240 seconds)
2023-11-12 13:45:46 +0100andrewboltachev(~andrey@178.141.201.173) ()
2023-11-12 13:46:25 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-12 13:47:03 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-12 13:47:11 +0100 <tomsmeding> _73: the *.cabal file is the actual specification for dependencies etc.; when using stack, stack.yaml specifies what ghc version to use and how to configure the build (e.g. where to get those dependencies _from_). With stack you can optionally use a package.yaml, from which stack generates the *.cabal file
2023-11-12 13:47:36 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-12 13:48:03 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-12 13:48:28 +0100 <tomsmeding> with cabal (instead of stack), there's no package.yaml (just write the *.cabal file manually), and cabal.project replaces stack.yaml
2023-11-12 13:52:07 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 13:52:32 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 13:52:44 +0100 <srk> why is stack still a thing..
2023-11-12 13:52:47 +0100AlexZenon(~alzenon@94.233.241.129) (Quit: ;-)
2023-11-12 13:53:39 +0100 <tomsmeding> srk: certain people like the reprodicibility
2023-11-12 13:53:46 +0100 <tomsmeding> *-du-
2023-11-12 13:54:15 +0100 <tomsmeding> same stack.yaml means same resolver means same packages means probably same build result
2023-11-12 13:54:15 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 13:54:34 +0100 <tomsmeding> I also prefer cabal, don't get me wrong
2023-11-12 13:55:00 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 13:57:02 +0100AlexNoo(~AlexNoo@94.233.241.129) (Quit: Leaving)
2023-11-12 13:57:48 +0100 <srk> tomsmeding: well you can set index-state nowadays and use nix for true reproducibility :)
2023-11-12 13:57:52 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 258 seconds)
2023-11-12 13:58:36 +0100 <tomsmeding> index-state means something else, right? A freeze file would be more in line with what a stackage snapshot gives you
2023-11-12 13:58:54 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 13:59:00 +0100 <srk> indeed!
2023-11-12 13:59:02 +0100euleritian(~euleritia@dynamic-046-114-201-248.46.114.pool.telefonica.de)
2023-11-12 13:59:05 +0100 <tomsmeding> And I guess it's true that the argument is mostly invalidated by the existence of freeze files
2023-11-12 13:59:19 +0100euleritian(~euleritia@dynamic-046-114-201-248.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-12 13:59:37 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 14:00:55 +0100 <Rembane> Can't you set the exact version numbers you want for all dependencies in your cabal file?
2023-11-12 14:01:04 +0100 <Rembane> ...to get reproducible builds?
2023-11-12 14:01:04 +0100 <tomsmeding> that's hard to upgrade
2023-11-12 14:01:22 +0100 <tomsmeding> stackage snapshot (and, indeed, a freeze file) is not -- just increment the version number
2023-11-12 14:01:36 +0100 <Rembane> Indeed. I've found some program to help with that, but after using it I promptly forgot the name of it.
2023-11-12 14:01:37 +0100 <srk> Rembane: but you do not list indirect dependencies there, freeze has all of them
2023-11-12 14:01:47 +0100 <Rembane> srk: That's a very good point.
2023-11-12 14:01:50 +0100 <tomsmeding> Rembane: 'cabal outdated'?
2023-11-12 14:02:03 +0100 <Rembane> tomsmeding: That sounds familiar.
2023-11-12 14:02:12 +0100 <tomsmeding> it at least does something related
2023-11-12 14:02:16 +0100 <Rembane> Yes.
2023-11-12 14:03:21 +0100 <srk> til! pretty cool.. I was using https://packdeps.haskellers.com/feed?needle=GPipe until now :D
2023-11-12 14:03:34 +0100_73(~Unknown_7@pool-173-76-100-193.bstnma.fios.verizon.net) ()
2023-11-12 14:03:51 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2023-11-12 14:08:36 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 14:09:03 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 14:10:12 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-11-12 14:21:01 +0100AlexNoo(~AlexNoo@94.233.241.129)
2023-11-12 14:23:59 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
2023-11-12 14:24:15 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2023-11-12 14:26:18 +0100AlexZenon(~alzenon@94.233.241.129)
2023-11-12 14:29:14 +0100mmhat(~mmh@p200300f1c7445e4eee086bfffe095315.dip0.t-ipconnect.de)
2023-11-12 14:29:36 +0100mmhat(~mmh@p200300f1c7445e4eee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-11-12 14:34:12 +0100chiselfu1e(~chiselfus@user/chiselfuse) (Quit: leaving)
2023-11-12 14:34:51 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-11-12 14:35:03 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 240 seconds)
2023-11-12 14:37:26 +0100chiselfuse(~chiselfus@user/chiselfuse) (Remote host closed the connection)
2023-11-12 14:38:15 +0100 <ph88> Could someone help me on discord with a call? I have a few questions about State, fold, intersperse combined
2023-11-12 14:39:53 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-11-12 14:40:49 +0100 <ph88> or matrix perhaps, does matrix do calls ?
2023-11-12 14:44:11 +0100haveo(~weechat@pacamara.iuwt.fr) (Server closed connection)
2023-11-12 14:44:35 +0100haveo(~weechat@pacamara.iuwt.fr)
2023-11-12 14:49:16 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 264 seconds)
2023-11-12 14:52:46 +0100swistak(~swistak@185.21.216.141) (Server closed connection)
2023-11-12 14:53:06 +0100swistak(~swistak@185.21.216.141)
2023-11-12 14:57:26 +0100Adran(~adran@botters/adran) (Server closed connection)
2023-11-12 14:57:39 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-12 15:00:32 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-12 15:01:11 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-11-12 15:03:38 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-11-12 15:04:32 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a)
2023-11-12 15:04:37 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-12 15:09:09 +0100danza(~francesco@151.57.226.145)
2023-11-12 15:10:14 +0100 <Inst> vty vs brick: i've set a goal for myself of learning either one this week
2023-11-12 15:10:25 +0100 <Inst> is there a reason i should prefer either? Or are they equally valid?
2023-11-12 15:11:16 +0100 <EvanR> what's the objective application
2023-11-12 15:11:43 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-12 15:12:29 +0100euleritian(~euleritia@77.22.252.56)
2023-11-12 15:12:40 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (Quit: WeeChat 4.1.1)
2023-11-12 15:13:53 +0100 <Inst> just me messing around, and trying to avoid using naive console UI in the future
2023-11-12 15:14:32 +0100 <Inst> something to default to in lieu of putStrLn someCrapIveSpecifiedElsewhere and thisIsHorriblyNaiveAndIsDumb <- getLine
2023-11-12 15:14:34 +0100 <EvanR> I find that a concrete objective makes it easier to learn the tools
2023-11-12 15:14:37 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-12 15:15:04 +0100 <Inst> i'd go port tower of hanoi over
2023-11-12 15:15:10 +0100 <Inst> or 3d maze, or something like that
2023-11-12 15:15:23 +0100 <EvanR> and in this case it might make the choice of library more meaningful
2023-11-12 15:15:27 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2023-11-12 15:15:28 +0100 <Inst> but i have something to do this week, so, dumbest possible toy example: "What is your name?" "Hello user"
2023-11-12 15:15:40 +0100 <Inst> in this case, I get the feeling right now vty is more suitable
2023-11-12 15:16:04 +0100 <Inst> I complained re monomer that it was awfully unintuitive to learn
2023-11-12 15:16:10 +0100euleritian(~euleritia@77.22.252.56)
2023-11-12 15:16:18 +0100 <Inst> and it's an "easy to use library, but only for experienced Haskellers"
2023-11-12 15:16:29 +0100 <Inst> looking at how Brick is set up, I can understand why it'd be considered easy to use
2023-11-12 15:16:59 +0100 <EvanR> if something is "easy to learn" that probably means you didn't learn very much and had already known the better part of the subject
2023-11-12 15:19:34 +0100nurupo(~nurupo.ga@user/nurupo) (Server closed connection)
2023-11-12 15:19:48 +0100nurupo(~nurupo.ga@user/nurupo)
2023-11-12 15:19:58 +0100 <Inst> when it comes to libraries, is that a good thing, though?
2023-11-12 15:20:23 +0100 <EvanR> haskell was easy to learn for me because prior fp education, I'm told haskell is hard to learn and esoteric by other people
2023-11-12 15:20:38 +0100 <EvanR> how can they both be true?!
2023-11-12 15:21:04 +0100 <EvanR> because it's not an intrinsic
2023-11-12 15:21:28 +0100 <Inst> Where did you come in from, anyways?
2023-11-12 15:22:06 +0100 <Unicorn_Princess> those people are wrong. i had no prior fp background, and haskell was easy to learn for me too. at least the basics, before you get into more esoteric, complex monad trickery, or dealing with nasty implementation issues like memory leaks or lazyness edge cases
2023-11-12 15:22:26 +0100 <Inst> I got into Haskell because it seemed to be easier to learn than C++
2023-11-12 15:22:51 +0100 <Inst> was supposed to take a 6 month detour, then go try to master C++, but instead, it's been 2 years, here we are
2023-11-12 15:22:58 +0100 <srk> Inst: brick is awesome, definitely worth learning
2023-11-12 15:23:04 +0100 <Unicorn_Princess> cuz the essence of haskell _is_ simple. of course you can build complex stuff on top, like pro-bifunctor affine traversals or w/e is the current hot thing in CT land, but at it's base it's very elegant and intuitive
2023-11-12 15:23:11 +0100 <srk> brick for UIs, vty for lower level things
2023-11-12 15:23:13 +0100 <Unicorn_Princess> and that's coming from c++ hellscape
2023-11-12 15:23:52 +0100 <EvanR> your brain was already on overdrive from learning C++, so haskell was relatively easy xD
2023-11-12 15:24:01 +0100 <srk> :D
2023-11-12 15:24:10 +0100 <Unicorn_Princess> yeah could be :S
2023-11-12 15:25:01 +0100 <EvanR> I get "haskell makes no sense whatsoever" from web dynamic languages people
2023-11-12 15:25:14 +0100 <Inst> It's more interesting WHY it makes no sense to them
2023-11-12 15:25:19 +0100 <Unicorn_Princess> i've said it before and i'll say it again
2023-11-12 15:25:21 +0100 <Unicorn_Princess> > web
2023-11-12 15:25:22 +0100 <lambdabot> error: Variable not in scope: web
2023-11-12 15:25:23 +0100 <Unicorn_Princess> > people
2023-11-12 15:25:24 +0100 <lambdabot> error: Variable not in scope: people
2023-11-12 15:25:26 +0100 <Unicorn_Princess> pick _one_
2023-11-12 15:25:35 +0100 <Inst> i guess at least out of purely anthropological interest
2023-11-12 15:25:43 +0100 <Unicorn_Princess> *zoological
2023-11-12 15:25:52 +0100 <Rembane> EvanR: Maybe they come frustrated when the type checker becomes confused at them?
2023-11-12 15:25:55 +0100 <EvanR> because PHP was invented, haskell was discovered
2023-11-12 15:26:46 +0100 <EvanR> haskell doesn't automatically fit into human affordances xD
2023-11-12 15:28:05 +0100lg188(~lg188@82.18.98.230) (Ping timeout: 240 seconds)
2023-11-12 15:29:15 +0100 <Inst> vty ironically makes more sense to me than brick at this point
2023-11-12 15:29:21 +0100 <EvanR> (that was a variation on an SPJ joke, haskell was in fact also invented for humans by humans)
2023-11-12 15:30:07 +0100 <Inst> which joke was that? ?:(
2023-11-12 15:30:24 +0100 <EvanR> haskell was discovered, not invented. *I think you can tell*
2023-11-12 15:31:58 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-12 15:32:18 +0100 <Inst> https://corecursive.com/021-gods-programming-language-with-philip-wadler/
2023-11-12 15:32:20 +0100 <Inst> this?
2023-11-12 15:32:29 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2023-11-12 15:32:57 +0100 <EvanR> that looks apropos to the sentiment
2023-11-12 15:35:17 +0100Adran(~adran@botters/adran)
2023-11-12 15:36:47 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2023-11-12 15:36:53 +0100 <Inst> also, speaking of Wadler, wow
2023-11-12 15:36:55 +0100 <Inst> https://www.amazon.in/Java-Generics-Collections-Fundamentals-Recommended/dp/1098136721
2023-11-12 15:37:37 +0100euleritian(~euleritia@77.22.252.56)
2023-11-12 15:38:29 +0100 <Inst> by the way
2023-11-12 15:38:34 +0100 <Inst> https://hackage.haskell.org/package/vty-6.0/docs/Graphics-Vty.html#t:Vty
2023-11-12 15:38:47 +0100 <Inst> what is this design? A record of IO functions
2023-11-12 15:38:57 +0100 <Inst> is it OOP?
2023-11-12 15:39:50 +0100 <EvanR> no in the sense of cardelli theory of objects because those functions don't take a self parameter
2023-11-12 15:39:53 +0100 <EvanR> not*
2023-11-12 15:40:26 +0100 <EvanR> but record of functions as a way to allow varying behavior is also common in C
2023-11-12 15:41:33 +0100 <Inst> record of functions is really weird to me, i've also seen something like that in the Cabal custom build system
2023-11-12 15:41:52 +0100 <EvanR> it's like a more flexible but more explicit type class
2023-11-12 15:42:12 +0100 <EvanR> manual dictionary passing
2023-11-12 15:43:07 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 264 seconds)
2023-11-12 15:43:27 +0100 <Inst> i mean implicitly you could do self, though
2023-11-12 15:43:28 +0100 <EvanR> UI libraries that consist of a driver loop which executes your "callbacks" is pretty common
2023-11-12 15:43:46 +0100 <Inst> since when you're defining a datatype like that, you can use where etc to extract data recursively from the host object
2023-11-12 15:43:52 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 264 seconds)
2023-11-12 15:44:04 +0100 <Inst> thanks <EvanR3
2023-11-12 15:44:15 +0100 <EvanR> you can, then it would be OOP in the sense of cardelli
2023-11-12 15:44:24 +0100 <Inst> well, not defining a datatype like that, defining a value of a datatype like that
2023-11-12 15:46:34 +0100 <EvanR> which leads to the idea of corecursive codata which is potentially infinite and usefully productive
2023-11-12 15:47:36 +0100 <EvanR> a stream allows you to continually ask for the next item and rest of stream, an object allows you to continually ask any question that's part of its class, which might return an updated object
2023-11-12 15:48:10 +0100notzmv(~zmv@user/notzmv)
2023-11-12 15:48:23 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 15:50:41 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1)
2023-11-12 15:52:07 +0100Fangs(sid141280@id-141280.hampstead.irccloud.com) (Server closed connection)
2023-11-12 15:52:19 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-12 15:52:21 +0100Fangs(sid141280@id-141280.hampstead.irccloud.com)
2023-11-12 15:53:03 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2023-11-12 15:55:06 +0100notzmv(~zmv@user/notzmv)
2023-11-12 15:57:53 +0100 <Inst> at least this was less painful than not figuring out that aeson was using typeclass based interfaces for its decode function for the longest time
2023-11-12 15:59:54 +0100 <EvanR> another library with a similar interface is gloss. But they take the fields of the record of functions as separate arguments instead of grouped into a record
2023-11-12 16:00:38 +0100 <EvanR> same concept, driver loop calls your callbacks
2023-11-12 16:02:26 +0100 <Inst> it just feels smelly, like, i can theoretically stuff anything i want into the record type as long as the types match
2023-11-12 16:02:42 +0100acidjnk(~acidjnk@p200300d6e72b933884d06dff6b3ba200.dip0.t-ipconnect.de)
2023-11-12 16:02:54 +0100 <Inst> with IO I could hide something that starts a keylogger, for example
2023-11-12 16:03:25 +0100 <Inst> and as a question of IO isolation, is the record in IO or is it out of IO?
2023-11-12 16:04:16 +0100 <EvanR> gloss has a pure version as well as IO versions
2023-11-12 16:04:37 +0100 <EvanR> if you don't use the IO version your program can do nothing but show graphics and get user input
2023-11-12 16:04:53 +0100 <EvanR> the record is just a way of grouping the data
2023-11-12 16:06:05 +0100 <EvanR> maybe vty has the same thing, or maybe the designer thought that wouldn't be very useful
2023-11-12 16:07:54 +0100new-account-2(~new-accou@user/new-account-2) (Quit: Client closed)
2023-11-12 16:07:54 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 16:08:36 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Client Quit)
2023-11-12 16:12:26 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-12 16:13:19 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 16:20:50 +0100Lycurgus(~georg@li1192-118.members.linode.com)
2023-11-12 16:20:51 +0100Lycurgus(~georg@li1192-118.members.linode.com) (Changing host)
2023-11-12 16:20:51 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-12 16:22:15 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-12 16:28:52 +0100actioninja(~actioninj@user/actioninja) (Server closed connection)
2023-11-12 16:29:16 +0100actioninja(~actioninj@user/actioninja)
2023-11-12 16:30:10 +0100Nixkernal_(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-11-12 16:33:16 +0100Tlsx(~rscastilh@187.40.125.21)
2023-11-12 16:36:07 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-11-12 16:37:51 +0100Tlsx(~rscastilh@187.40.125.21) (Ping timeout: 240 seconds)
2023-11-12 16:39:21 +0100Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch)
2023-11-12 16:40:10 +0100hc(~hc@bsd.pm)
2023-11-12 16:40:12 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-12 16:43:20 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2023-11-12 16:43:32 +0100pavonia(~user@user/siracusa)
2023-11-12 16:43:47 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2023-11-12 16:45:21 +0100 <hc> Hello, just for fun I'm writing a library where you can write something like: a = (Z 5) :: Z 23 Now a has the value 5 in the ring Z_23.
2023-11-12 16:46:08 +0100 <hc> Problem is, I need to declare the type in addition to calling the data constructor. My question is, could I write a function mkNum a b that takes as a the 23 of Z_23 and as b the actual numer like 5, so I could write a = mkZ 23 5 isntead of a=(Z 5) :: Z23 ?
2023-11-12 16:49:09 +0100 <EvanR> MkZ @23 5 ?
2023-11-12 16:49:17 +0100 <EvanR> visible type application
2023-11-12 16:49:18 +0100 <probie> hc: You can't. What you can probably do however is `Z @23 5`
2023-11-12 16:49:59 +0100 <hc> Ah, that's the new syntax I just learnt about in one of the well-typed youtube haskell videos
2023-11-12 16:50:02 +0100 <hc> Thanks, will try
2023-11-12 16:50:29 +0100 <APic> lol
2023-11-12 16:50:59 +0100Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-11-12 16:51:19 +0100 <hc> Nice, that works!
2023-11-12 16:52:45 +0100Tlsx(~rscastilh@187.40.125.21)
2023-11-12 16:56:54 +0100 <Inst> i love this guy on FP Discord
2023-11-12 16:57:07 +0100 <Inst> he got into a fight after someone trashed him for not understanding the Haskell import system
2023-11-12 16:57:59 +0100 <Inst> took him aside, put in some comfort, then he showed me some code he was debugging, which was wrong because he didn't understand how (>>=) worked, he had a really great time realizing how to understand Haskell's types
2023-11-12 16:58:18 +0100 <Inst> then we discussed how foo =<< bar is better than foo(bar())
2023-11-12 16:59:13 +0100 <Inst> with him showing an example of how method chaining in Rust created a very subtle bug that would have been avoided with explicit bind operators in Haskell
2023-11-12 17:00:17 +0100hc_(~hc@ip-185-104-142-44.hosts-fiberone.de)
2023-11-12 17:00:33 +0100hc(~hc@bsd.pm) (Quit: leaving)
2023-11-12 17:00:44 +0100hc_hc
2023-11-12 17:01:08 +0100 <EvanR> for maximum diversity use an even mix of foo =<< bar and bar >>= foo
2023-11-12 17:01:28 +0100 <Inst> sarcasm noted :(
2023-11-12 17:01:38 +0100 <EvanR> no
2023-11-12 17:01:44 +0100 <Inst> you literally can't do that iirc because =<< and >>= have different fixities
2023-11-12 17:02:08 +0100 <EvanR> yes not in the same chain
2023-11-12 17:02:13 +0100 <duncan> how exactly do you take someone aside on an online chatroom?
2023-11-12 17:02:23 +0100 <EvanR> "PM me" lol
2023-11-12 17:02:36 +0100 <EvanR> (always a bad sign)
2023-11-12 17:03:36 +0100 <duncan> uh-oh
2023-11-12 17:03:39 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-12 17:04:24 +0100 <Inst> i mean =<< and >>= express different ideas
2023-11-12 17:04:32 +0100 <Inst> imo >>= expresses chaining of monadic functions
2023-11-12 17:04:36 +0100 <Inst> and an order of effects
2023-11-12 17:04:52 +0100 <Inst> =<< seems to me, denote a function call
2023-11-12 17:05:15 +0100 <Inst> or function application, the code does the same thing but the concept being expressed is different
2023-11-12 17:05:19 +0100 <EvanR> they do the same thing
2023-11-12 17:05:34 +0100 <EvanR> it's a stylistic choice
2023-11-12 17:08:22 +0100 <EvanR> and foo |> bar |> baz in elixir is still just reverse function application
2023-11-12 17:08:32 +0100 <probie> Remember to mix in `>=>` and `<=<`
2023-11-12 17:09:19 +0100_0xa(~user@user/0xa/x-3134607) (Server closed connection)
2023-11-12 17:09:23 +0100 <Inst> that is really cute
2023-11-12 17:09:30 +0100_0xa(~user@95.179.128.10)
2023-11-12 17:09:30 +0100_0xa(~user@95.179.128.10) (Changing host)
2023-11-12 17:09:30 +0100_0xa(~user@user/0xa/x-3134607)
2023-11-12 17:09:38 +0100 <Inst> >=> is infixr like =<<, while <=< is infixl like >>=
2023-11-12 17:10:38 +0100mokee(~mokee@37.228.215.150)
2023-11-12 17:11:35 +0100 <Inst> and they can't be used together, even though the fixities match
2023-11-12 17:12:40 +0100 <EvanR> :t m >>= f >=> g
2023-11-12 17:12:41 +0100 <lambdabot> error:
2023-11-12 17:12:41 +0100 <lambdabot> Precedence parsing error
2023-11-12 17:12:41 +0100 <lambdabot> cannot mix ‘>>=’ [infixl 1] and ‘>=>’ [infixr 1] in the same infix expression
2023-11-12 17:12:43 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-12 17:12:49 +0100 <EvanR> :t m >>= f <=< g
2023-11-12 17:12:50 +0100 <lambdabot> error:
2023-11-12 17:12:50 +0100 <lambdabot> Precedence parsing error
2023-11-12 17:12:50 +0100 <lambdabot> cannot mix ‘>>=’ [infixl 1] and ‘<=<’ [infixr 1] in the same infix expression
2023-11-12 17:13:08 +0100 <EvanR> what you talking about
2023-11-12 17:13:12 +0100 <Inst> wait what?
2023-11-12 17:14:08 +0100 <Inst> huh so both (>=>) and (<=<) are infixr
2023-11-12 17:14:19 +0100 <int-e> ...no?
2023-11-12 17:14:27 +0100 <int-e> oh
2023-11-12 17:14:29 +0100 <Inst> :i (>=>)
2023-11-12 17:14:32 +0100 <Inst> :i (<=<)
2023-11-12 17:14:39 +0100 <int-e> sorry, I misread
2023-11-12 17:14:50 +0100 <int-e> I thought one of those was >>=
2023-11-12 17:15:31 +0100 <Inst> so you can mix both kinds of kleisli arrows together, weird
2023-11-12 17:16:47 +0100 <EvanR> good
2023-11-12 17:17:00 +0100 <EvanR> same for composition and reverse composition
2023-11-12 17:17:29 +0100 <Inst> what is reverse composition?
2023-11-12 17:17:32 +0100 <Inst> do you mean >>>?
2023-11-12 17:17:34 +0100 <int-e> You can't mix either of them with >>= and that's probably for the better.
2023-11-12 17:17:39 +0100 <EvanR> >>> and <<< sure
2023-11-12 17:18:19 +0100 <EvanR> :t flip (.)
2023-11-12 17:18:20 +0100 <lambdabot> (a -> b) -> (b -> c) -> a -> c
2023-11-12 17:24:46 +0100tango88(~tango88@194.127.199.82)
2023-11-12 17:25:04 +0100 <hc> Another question, just for fun I'm implementing the C ternary operator ? in haskell by doing: (!) a b = (a, b) and (?) a (b, c) = if a then b else c
2023-11-12 17:25:18 +0100 <hc> Is there anyway to hide the original : operator so I can use it instead?
2023-11-12 17:25:55 +0100 <ncf> have you considered learning agda instead
2023-11-12 17:26:03 +0100 <hc> haha :)
2023-11-12 17:26:06 +0100 <ncf> hm i guess you still couldn't use :
2023-11-12 17:26:55 +0100 <duncan> aw yea R now has pipes like |> natively, they're great
2023-11-12 17:27:22 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-12 17:27:40 +0100 <EvanR> :t f >>> g <<< h -- o_O
2023-11-12 17:27:41 +0100 <lambdabot> forall k (cat :: k -> k -> *) (a :: k) (b1 :: k) (b2 :: k) (c :: k). (Category cat, FromExpr (cat a b1), FromExpr (cat b2 c), FromExpr (cat b1 b2)) => cat a c
2023-11-12 17:27:49 +0100 <EvanR> :t f <<< g >>> h --- o_O
2023-11-12 17:27:50 +0100 <lambdabot> forall k (cat :: k -> k -> *) (b1 :: k) (c :: k) (a :: k) (b2 :: k). (Category cat, FromExpr (cat b1 c), FromExpr (cat a b2), FromExpr (cat b2 b1)) => cat a c
2023-11-12 17:27:58 +0100 <EvanR> looks like you can mix them after all
2023-11-12 17:28:08 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-11-12 17:28:28 +0100 <ncf> gross
2023-11-12 17:28:50 +0100 <EvanR> infixr...
2023-11-12 17:29:16 +0100 <hc> So I guess (:) is more hardcoded into haskell than (+), (*), etc.?
2023-11-12 17:29:26 +0100 <EvanR> yes
2023-11-12 17:29:30 +0100 <hc> Fascinating
2023-11-12 17:30:18 +0100 <Inst> I guess it's considered the same as [] syntax?
2023-11-12 17:30:46 +0100 <tomsmeding> hc: a clever alternative syntax is given at https://wiki.haskell.org/If-then-else#Use_cases
2023-11-12 17:31:15 +0100 <tomsmeding> (? $ instead of ? :)
2023-11-12 17:31:25 +0100mastarija(~mastarija@42-42.dsl.iskon.hr)
2023-11-12 17:31:36 +0100 <tomsmeding> Inst: yeah, (:) is built-in syntax just like []
2023-11-12 17:32:12 +0100 <tomsmeding> https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-340003.7
2023-11-12 17:32:25 +0100Ram-Z(Ram-Z@2a01:7e01::f03c:91ff:fe57:d2df) (Server closed connection)
2023-11-12 17:32:50 +0100Ram-Z(Ram-Z@2a01:7e01::f03c:91ff:fe57:d2df)
2023-11-12 17:33:39 +0100 <hc> Oh I see. Thanks to the currying an operator doesn't necessarily have to take two arguments
2023-11-12 17:33:45 +0100 <hc> But then the syntax is a bit less C-like ;-)
2023-11-12 17:34:02 +0100 <hc> Hmm, unless you use $, true :)
2023-11-12 17:35:08 +0100 <tomsmeding> yeah it's a hack
2023-11-12 17:35:29 +0100 <hc> A very nice one
2023-11-12 17:37:02 +0100 <EvanR> > True & 'a' `bool` 'b' -- xD
2023-11-12 17:37:03 +0100 <lambdabot> 'b'
2023-11-12 17:37:08 +0100 <EvanR> > False & 'a' `bool` 'b' -- xD
2023-11-12 17:37:10 +0100 <lambdabot> 'a'
2023-11-12 17:38:03 +0100Square(~Square@user/square) (Remote host closed the connection)
2023-11-12 17:38:16 +0100 <hc> Oh, that one is also nice :)
2023-11-12 17:39:46 +0100 <EvanR> > 3 & (+1) & sqrt & floor
2023-11-12 17:39:47 +0100 <lambdabot> 2
2023-11-12 17:41:06 +0100 <Inst> Also
2023-11-12 17:41:33 +0100 <Inst> 🍅
2023-11-12 17:41:43 +0100 <Inst> This should be a tomato, right? I don't have the right font configured for it :(
2023-11-12 17:41:59 +0100 <geekosaur> looks like a tomato here
2023-11-12 17:42:00 +0100 <Inst> (🍅) = putStrLn "this is a tomato"
2023-11-12 17:42:22 +0100 <EvanR> https://i.imgur.com/fNJKjsV.png
2023-11-12 17:44:28 +0100 <Inst> I guess it's more fit for Acme, but I'm still surprised no one tried to stuff emojis into a library yet.
2023-11-12 17:44:30 +0100tango88(~tango88@194.127.199.82) (Quit: Client closed)
2023-11-12 17:44:48 +0100Square(~Square@user/square)
2023-11-12 17:44:52 +0100 <Inst> > (🏆) = putStrLn "This is a tomato"
2023-11-12 17:44:53 +0100 <lambdabot> <hint>:1:5: error: parse error on input ‘=’
2023-11-12 17:44:59 +0100 <hc> EvanR: Which package is the & operator from?
2023-11-12 17:45:11 +0100 <EvanR> @index (&)
2023-11-12 17:45:11 +0100 <lambdabot> Data.Function
2023-11-12 17:45:33 +0100 <hc> Ah, thanks.
2023-11-12 17:46:47 +0100 <Inst> that said: https://hackage.haskell.org/package/hmatrix-0.20.2/docs/Numeric-LinearAlgebra-Static.html#t:-8477-
2023-11-12 17:47:38 +0100 <EvanR> > let (🍅) = (+) in 7 🍅 7
2023-11-12 17:47:39 +0100 <lambdabot> 14
2023-11-12 17:49:02 +0100 <c_wraith> hc: for what it's worth, a lot of people miss the index pages on hackage. They're really very useful: https://hackage.haskell.org/package/base-4.19.0.0/docs/doc-index.html
2023-11-12 17:49:38 +0100 <c_wraith> (I think it took me a year to notice them)
2023-11-12 17:49:42 +0100 <tomsmeding> also useful: if you're on a reference page of a package, you can press 's' on the keyboard to get a search box
2023-11-12 17:49:55 +0100 <hc> c_wraith: Thanks! In this case my mistake was to write load instead of import and was confused why Data.Function wouldn't load, so I asked here
2023-11-12 17:50:00 +0100 <tomsmeding> for 'base' it doesn't work on the package contents page, but for most packages it does
2023-11-12 17:50:04 +0100 <c_wraith> ... depending on when the docs were last generated.
2023-11-12 17:50:12 +0100 <tomsmeding> also that
2023-11-12 17:50:21 +0100 <c_wraith> Hackage doesn't rebuild docs when haddock is updated
2023-11-12 17:52:15 +0100 <c_wraith> (it can't, really. A lot of docs don't build on hackage. They depend on an OS or native library or something that isn't installed there.)
2023-11-12 17:52:51 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-12 17:53:14 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-11-12 17:53:57 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 17:53:58 +0100berberman(~berberman@user/berberman) (Server closed connection)
2023-11-12 17:54:12 +0100berberman(~berberman@user/berberman)
2023-11-12 17:55:49 +0100 <probie> Inst: have some Haskell with emojis https://paste.tomsmeding.com/EEEb2tNj
2023-11-12 17:56:28 +0100 <EvanR> emoji haskell twitter account was suspended :(
2023-11-12 17:57:20 +0100 <Rembane> :(
2023-11-12 17:57:39 +0100 <Inst> wait, that was a thing? ?:(
2023-11-12 17:58:34 +0100 <EvanR> elon not a haskell fan
2023-11-12 17:58:41 +0100 <Inst> thanks <Probie3
2023-11-12 18:01:13 +0100 <Inst> https://hackage.haskell.org/package/emojis-0.1.3
2023-11-12 18:01:58 +0100mastarija(~mastarija@42-42.dsl.iskon.hr) (Quit: Client closed)
2023-11-12 18:02:03 +0100 <Inst> I wonder if anyone has ever taught a Haskell uni course where the problem sets are in emojis, at least before drop / withdrawal dates kick in
2023-11-12 18:02:40 +0100 <c_wraith> seems like unnecessary torture
2023-11-12 18:03:29 +0100 <EvanR> to take this course you need a 90s japanese phone
2023-11-12 18:03:50 +0100 <c_wraith> heck, I think libraries that use α in their types are unnecessary torture
2023-11-12 18:04:13 +0100tango88(~tango88@194.127.199.82)
2023-11-12 18:04:37 +0100 <Inst> also on my Arch machine, I can't render 70% of the emojis shown :(
2023-11-12 18:04:59 +0100 <geekosaur> that's just a fntconfig thing, install more fonts
2023-11-12 18:05:35 +0100 <Rembane> Especially those with the emoji extensions
2023-11-12 18:05:58 +0100 <duncan> I think there's more to it than just installing a font, given emoji can be multiple width characters
2023-11-12 18:06:31 +0100mokee(~mokee@37.228.215.150) (Ping timeout: 246 seconds)
2023-11-12 18:06:35 +0100 <EvanR> if chinese is working in your terminal, that shouldn't be an issue
2023-11-12 18:07:09 +0100 <geekosaur> not the same issue, some emoji are ligatures I think
2023-11-12 18:07:15 +0100 <duncan> IIRC it is more complex than that because many emoji are compound characters
2023-11-12 18:07:46 +0100 <EvanR> if hindi is working in your terminal shouldn't be an issue ? xD
2023-11-12 18:09:16 +0100 <duncan> There's definitely something 'weird' about emoji
2023-11-12 18:10:25 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-11-12 18:11:56 +0100tango88(~tango88@194.127.199.82) (Quit: Client closed)
2023-11-12 18:12:12 +0100 <EvanR> > text ['🇺','🇸']
2023-11-12 18:12:13 +0100 <lambdabot> 🇺🇸
2023-11-12 18:13:49 +0100 <tomsmeding> Inst: I run arch and emojis render fine
2023-11-12 18:13:55 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-11-12 18:14:04 +0100 <tomsmeding> in st, no less, so if it works there you have no excuse :p
2023-11-12 18:14:26 +0100 <tomsmeding> right, yeah the ligatures fail in the terminal
2023-11-12 18:14:39 +0100 <tomsmeding> but that's a terminal issue, not an arch issue :)
2023-11-12 18:14:54 +0100 <EvanR> > text ['ष','त']
2023-11-12 18:14:55 +0100 <lambdabot> षत
2023-11-12 18:15:09 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (Quit: WeeChat 4.1.1)
2023-11-12 18:15:41 +0100 <EvanR> fail
2023-11-12 18:16:45 +0100 <ski> (thankfully they fail to render here)
2023-11-12 18:20:54 +0100 <EvanR> > text (intersperse ' ' "च्ट")
2023-11-12 18:20:56 +0100 <lambdabot> च ् ट
2023-11-12 18:20:58 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 18:21:28 +0100 <EvanR> is there a haskell package similar to libgrapheme which can split on the first grapheme cluster
2023-11-12 18:25:35 +0100mokee(~mokee@37.228.215.150)
2023-11-12 18:26:18 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a) (Remote host closed the connection)
2023-11-12 18:26:34 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a)
2023-11-12 18:29:23 +0100Nixkernal(~Nixkernal@115.16.194.178.dynamic.wline.res.cust.swisscom.ch)
2023-11-12 18:29:48 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-12 18:30:44 +0100mc47(~mc47@xmonad/TheMC47)
2023-11-12 18:30:45 +0100themc47(~mc47@xmonad/TheMC47)
2023-11-12 18:31:03 +0100themc47(~mc47@xmonad/TheMC47) (Client Quit)
2023-11-12 18:31:07 +0100mc47(~mc47@xmonad/TheMC47) (Client Quit)
2023-11-12 18:31:24 +0100mc47(~mc47@xmonad/TheMC47)
2023-11-12 18:34:36 +0100CO2(CO2@gateway/vpn/protonvpn/co2) (Client Quit)
2023-11-12 18:39:43 +0100jpds1(~jpds@gateway/tor-sasl/jpds)
2023-11-12 18:40:13 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-11-12 18:43:46 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-11-12 18:44:03 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-12 18:44:59 +0100 <Inst> tomsmeding: what's the standard Arch font, then, the one I need to install? I just grabbed KDE
2023-11-12 18:45:04 +0100 <Inst> or maybe I should go install a KDE font pack?
2023-11-12 18:45:29 +0100CO2(CO2@gateway/vpn/protonvpn/co2)
2023-11-12 18:46:39 +0100 <yushyin> noto-fonts-emoji maybe
2023-11-12 18:49:18 +0100 <geekosaur> fwiw on ubuntu it's fonts-noto-color-emoji - color emoji font from Google
2023-11-12 18:49:26 +0100 <geekosaur> quoting `apt-cache search`
2023-11-12 18:50:17 +0100 <geekosaur> sadly there's about zero consistency in package names across linux distributions
2023-11-12 18:50:38 +0100mastarija(~mastarija@42-42.dsl.iskon.hr)
2023-11-12 18:50:52 +0100 <geekosaur> (which is why neither cabal nor stack try to install distro packages when needed)
2023-11-12 18:51:00 +0100 <Inst> thanks <3
2023-11-12 18:56:17 +0100danza(~francesco@151.57.226.145) (Read error: Connection reset by peer)
2023-11-12 19:00:46 +0100hovsater(sid499516@id-499516.lymington.irccloud.com) (Server closed connection)
2023-11-12 19:00:56 +0100hovsater(sid499516@id-499516.lymington.irccloud.com)
2023-11-12 19:12:27 +0100danza(~francesco@151.43.231.114)
2023-11-12 19:14:49 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-12 19:16:16 +0100degraafk(sid71464@id-71464.lymington.irccloud.com) (Server closed connection)
2023-11-12 19:16:29 +0100degraafk(sid71464@id-71464.lymington.irccloud.com)
2023-11-12 19:20:01 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 19:23:33 +0100ubert(~Thunderbi@178.165.170.224.wireless.dyn.drei.com)
2023-11-12 19:24:51 +0100Inst(~Inst@120.244.192.250) (Remote host closed the connection)
2023-11-12 19:31:17 +0100Pickchea(~private@user/pickchea)
2023-11-12 19:32:55 +0100Inst(~Inst@120.244.192.250)
2023-11-12 19:33:13 +0100 <Inst> hmmm, this is nice, isntalled your recommended fonts and now I can see emojis
2023-11-12 19:33:47 +0100 <Inst> and probie's program is perfectly readable now... for some definition of readable ;)
2023-11-12 19:34:33 +0100mastarija(~mastarija@42-42.dsl.iskon.hr) (Quit: Client closed)
2023-11-12 19:35:37 +0100 <Inst> where did that come from?
2023-11-12 19:38:16 +0100steew(~steew@user/steew) (Quit: WeeChat 4.0.4)
2023-11-12 19:40:07 +0100riatre(~quassel@2001:310:6000:f::5198:1) (Server closed connection)
2023-11-12 19:40:14 +0100riatre(~quassel@2001:310:6000:f::5198:1)
2023-11-12 19:40:39 +0100apache2(apache2@anubis.0x90.dk)
2023-11-12 19:40:47 +0100apache2(apache2@anubis.0x90.dk) (Client Quit)
2023-11-12 19:41:17 +0100apache2(apache2@anubis.0x90.dk)
2023-11-12 19:46:47 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2023-11-12 19:47:37 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 19:48:52 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 19:49:35 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 260 seconds)
2023-11-12 19:49:54 +0100 <hc> By the way, not sure if this is the right place to ask, so if not please point me accordingly. I was wondering what's the situation regarding transitive dependencies in haskell these days? Rust has solved this nicely by allowing multiple versions of the same package to be linked to an executable, any chance we can get this in haskell as well?
2023-11-12 19:51:00 +0100 <monochrom> No. Rust has it easy. (Generally any compiler that does not need to to do cross-package inlining.)
2023-11-12 19:51:11 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2023-11-12 19:51:14 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-12 19:51:18 +0100 <hc> I think rust can do that
2023-11-12 19:51:52 +0100 <hc> It is called lto
2023-11-12 19:53:35 +0100Square(~Square@user/square) (Remote host closed the connection)
2023-11-12 19:54:37 +0100 <yin> @pl uncurry f . join bimap g . (h &&& i)
2023-11-12 19:54:37 +0100 <lambdabot> uncurry f . bimap g g . (h &&& i)
2023-11-12 19:55:13 +0100 <yin> @pl uncurry f . (h &&& id)
2023-11-12 19:55:13 +0100 <lambdabot> uncurry f . (h &&& id)
2023-11-12 19:55:16 +0100 <hc> Also, how would creoss-package inlining influence any of this? If you link two versions of a package, mind you only for transitive dependencies, those two versions could be given unique names internally for the duration of the compilation
2023-11-12 19:55:23 +0100 <hc> They wouldn't have to interact with one another either
2023-11-12 19:55:25 +0100 <yin> @pl f <*> h
2023-11-12 19:55:25 +0100 <lambdabot> f <*> h
2023-11-12 19:55:33 +0100 <hc> Just to avoid version conflicts between two transitive dependencies
2023-11-12 19:56:16 +0100 <hc> ...of two different direct dependencies
2023-11-12 19:57:20 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-12 19:57:34 +0100 <monochrom> You know, if we separate GHC and cabal, GHC doesn't mind, it's cabal that does.
2023-11-12 19:58:05 +0100 <hc> I don't know; I haven't been using haskell for a few years and I have never been that deep into its internals :)
2023-11-12 19:58:31 +0100 <hc> Hence my asking... I do think it could help to solve the dependency hell problem quite a bit
2023-11-12 19:58:37 +0100 <geekosaur> ghc cares when it discovers the conflict and reports it as a symbol clonflicting with (apparently) itself
2023-11-12 19:58:43 +0100FinnBoat(~user@2001:861:5863:3d50:839b:2ec1:8b15:a80b)
2023-11-12 19:58:56 +0100 <monochrom> You already know Rust, so it's just GHC : cabal :: rustc :: cargo
2023-11-12 19:58:59 +0100 <hc> I get it that it currently doesn't work... but I wonder if there is a technical reason behind
2023-11-12 19:59:23 +0100 <geekosaur> oh, it works fine as long as the two never intersect
2023-11-12 19:59:27 +0100 <FinnBoat> in ghci, with :! shell-command, how to make use of the user's .bashrc ?
2023-11-12 19:59:32 +0100 <hc> Yes indeed, which they won't have to
2023-11-12 20:00:15 +0100sdz(~sdz@user/sdz) (Ping timeout: 240 seconds)
2023-11-12 20:00:17 +0100 <geekosaur> you hope
2023-11-12 20:00:23 +0100 <hc> No I'm sure of that
2023-11-12 20:00:41 +0100 <geekosaur> I'm absolutely certain you are wrong because I hve seen it happen multiple times
2023-11-12 20:00:43 +0100 <hc> Because I don't want to include two versions of the same package myself, just be able to include a package that includes an old version of another package
2023-11-12 20:00:48 +0100sdz(~sdz@user/sdz)
2023-11-12 20:00:55 +0100 <hc> geekosaur: It does work fine in rust, seen it happen there many time
2023-11-12 20:00:56 +0100 <hc> s*
2023-11-12 20:01:32 +0100 <hc> Say: a refers to c0.1.0, b refers to c0.2.0, so I cannot use packages a and b in my own project currently
2023-11-12 20:01:40 +0100 <monochrom> "I agree with myself all the time. It adds harmony to my monologues." >:)
2023-11-12 20:02:00 +0100 <hc> If c0.1.0 and c0.2.0 could both be linked in at the same time, then using packages a and b together would be no problem
2023-11-12 20:02:12 +0100 <hc> Since a only knows of c0.1.0 and b only knows of c0.2.0, there'd be no problem
2023-11-12 20:02:26 +0100 <hc> Since my own package doesn't even include any version of c, no problem there either
2023-11-12 20:02:27 +0100 <geekosaur> until typeclasses, which are global, come into play
2023-11-12 20:02:39 +0100 <hc> Okay, hence my asking if there is any technical reason
2023-11-12 20:03:44 +0100 <hc> Well, couldn't something be done about this? Because I think this would be a really good improvement in terms of long term stability for projects
2023-11-12 20:04:38 +0100 <hc> Why can't typeclasses be imported like everything else?
2023-11-12 20:07:01 +0100 <monochrom> In principle, it is mechanical to detect incoherence. In principle, when there is no incoherence, it is mechanical to allow multiple versions.
2023-11-12 20:07:09 +0100 <monochrom> In practice, "patches welcome".
2023-11-12 20:09:14 +0100 <FinnBoat> in ghci, :! can't call alias
2023-11-12 20:09:20 +0100 <FinnBoat> any idea?
2023-11-12 20:09:29 +0100 <FinnBoat> bash alias
2023-11-12 20:09:54 +0100 <hc> monochrom: Would patches be welcome? Because I'm getting the feeling you're making fun of me for asking that question... maybe I am missing an important point or this is really a no-issue?
2023-11-12 20:10:02 +0100 <monochrom> Does :! call bash in the first place?
2023-11-12 20:10:11 +0100 <FinnBoat> yes it does
2023-11-12 20:10:33 +0100 <FinnBoat> :! export BASH_ENV=/home/me/.bashrc ; alias
2023-11-12 20:10:36 +0100 <FinnBoat> gives nothing
2023-11-12 20:11:25 +0100 <FinnBoat> :! date && date , with this i do get the right result
2023-11-12 20:11:53 +0100 <FinnBoat> i've defined a bash function to list exposed modules from a package
2023-11-12 20:12:03 +0100 <FinnBoat> using a user package-db
2023-11-12 20:12:55 +0100qqq(~qqq@92.43.167.61) (Ping timeout: 260 seconds)
2023-11-12 20:13:19 +0100 <FinnBoat> :! alias actually gives nothing
2023-11-12 20:13:55 +0100 <monochrom> Perhaps it runs bash as non-interactive and so .bashrc is not loaded.
2023-11-12 20:14:33 +0100 <FinnBoat> ah could be
2023-11-12 20:15:16 +0100 <monochrom> or the beginning of .bashrc detects "non-interactive, quit".
2023-11-12 20:15:47 +0100 <monochrom> Mine has "[ -z "$PS1" ] && return", for example.
2023-11-12 20:16:52 +0100 <int-e> % :! cat < /proc/self/cmdline
2023-11-12 20:17:22 +0100YuutaW(~YuutaW@mail.yuuta.moe) (Ping timeout: 258 seconds)
2023-11-12 20:17:38 +0100 <FinnBoat> int-e: what do you mean?
2023-11-12 20:18:15 +0100 <monochrom> It is also sh rather than bash.
2023-11-12 20:18:16 +0100EvanR(~EvanR@user/evanr) (Server closed connection)
2023-11-12 20:18:19 +0100 <int-e> (For me that prints /bin/sh-ccat < /proc/self/cmdline; echo which a) isn't bash for me, and b) isn't interactive.
2023-11-12 20:18:23 +0100 <monochrom> Although, on Mac, sh is bash.
2023-11-12 20:18:41 +0100EvanR(~EvanR@user/evanr)
2023-11-12 20:18:42 +0100monochromis super-annoyed at that actually.
2023-11-12 20:19:18 +0100 <int-e> Are we Mac-bashing?
2023-11-12 20:19:23 +0100 <monochrom> haha
2023-11-12 20:20:09 +0100 <FinnBoat> good one. so people don't :! their alias ?
2023-11-12 20:20:24 +0100 <monochrom> My case is niche. Real people need not worry about it.
2023-11-12 20:20:53 +0100 <int-e> I hardly ever use :! at all.
2023-11-12 20:21:12 +0100 <monochrom> But I want students to learn | and use it in shell-scripting assignments, not google for solutions and use bash's <(cmd).
2023-11-12 20:21:18 +0100 <geekosaur> actually on recent Macs sh is zsh
2023-11-12 20:21:20 +0100 <FinnBoat> how do you check what modules are exposed from a package?
2023-11-12 20:21:22 +0100yandere(sid467876@id-467876.ilkley.irccloud.com) (Server closed connection)
2023-11-12 20:21:31 +0100yandere(sid467876@id-467876.ilkley.irccloud.com)
2023-11-12 20:21:40 +0100 <monochrom> So I tell them "my automarking runs your shell script with /bin/sh your-script"
2023-11-12 20:22:34 +0100 <monochrom> But then Mac students go on to google for solutions and use <(cmd), and /bin/sh your-script works for them. They also go on to never test it on real Linux.
2023-11-12 20:22:39 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-11-12 20:23:15 +0100 <haskellbridge> 06<s​m> FinnBoat you can check the list in the cabal
2023-11-12 20:23:16 +0100 <haskellbridge> 06<s​m> file I guess
2023-11-12 20:23:25 +0100 <int-e> FinnBoat: uh, it doesn't really come up on the spot... I browse haddocks for that.
2023-11-12 20:24:33 +0100 <int-e> there is `ghc-pkg describe` and I can see how if you're using `cabal repl` you might want to invoke that with :!. I just don't.
2023-11-12 20:25:04 +0100 <monochrom> ghc-pkg field <pkg> exposed-modules
2023-11-12 20:25:34 +0100 <int-e> that works but it's not something I'd remember :-P
2023-11-12 20:25:43 +0100 <FinnBoat> ghc-pkg --package-db=path-to-my-db field vector exposed-modules
2023-11-12 20:25:45 +0100 <monochrom> But yeah a mere list of modules is utterly useless.
2023-11-12 20:25:53 +0100 <monochrom> doc is actually useful.
2023-11-12 20:26:05 +0100steew(~steew@user/steew)
2023-11-12 20:26:17 +0100 <FinnBoat> i cabal install --env .
2023-11-12 20:27:11 +0100 <geekosaur> ghc-pkg won't list stuff in environment files
2023-11-12 20:27:48 +0100 <monochrom> Dijkstra is right about people are so irrationally fixated on names.
2023-11-12 20:27:59 +0100 <monochrom> Names are bloody useless.
2023-11-12 20:28:24 +0100 <int-e> you're so right, person on the internet relay chat
2023-11-12 20:28:42 +0100 <monochrom> So what if I know Prelude is called Prelude? I still don't know what functions I can use from that name.
2023-11-12 20:29:30 +0100 <int-e> (Names *are* useful. But they don't do much to explain anything by themselves.)
2023-11-12 20:29:33 +0100steew(~steew@user/steew) (Remote host closed the connection)
2023-11-12 20:29:36 +0100 <Franciman> probably dijkstra's point is more understandable in the context of the philosophy of language of Dummett
2023-11-12 20:30:42 +0100steew(~steew@204.red-81-33-65.dynamicip.rima-tde.net)
2023-11-12 20:30:55 +0100steew(~steew@204.red-81-33-65.dynamicip.rima-tde.net) (Changing host)
2023-11-12 20:30:55 +0100steew(~steew@user/steew)
2023-11-12 20:32:34 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a) (Remote host closed the connection)
2023-11-12 20:34:07 +0100 <monochrom> int-e: That ties to, actually, imperative vs functional, even pointful vs pointfree.
2023-11-12 20:34:55 +0100 <int-e> monochrom: Thanks now I'm finding humor in "Dijkstra's point".
2023-11-12 20:34:56 +0100 <monochrom> So "monochrom" is useful insomuch as tying it to, for example, what I wrote on IRC.
2023-11-12 20:35:04 +0100 <monochrom> hahaha
2023-11-12 20:35:36 +0100 <monochrom> But then that's another way to say that it is the tie that's useful. This is one order up.
2023-11-12 20:36:28 +0100 <int-e> . o O ( "Fred would agree." - "Who's Fred?" - "Exactly." )
2023-11-12 20:36:34 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-12 20:36:52 +0100robertm(robertm@lattice.rojoma.com) (Server closed connection)
2023-11-12 20:37:03 +0100 <monochrom> Likewise, whereas the usual narrative of imperative programming is fixated on state 1, state 2, state 3, ... It is the state transition function, written like "x := x+1", that is important.
2023-11-12 20:37:10 +0100robertm(robertm@lattice.rojoma.com)
2023-11-12 20:37:17 +0100FinnBoat(~user@2001:861:5863:3d50:839b:2ec1:8b15:a80b) (Ping timeout: 252 seconds)
2023-11-12 20:38:50 +0100johnw(~johnw@69.62.242.138) (Quit: ZNC - http://znc.in)
2023-11-12 20:42:14 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:7011:9d1b:12e0:79a)
2023-11-12 20:44:09 +0100 <haskellbridge> 14<m​auke> Have you tried using shell functions instead of aliases?
2023-11-12 20:45:01 +0100 <monochrom> But if the shell functions are only defined in the files not loaded, it is not going to be any different.
2023-11-12 20:45:32 +0100 <haskellbridge> 14<m​auke> Also, I wish macs used bash, but Apple is allergic to GPL 3
2023-11-12 20:45:44 +0100 <monochrom> or rather files that are loaded but right away they say "PS1 not defined, skip".
2023-11-12 20:46:31 +0100 <haskellbridge> 14<m​auke> Difference is that aliases are not expanded at all in non-interactive shells IIRC
2023-11-12 20:47:20 +0100 <monochrom> Hrm, you're right.
2023-11-12 20:48:28 +0100 <monochrom> No, I am not so sure anymore, there is an alternative hypothesis.
2023-11-12 20:48:37 +0100 <geekosaur> unless defined in .bash_aliases iirc?
2023-11-12 20:48:45 +0100 <int-e> . o O ( shopt -s expand_aliases )
2023-11-12 20:49:11 +0100 <monochrom> This is madness.
2023-11-12 20:49:22 +0100 <int-e> welcome to s-hell.
2023-11-12 20:49:27 +0100 <monochrom> haha
2023-11-12 20:49:30 +0100 <monochrom> :(
2023-11-12 20:50:06 +0100 <int-e> I can't help feeling that we're quickly headed towards Z in an XY problem.
2023-11-12 20:50:51 +0100 <int-e> Which is fine, I'm all for sightseeing.
2023-11-12 20:51:55 +0100danza(~francesco@151.43.231.114) (Ping timeout: 255 seconds)
2023-11-12 20:52:29 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-12 20:53:26 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-12 20:55:28 +0100Boarders___(sid425905@id-425905.lymington.irccloud.com) (Server closed connection)
2023-11-12 20:55:47 +0100Boarders___(sid425905@id-425905.lymington.irccloud.com)
2023-11-12 20:56:06 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-12 20:57:11 +0100euleritian(~euleritia@dynamic-046-114-207-173.46.114.pool.telefonica.de)
2023-11-12 20:57:14 +0100 <tomsmeding> did this all start because of wanting to run a bash alias in a binding in ghci?
2023-11-12 20:57:20 +0100 <tomsmeding> local bin folders are a thing
2023-11-12 20:57:22 +0100 <tomsmeding> that's what they are for
2023-11-12 20:57:57 +0100 <tomsmeding> put your one-line thing in ~/.local/bin/your-name, chmod +x it, and (once-only) add that directory to your PATH -- maybe even system-wide
2023-11-12 20:58:13 +0100 <tomsmeding> et voilà
2023-11-12 20:58:23 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2023-11-12 20:58:25 +0100 <int-e> what happened to ~/bin :-/
2023-11-12 20:58:31 +0100 <tomsmeding> or ~/bin
2023-11-12 20:58:39 +0100 <tomsmeding> or ~/prefix/bin as I've done for a while
2023-11-12 20:59:55 +0100 <monochrom> My hypothesis is that ~/.local/bin was invented by people who came from Windows and never learned that in Unix ~/bin has existed for decades.
2023-11-12 21:00:49 +0100 <monochrom> Millenials and NIV.
2023-11-12 21:00:54 +0100 <monochrom> err NIH.
2023-11-12 21:01:15 +0100tomsmedingwas pondering English words starting with V
2023-11-12 21:02:26 +0100 <tomsmeding> the advantage of the NIH solution, though, is that somehow or other it's worked its way into the default .bashrc of various distributions
2023-11-12 21:02:37 +0100 <tomsmeding> so NIH or not, if someone has no clue about this, it's the most convenient one to suggest
2023-11-12 21:03:15 +0100 <monochrom> Default .profile's and .bashrc's have both ~/bin and ~/.local/bin
2023-11-12 21:03:16 +0100ski's used `~/bin',`~/etc',`~/lib',`~/share'
2023-11-12 21:03:55 +0100 <monochrom> I'm afraid both are here to stay.
2023-11-12 21:04:14 +0100 <monochrom> And by the time the OS/2 people finally enter the chat too, there may be yet another one. :)
2023-11-12 21:04:26 +0100 <tomsmeding> worse crimes have been committed :p
2023-11-12 21:05:45 +0100skialso reconfigures programs, when possible, to put stuff in `.foorc' or `.foo/', rather than in `.config/foo'
2023-11-12 21:06:23 +0100tomsmeding. o O ( ln -s ~ ~/.config/foo )
2023-11-12 21:06:31 +0100 <tomsmeding> (no don't do that)
2023-11-12 21:06:34 +0100 <probie> I once had a home folder that ended up with ~/bin ~/.bin and ~/.local/bin at the same time
2023-11-12 21:06:42 +0100 <ski> no, ideally `.config' should be non-existing
2023-11-12 21:07:27 +0100euleritian(~euleritia@dynamic-046-114-207-173.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-12 21:07:44 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-12 21:08:09 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 4.1.1)
2023-11-12 21:09:22 +0100 <Rembane> Recursive links are the best.
2023-11-12 21:09:32 +0100 <Rembane> Or well, not the best, but they are fun until they wreck the system.
2023-11-12 21:09:50 +0100 <monochrom> i.e., best. >:)
2023-11-12 21:10:18 +0100 <Rembane> :D
2023-11-12 21:10:43 +0100 <yin> why do we still use file trees is beyond me
2023-11-12 21:11:26 +0100 <tomsmeding> DOS is dead, long live DOS?
2023-11-12 21:11:47 +0100Sgeo(~Sgeo@user/sgeo)
2023-11-12 21:11:58 +0100 <monochrom> No, Apple DOS was flat. :)
2023-11-12 21:12:21 +0100 <tomsmeding> maybe I borked the reference
2023-11-12 21:12:39 +0100 <monochrom> Well, there was Apple DOS, and then there was MS DOS.
2023-11-12 21:13:15 +0100tomsmedingused neither, except if you count "opening cmd on windows XP"
2023-11-12 21:13:31 +0100 <tomsmeding> I used windows 98 but I don't think I knew about cmd back then :D
2023-11-12 21:14:29 +0100 <Rembane> CMD.EXE is good, the perfect place to run ipconfig.
2023-11-12 21:15:38 +0100 <monochrom> yin: On the ladder of intellectual maturity, the lowest rung is understanding flat lists, next up is trees, next is DAG, next is general graph. (There can be more further up, e.g., hypergraphs? 2-categories?)
2023-11-12 21:16:04 +0100 <monochrom> So what you're looking at is, currently, humanity has barely achieved the 2nd rung.
2023-11-12 21:16:25 +0100 <Rembane> Are there any hypergraph filesystems?
2023-11-12 21:16:39 +0100 <monochrom> In fact, just look at how many decades web forums used flat lists until Reddit came along to present a tree.
2023-11-12 21:17:35 +0100 <Rembane> There were forum software that used trees before Reddit, but they weren't as popular which probably tells us something about humanity.
2023-11-12 21:18:13 +0100 <yin> Rembane: macOS introduced labels in 1991 which I *think* qualifies
2023-11-12 21:18:16 +0100 <monochrom> Well yeah sure I was on Usenet etc. too.
2023-11-12 21:18:36 +0100 <Rembane> yin: Nice!
2023-11-12 21:18:40 +0100 <monochrom> But Usenet etc did not represent the record-low savageness of humanity.
2023-11-12 21:19:34 +0100 <Rembane> But phpBB did? :)
2023-11-12 21:19:43 +0100YuutaW(~YuutaW@2404:f4c0:f9c3:502::100:17b7)
2023-11-12 21:19:53 +0100 <yin> they were reintroduced in 2003 along with other paradigm shifts like getting rid of the save abstraction but people criticized it so they stopped going in that direction :/
2023-11-12 21:20:42 +0100 <monochrom> No I think phpBB was the first web forum thing I came across and I was annoyed that it was flat list.
2023-11-12 21:20:48 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-11-12 21:21:08 +0100 <yin> i'm pretty sure at one point they had the long term goal of parting from the graphical folder model
2023-11-12 21:21:31 +0100 <monochrom> I even wrote "Usenet already exists, newsgroup readers already exist, why did some programmer write phpBB, except to justify their existence?"
2023-11-12 21:21:45 +0100 <yin> in
2023-11-12 21:21:50 +0100 <Rembane> And then the dark ages of phpBB started.
2023-11-12 21:22:01 +0100 <carbolymer> wdym by dark
2023-11-12 21:22:05 +0100 <carbolymer> those security holes
2023-11-12 21:22:32 +0100 <carbolymer> you could exploit almost every phpbb installation back in the days
2023-11-12 21:22:56 +0100 <yin> in https://en.wikipedia.org/wiki/The_Humane_Interface Rasking (who incidently worked at Apple) explores a few more interesting ideas that could have replaced the file/folder directory metaphor
2023-11-12 21:23:16 +0100 <monochrom> <3 Raskin
2023-11-12 21:23:47 +0100 <yin> :)
2023-11-12 21:24:07 +0100 <yin> it's an awesome introductory book for interface design
2023-11-12 21:25:01 +0100 <monochrom> One of the few people who are brave enough to tell the truth, which I paraphrase and exaggerate as: 26 buttons for 26 letters are easier to use than a 5-level menu of binary choices at each level.
2023-11-12 21:25:30 +0100 <monochrom> i.e., against the ridiculous superstition "fewer buttons are easier".
2023-11-12 21:25:44 +0100 <tomsmeding> > who incidentally worked at Apple
2023-11-12 21:25:46 +0100 <lambdabot> error:
2023-11-12 21:25:46 +0100 <lambdabot> Variable not in scope:
2023-11-12 21:25:46 +0100 <lambdabot> who
2023-11-12 21:25:48 +0100 <tomsmeding> apparently not for long
2023-11-12 21:25:52 +0100 <tomsmeding> thank you lambdabot
2023-11-12 21:25:54 +0100 <tomsmeding> @botsnack
2023-11-12 21:25:54 +0100 <lambdabot> :)
2023-11-12 21:26:08 +0100 <monochrom> He died early.
2023-11-12 21:26:32 +0100 <yin> he was fired from apple by steve jobs iirc?
2023-11-12 21:26:36 +0100 <tomsmeding> oh :/
2023-11-12 21:27:52 +0100 <monochrom> Google Japan was another instance of being brave enough to make an April 1st parody: "We have made the ultimate user-friendly UI, it's just one button! So easy! All you need is to learn Morse code..."
2023-11-12 21:28:24 +0100 <Rembane> That is hilarious
2023-11-12 21:28:38 +0100 <yin> tbf i miss the old nokia phones. i could type an sms without getting it out of my pocket
2023-11-12 21:29:17 +0100 <yin> even before that sort of predictive typing
2023-11-12 21:29:41 +0100 <yin> i believe there is a balance between 1 button and 42 buttons
2023-11-12 21:30:31 +0100 <yin> *24
2023-11-12 21:30:35 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 258 seconds)
2023-11-12 21:30:36 +0100 <yin> or 26 i guess
2023-11-12 21:31:26 +0100 <geekosaur> only court recorders use chord keyboards…
2023-11-12 21:32:00 +0100ubert1(~Thunderbi@178.115.54.161.wireless.dyn.drei.com)
2023-11-12 21:32:05 +0100 <monochrom> I am OK with a rigorous Huffman-style analysis that comes out as "these things are used 90% of the time so make them immediate, the other can hide behind a level or two". Raskin would agree with that. Take actual statistics. Not ideology.
2023-11-12 21:33:12 +0100Tlsx(~rscastilh@187.40.125.21) ()
2023-11-12 21:33:22 +0100ubert(~Thunderbi@178.165.170.224.wireless.dyn.drei.com) (Ping timeout: 246 seconds)
2023-11-12 21:33:22 +0100ubert1ubert
2023-11-12 21:34:55 +0100 <yin> as it seems raskin left Apple voluntarily over disagreements with the Macintosh team in 82. he died in 2005 age 61
2023-11-12 21:35:57 +0100 <geekosaur> tomsmeding, › (compose dot greater)
2023-11-12 21:36:11 +0100 <int-e> yin: But also "Apple acknowledged Raskin's role after he had left the company by giving him as a gift, the millionth Macintosh computer, with an engraved brass plaque on the front." So the rift was probably not *terribly* deep.
2023-11-12 21:37:17 +0100 <tomsmeding> geekosaur: my usual solution is to put a reset-color byte before the > but I forgot this time :p
2023-11-12 21:37:19 +0100mokee(~mokee@37.228.215.150) (Remote host closed the connection)
2023-11-12 21:37:50 +0100 <monochrom> ooohhh reset-color byte, sneaky
2023-11-12 21:37:54 +0100 <yin> > 5
2023-11-12 21:37:58 +0100 <tomsmeding> > like this
2023-11-12 21:38:26 +0100monochromis sacrilegous: Consider the BOM... >:)
2023-11-12 21:38:46 +0100mechap(~mechap@user/mechap)
2023-11-12 21:39:10 +0100 <geekosaur> ZWNJ
2023-11-12 21:39:54 +0100 <yin> Raskin would've used a space
2023-11-12 21:40:10 +0100 <yin> >:)
2023-11-12 21:40:27 +0100 <tomsmeding> > test
2023-11-12 21:40:31 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-11-12 21:41:56 +0100 <tomsmeding> but reset-color is easy in weechat: ctrl-C ctrl-O. For BOM/etc. I need to pull tricks :p
2023-11-12 21:42:15 +0100 <tomsmeding> er, ctrl-C o
2023-11-12 21:42:44 +0100statusbot1(~statusbot@ec2-34-198-122-184.compute-1.amazonaws.com) (Server closed connection)
2023-11-12 21:42:51 +0100 <int-e> Somehow it's cimply C-O for me. I wonder whether I did anything to enable that (irssi)
2023-11-12 21:42:59 +0100statusbot(~statusbot@ec2-34-198-122-184.compute-1.amazonaws.com)
2023-11-12 21:42:59 +0100 <tomsmeding> irssi != weechat :p
2023-11-12 21:43:06 +0100 <geekosaur> yeh, it's %O in hexchat if you enable % escapes
2023-11-12 21:43:17 +0100 <ski> int-e : same here
2023-11-12 21:43:43 +0100 <geekosaur> C-O is what it actually is when encoded, so I assume irssi just passes control chars through
2023-11-12 21:43:55 +0100 <int-e> ski: Yeah I've just looked at my keybindings and there's nothing there so I guess it's the default.
2023-11-12 21:44:45 +0100 <ski> also C,_,]
2023-11-12 21:45:06 +0100 <ski> geekosaur : certainly not all
2023-11-12 21:45:20 +0100 <ski> (but i guess, the ones which aren't explicitly rebound)
2023-11-12 21:47:11 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-12 21:47:16 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Remote host closed the connection)
2023-11-12 21:47:40 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-11-12 21:47:53 +0100Square(~Square@user/square)
2023-11-12 21:48:47 +0100samhh(7569f027cf@2604:bf00:561:2000::e4) (Server closed connection)
2023-11-12 21:48:47 +0100samhh_samhh
2023-11-12 21:48:58 +0100samhh_(7569f027cf@2604:bf00:561:2000::e4)
2023-11-12 21:51:57 +0100 <yin> > 7
2023-11-12 21:53:37 +0100 <yin>  bell
2023-11-12 21:54:50 +0100 <yin> irssi passes way more of them than my term
2023-11-12 21:56:37 +0100 <yin> i'm not sure if that makes sense
2023-11-12 21:57:42 +0100 <geekosaur> depends on what you mean by "your term"
2023-11-12 21:58:11 +0100 <geekosaur> readlin intercepts most control characters so you need to arrange for them to be output, not just type them
2023-11-12 21:58:25 +0100 <geekosaur> (try /usr/bin/printf on linux)
2023-11-12 21:58:40 +0100michalz(~michalz@185.246.207.203) (Remote host closed the connection)
2023-11-12 22:02:09 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-11-12 22:07:11 +0100modotte(~modotte@user/modotte)
2023-11-12 22:10:55 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-11-12 22:12:19 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-12 22:16:41 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-12 22:16:47 +0100modotte(~modotte@user/modotte) (Quit: Leaving)
2023-11-12 22:23:52 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 258 seconds)
2023-11-12 22:24:24 +0100euleritian(~euleritia@dynamic-046-114-207-173.46.114.pool.telefonica.de)
2023-11-12 22:26:55 +0100bradparker(sid262931@id-262931.uxbridge.irccloud.com) (Server closed connection)
2023-11-12 22:27:09 +0100bradparker(sid262931@id-262931.uxbridge.irccloud.com)
2023-11-12 22:27:43 +0100[_][itchyjunk]
2023-11-12 22:27:47 +0100johnw(~johnw@69.62.242.138)
2023-11-12 22:35:00 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2023-11-12 22:55:46 +0100zetef(~quassel@5.2.182.98)
2023-11-12 22:56:15 +0100falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 255 seconds)
2023-11-12 22:58:02 +0100slack1256(~slack1256@191.126.186.232)
2023-11-12 23:00:55 +0100 <slack1256> Does anybody know if nix/nixpkgs supports backpack instantiations ? There are some old github issues that are stalled...
2023-11-12 23:01:54 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-12 23:02:49 +0100gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2023-11-12 23:03:32 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 255 seconds)
2023-11-12 23:05:22 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-11-12 23:05:35 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 260 seconds)
2023-11-12 23:06:07 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 246 seconds)
2023-11-12 23:06:52 +0100nullie(~nullie@2a01:4f8:c2c:6177::1) (Quit: WeeChat 4.0.5)
2023-11-12 23:07:10 +0100nullie(~nullie@nuremberg.nullie.name)
2023-11-12 23:08:38 +0100gentauro(~gentauro@user/gentauro)
2023-11-12 23:13:03 +0100chomwitt(~chomwitt@2a02:587:7a12:2d00:1ac0:4dff:fedb:a3f1) (Ping timeout: 240 seconds)
2023-11-12 23:22:43 +0100ham(~ham@user/ham) (Quit: WeeChat 3.5)
2023-11-12 23:26:21 +0100Square(~Square@user/square) (Ping timeout: 240 seconds)
2023-11-12 23:27:33 +0100justThanks(~justache@user/justache) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-12 23:28:15 +0100justache(~justache@user/justache)
2023-11-12 23:37:34 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-12 23:40:04 +0100acidjnk(~acidjnk@p200300d6e72b933884d06dff6b3ba200.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-11-12 23:41:28 +0100justache(~justache@user/justache) (Remote host closed the connection)
2023-11-12 23:44:25 +0100yin(~z@user/zero) (Server closed connection)
2023-11-12 23:44:45 +0100zero(~z@user/zero)
2023-11-12 23:48:57 +0100justache(~justache@user/justache)
2023-11-12 23:55:38 +0100slack1256(~slack1256@191.126.186.232) (Read error: Connection reset by peer)
2023-11-12 23:55:43 +0100slac52794(~slack1256@2800:150:151:1a42:c06e:b7d:d50e:d5f6)