Logs on 2022-10-17 (liberachat/#haskell)

00:00:01	→	alismanickt joins (~talismani@2601:200:c100:c9e0::1b0b)
00:01:35	×	califax quits (~califax@user/califx) (Remote host closed the connection)
00:01:52	<alismanickt>	Why might GHC be hanging at link time? The code I've written is fairly conservative: the only extension I used is OverloadedStrings
00:02:52	<alismanickt>	That's with `cabal run`; if I ^C and `cabal build`, it says "Up to date"
00:03:05	<geekosaur>	"hanging at link time" usually means it's the system linker that's hanging
00:03:41	<geekosaur>	if it's ld.bfd then it'll be extremely slow and memory hungry
00:03:43	<Axman6>	We'd need quite a bit more information to begin to help though
00:03:47	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 248 seconds)
00:04:09	→	califax joins (~califax@user/califx)
00:04:46	→	eggplantade joins (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
00:05:30	<zzz>	ok so i created a cabal.project file with `packages: ./.cabal , ./vendor//*.cabal`
00:05:58	<alismanickt>	I don't see anything linker-related in ~/.cabal/logs/build.log
00:06:05	<zzz>	how do i import modules from ./vendor/ packages now?
00:06:38	<Axman6>	zzz: you need to add the packages as dependencies in the .cabal file for your package
00:06:48	<Axman6>	then they'll be visible within that package
00:07:02	<geekosaur>	you declare dependencies on the packages as usual (they'll be satisfied locally since they're declared as vendored in cabal.project) and then you can import
00:07:14	geekosaur	is slow
00:07:14	<Axman6>	(afaiui anyway, I haven't done much with cabal.project files)
00:07:29	<zzz>	Axman6: oh, so cabal looks for local packages and prefers them to remote ones?
00:07:35	<zzz>	how does this work with versions?
00:07:35	<geekosaur>	yes
00:07:58	<geekosaur>	same way it would normally, so you need to declare a dependency on the vendored package's version
00:08:20	<zzz>	ok nice!
00:08:23	<geekosaur>	I do this with vendored (from git) xmonad and xmonad-contrib
00:09:42	×	eggplantade quits (~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 264 seconds)
00:10:16	<zzz>	just to make sure, i need to add them to `build-depends:` on my .cabal file, right?
00:10:42	<geekosaur>	yes, just like any other package
00:11:56	×	_xor quits (~xor@74.215.182.83) (Quit: WeeChat 3.6)
00:12:18	<Axman6>	.cabal specifies what packages you depend on, cabal.project specifies where to get them from if they're not from hackage
00:14:38	×	alismanickt quits (~talismani@2601:200:c100:c9e0::1b0b) (Remote host closed the connection)
00:14:38	×	talismanick quits (~talismani@2601:200:c100:c9e0::1b0b) (Remote host closed the connection)
00:15:04	geekosaur	wonders if they thought we'd forgotten about them
00:16:12	→	causal joins (~user@50.35.83.177)
00:16:44	×	causal quits (~user@50.35.83.177) (Client Quit)
00:18:53	→	jero98772 joins (~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c)
00:19:32	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Remote host closed the connection)
00:19:46	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
00:19:50	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
00:20:28	<zzz>	ok i was messing up. i had an alias for ghcid that was the culprit for ignoring cabal.package
00:20:30	→	talismanick joins (~talismani@2601:200:c100:c9e0::1b0b)
00:21:11	→	causal joins (~user@2001:470:ea0f:3:329c:23ff:fe3f:1e0d)
00:23:08	<zzz>	i was doing `ghcid [options] app/Main.hs` and not just `ghcid [options]`
00:24:09	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
00:27:26	×	Topsi quits (~Topsi@dyndsl-095-033-095-014.ewe-ip-backbone.de) (Read error: Connection reset by peer)
00:28:18	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 264 seconds)
00:28:47	→	freeside joins (~mengwong@103.252.202.193)
00:31:21	<talismanick>	I passed "ld-options: -fuse-ld=gold" and "ghc-options: -optl-fuse-ld=gold" in the .cabal file, deleted dist-newstyle, and tried `cabal run`
00:31:25	<talismanick>	segfault
00:31:30	→	rockystone joins (~rocky@user/rockymarine)
00:32:46	<geekosaur>	I think that's the wrong way to do it, because it's being passed to ld itself which is too late for it to take effect
00:33:07	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 252 seconds)
00:33:09	<Axman6>	yeah -optl is for passing arguments to the linker
00:34:14	<talismanick>	so... how do I tell it to use another linker?
00:34:19	×	causal quits (~user@2001:470:ea0f:3:329c:23ff:fe3f:1e0d) (Quit: WeeChat 3.6)
00:34:23	×	zaquest quits (~notzaques@5.130.79.72) (Remote host closed the connection)
00:34:56	<geekosaur>	ghc-options: -pgml=ld.gold
00:35:08	<geekosaur>	sorry, no = in there
00:35:14	<geekosaur>	-pgml ld.gold
00:37:26	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
00:37:35	<geekosaur>	althoughm hm, that -optl should have worked (ld-options is not normally used for final link, but for generating shared objects and such)
00:37:51	→	justsomeguy joins (~justsomeg@user/justsomeguy)
00:37:56	<talismanick>	https://0x0.st/owZ-.txt
00:38:14	×	jero98772 quits (~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c) (Quit: leaving)
00:38:14	→	causal joins (~user@50.35.83.177)
00:38:33	<geekosaur>	right, it really wants cc as the link command
00:38:57	<geekosaur>	problem there being I'm not sure how to do that via command line options, I've always edited the settings file directly
00:39:16	<geekosaur>	$(ghc --print-libdir)/settings
00:39:16	<talismanick>	settings file?
00:39:57	→	rockystone joins (~rocky@user/rockymarine)
00:40:24	<talismanick>	from there: ,("ld command", "ld.lld")
00:40:41	<talismanick>	so, that should be even faster than gold, let alone ld.bfd
00:40:55	<geekosaur>	lld doesn't work as final link
00:41:33	<geekosaur>	you really want "C compiler link flags" because final link needs to include libc / C runtime stuff only cc knows how to do properly
00:41:39	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
00:41:56	<geekosaur>	on my system that's ,("C compiler link flags", "-fuse-ld=gold")
00:42:12	<talismanick>	Yeah, I search-and-replaced lld with gold
00:42:33	<talismanick>	oh, segfault now!
00:43:05	×	Tuplanolla quits (~Tuplanoll@91-159-69-34.elisa-laajakaista.fi) (Ping timeout: 250 seconds)
00:43:22	<geekosaur>	sigh
00:43:29	<EvanR>	segfaults in haskell, smh
00:43:45	<geekosaur>	lld is known not to work, but I'd have expected gold to work properly
00:44:30	<talismanick>	I did just update my system... let me see if another project still builds fine after I edit it
00:44:39	<talismanick>	nope! segfaults too
00:44:45	<geekosaur>	😞
00:44:55	×	causal quits (~user@50.35.83.177) (Read error: Connection reset by peer)
00:45:13	<geekosaur>	hope you at least saved a copy of the settings file
00:45:52	→	causal joins (~user@50.35.83.177)
00:46:02	<talismanick>	if there's an issue tracker somewhere: you can record that building with Cabal 3.8.0.0 and GHC 9.2.4 (via ghcup) fails on Void Linux as of Oct. 16, 2022
00:46:17	<talismanick>	geekosaur: oh, I'll just change gold back to lld
00:46:28	→	freeside joins (~mengwong@103.252.202.193)
00:46:41	<geekosaur>	.oO { optimist }
00:46:55	<talismanick>	I mean, it was already broken after this most recent update
00:47:03	<talismanick>	and, I've evidently been using lld (somehow)
00:47:11	<talismanick>	(that's what it was before I changed anything)
00:48:01	→	zaquest joins (~notzaques@5.130.79.72)
00:48:25	<geekosaur>	hm. I don't actually know about lld on linux being working or not. it's mostly on M1 Macs that lld has been being detected a system linker and breaking, and the fix is to switch to the proper system linker
00:48:32	<geekosaur>	(ld64 on those machines)
00:50:03	<geekosaur>	*as system
00:50:11	×	Kaipei quits (~Kaiepi@142.68.249.28) (Ping timeout: 248 seconds)
00:50:27	×	causal quits (~user@50.35.83.177) (Ping timeout: 250 seconds)
00:50:37	<talismanick>	oh, it works if I switch it to ld.bfd
00:50:44	<geekosaur>	odd
00:51:01	<geekosaur>	wonder if the hangs are lld's fault then
00:51:26	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 260 seconds)
00:52:59	→	fmgornick joins (~fmgornick@2607:ea00:107:1c07:81d6:d0ad:8522:af6e)
00:53:18	<fmgornick>	?src scanr
00:53:18	<lambdabot>	scanr _ q0 [] = [q0]
00:53:19	<lambdabot>	scanr f q0 (x:xs) = f x q : qs
00:53:19	<lambdabot>	where qs@(q:_) = scanr f q0 xs
00:53:56	×	fmgornick quits (~fmgornick@2607:ea00:107:1c07:81d6:d0ad:8522:af6e) (Client Quit)
00:56:07	×	Lord_of_Life quits (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 246 seconds)
00:56:36	×	finsternis quits (~X@23.226.237.192) (Read error: Connection reset by peer)
00:57:23	→	Lord_of_Life joins (~Lord@user/lord-of-life/x-2819915)
00:57:58	→	nate1 joins (~nate@98.45.169.16)
01:05:12	→	causal joins (~user@2001:470:ea0f:3:329c:23ff:fe3f:1e0d)
01:10:14	×	albet70 quits (~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
01:13:51	←	justsomeguy parts (~justsomeg@user/justsomeguy) (WeeChat 3.6)
01:14:05	→	justsomeguy joins (~justsomeg@user/justsomeguy)
01:16:22	→	albet70 joins (~xxx@2400:8902::f03c:92ff:fe60:98d8)
01:18:24	×	xff0x quits (~xff0x@2405:6580:b080:900:b67d:8bf9:8e64:c723) (Ping timeout: 264 seconds)
01:21:03	→	freeside joins (~mengwong@103.252.202.193)
01:25:51	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 260 seconds)
01:40:00	×	wroathe quits (~wroathe@user/wroathe) (Ping timeout: 264 seconds)
01:41:20	→	wroathe joins (~wroathe@206-55-188-8.fttp.usinternet.com)
01:41:20	×	wroathe quits (~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
01:41:20	→	wroathe joins (~wroathe@user/wroathe)
01:44:31	→	Lumia joins (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net)
01:45:45	→	freeside joins (~mengwong@103.252.202.193)
01:46:16	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
01:50:27	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 248 seconds)
01:50:38	←	L29Ah parts (~L29Ah@wikipedia/L29Ah) ()
01:52:51	×	beteigeuze quits (~Thunderbi@2001:8a0:61b5:6101:f0c:e4e3:bfdc:91df) (Ping timeout: 250 seconds)
01:53:26	×	[spookyjunk] quits (~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
01:54:53	→	ezzieyguywuf joins (~Unknown@user/ezzieyguywuf)
01:57:54	→	rockystone joins (~rocky@user/rockymarine)
01:58:05	<EvanR>	I was like how to fold over this type, then it became clear. That I may have gone insane https://paste.tomsmeding.com/Javeh97i
01:58:28	→	L29Ah joins (~L29Ah@wikipedia/L29Ah)
02:00:07	→	xff0x joins (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
02:01:38	<byorgey>	very nice
02:01:57	<Axman6>	there are libraries that can autogenerate that right?>
02:02:06	<EvanR>	what would the type of something like foldMap for this type be?
02:02:35	→	freeside joins (~mengwong@103.252.202.193)
02:03:03	<Axman6>	also feels quite Data.Data-y
02:04:32	<EvanR>	I found catamorphism package, which does this one thing
02:04:52	<EvanR>	another package for another thing, I guess xD
02:04:56	×	ddellacosta quits (~ddellacos@143.244.47.82) (Ping timeout: 260 seconds)
02:04:56	<[Leary]>	That's why you write `type E = Fix EF; data EF a = ...; cataE :: (EF a -> a) -> ...`.
02:05:11	<Axman6>	yeah
02:05:12	<EvanR>	I just deleted the Fix version
02:05:22	<Axman6>	well ReFix it :P
02:05:29	<EvanR>	over it, moving on xD
02:06:40	→	ddellacosta joins (~ddellacos@143.244.47.100)
02:07:36	<EvanR>	here is cataE in action, screaming for some sort of foldMap somehow https://paste.tomsmeding.com/ViIfOUKa
02:08:48	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 264 seconds)
02:09:25	×	califax quits (~califax@user/califx) (Ping timeout: 258 seconds)
02:10:11	×	justsomeguy quits (~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
02:10:20	→	califax joins (~califax@user/califx)
02:10:21	<Axman6>	@hoogle everywhere
02:10:21	<lambdabot>	Data.Generics.Schemes everywhere :: (forall a . Data a => a -> a) -> forall a . Data a => a -> a
02:10:21	<lambdabot>	Data.Generics.SYB everywhere :: Biplate b a => (a -> a) -> b -> b
02:10:21	<lambdabot>	Numeric.Integration.TanhSinh everywhere :: ((Double -> Double) -> Double -> Double -> r) -> (Double -> Double) -> r
02:10:51	<Axman6>	:t partsOf template
02:10:52	<lambdabot>	(Functor f, Data t, Typeable a) => LensLike f t t [a] [a]
02:12:41	<EvanR>	I knew SYB was going to come up
02:13:01	<Axman6>	> ("Hello", Left "World :: Either String Bool, (Just "some", "String")) ^.. partsOf template :: [String]
02:13:03	<lambdabot>	<hint>:1:103: error:
02:13:03	<lambdabot>	lexical error in string/character literal at end of input
02:13:14	<Axman6>	> ("Hello", Left "World" :: Either String Bool, (Just "some", "String")) ^.. partsOf template :: [String]
02:13:16	<lambdabot>	["HelloWorldsomeString"]
02:13:25	<Axman6>	> ("Hello", Left "World" :: Either String Bool, (Just "some", "String")) ^.. partsOf template :: [[String]]
02:13:27	<lambdabot>	[["Hello","World","some","String"]]
02:14:37	<talismanick>	What's the difference between [y \| (x,y)<-tupList, x==a, ...] and [y \| (a,y)<-tupList ...] ?
02:14:47	<talismanick>	because, they both compile, but the latter gives the wrong answer
02:15:04	<Axman6>	the former only returns y's where x is equal to a
02:15:20	<talismanick>	and the latter not?
02:15:22	<Axman6>	the later just names x a
02:15:33	<Axman6>	you can't pattern match on arbitrary values
02:15:34	<talismanick>	assuming a is already named outside
02:15:46	<talismanick>	because, then it shouldn't compile...
02:15:47	<Axman6>	that's not how pattern matching works, you're just shadowing a
02:15:51	<talismanick>	ah
02:16:12	<EvanR>	something like that works in elixir... and it's weird
02:16:28	<EvanR>	instead of shadowing it acts like an extra equality check
02:16:52	<talismanick>	that'd be Erlang's Prolog heritage rearing its face, I imagine
02:16:55	→	razetime joins (~quassel@117.193.4.27)
02:17:07	<talismanick>	(Prolog -> Concurrent Prolog -> Erlang -> Elixir)
02:17:37	<talismanick>	idk if Elixir has logic variables, but Erlang does (a restricted form thereof, at any rate)
02:18:34	<EvanR>	I guess rearing its face is better than facing its rear
02:19:13	<talismanick>	hey, predicates run both ways for a reason
02:19:24	→	zxx7529 joins (~Thunderbi@user/zxx7529)
02:19:36	<EvanR>	no this feature of elixir is in the pattern matching
02:19:55	<talismanick>	pattern matching is a weakened form of unification
02:20:47	<Axman6>	yeah I remember really liking being able to do foo x x = ... in erlang to require both arguments to be the same
02:21:18	<talismanick>	trying to write that has bit me multiple times in Haskell :(
02:21:24	<EvanR>	Refl : a = a
02:21:40	×	td_ quits (~td@83.135.9.59) (Ping timeout: 268 seconds)
02:21:40	<EvanR>	brainexplode
02:23:18	→	td_ joins (~td@83.135.9.13)
02:26:01	→	elbear joins (~lucian@188.24.138.239)
02:26:12	×	ddellacosta quits (~ddellacos@143.244.47.100) (Ping timeout: 264 seconds)
02:29:26	×	waleee quits (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 260 seconds)
02:30:27	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
02:35:12	<ski>	EvanR : next try folding a non-regular `data' type, or even a GADT
02:35:57	<EvanR>	non-regular?
02:35:57	<ski>	talismanick : Erlang does not have logic variables, it's just plain (immutable) variables, as in Haskell,SML,OCaml,Clean,F#,..
02:38:03	→	freeside joins (~mengwong@103.252.202.193)
02:42:41	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 250 seconds)
02:42:53	×	terrorjack quits (~terrorjac@2a01:4f8:1c1e:509a::1) (Quit: The Lounge - https://thelounge.chat)
02:43:59	<EvanR>	data NRData a b = MkNRData a (NRData b a)
02:44:15	→	terrorjack joins (~terrorjac@2a01:4f8:1c1e:509a::1)
02:44:59	<ski>	EvanR : ones requiring polymorphic recursion to recur on. ones which don't pass the same parameters recursively. like `data SwapList a b = Nil \| Cons a (SwapList b a)', `data PerfectlyBalancedTree a = Elems a \| Double (PerfectlyBalancedTree (a,a))', `data Nest a = Leaf a \| Node a (Nest [a])', `data IterList f a = Nil \| Cons a (IterList f (f a))', `data HyperFunction f a b = HF (a -> b) (HyperFunction f (f a)
02:45:05	<ski>	(f b))', `data Trist (ar :: k -> k -> ) :: k -> k -> where Nil :: Trist ar a a; Cons :: ar a b -> Trist ar b c -> Trist ar a b'
02:46:15	<ski>	(well, you could express the last one as `data Trist ar b c = (b ~ c) => Nil \| forall a. Cons (ar a b) (Trist a c)', without using `GADTs')
02:47:49	<ski>	Erlang does allow matching on an already bound(/instantiated) variable, though. it also allows binding a variable in each branch of a conditional or `case' (or `receive', for matching on messages in the inbox/mailbox of the process), and then use it afterwards
02:48:13	<ski>	(sometimes i wish for this latter in Haskell. both of these things comes from its Prolog inheritance, yes)
02:49:40	×	califax quits (~califax@user/califx) (Ping timeout: 258 seconds)
02:50:26	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
02:50:56	→	califax joins (~califax@user/califx)
02:51:21	<EvanR>	cataNRData :: (a -> r -> r) -> (b -> r -> r) -> NRData a b -> r
02:51:28	<EvanR>	cataNRData f g (MkNRData x more) = f x (cataNRData g f more)
02:53:55	×	berberman quits (~berberman@user/berberman) (Ping timeout: 248 seconds)
02:54:21	×	Axman6 quits (~Axman6@user/axman6) (Ping timeout: 252 seconds)
02:56:44	→	freeside joins (~mengwong@103.252.202.193)
02:57:53	→	rockystone joins (~rocky@user/rockymarine)
03:02:54	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 268 seconds)
03:03:51	×	AkechiShiro quits (~licht@user/akechishiro) (Ping timeout: 260 seconds)
03:04:06	×	Raito_Bezarius quits (~Raito@wireguard/tunneler/raito-bezarius) (Ping timeout: 268 seconds)
03:04:26	×	Luj3 quits (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb) (Ping timeout: 260 seconds)
03:05:36	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 260 seconds)
03:10:28	→	AkechiShiro joins (~licht@user/akechishiro)
03:12:26	→	Luj3 joins (~Luj@2a01:e0a:5f9:9681:5880:c9ff:fe9f:3dfb)
03:12:56	×	Lumia quits (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net) (Remote host closed the connection)
03:13:00	→	rockystone joins (~rocky@user/rockymarine)
03:13:20	→	Lumia joins (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net)
03:13:22	<ski>	yup, that's an easy one
03:17:15	→	Raito_Bezarius joins (~Raito@wireguard/tunneler/raito-bezarius)
03:19:08	<ski>	(`FunList' is another one. <https://twanvl.nl/blog/haskell/non-regular1>,<https://bartoszmilewski.com/2018/10/12/trading-funlists-at-a-bazaar-with-yoneda/>,<https://stackoverflow.com/questions/64935210/what-subclasses-of-profunctor-does-funlist-support>)
03:20:59	×	Raito_Bezarius quits (~Raito@wireguard/tunneler/raito-bezarius) (Max SendQ exceeded)
03:23:07	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 246 seconds)
03:23:56	×	causal quits (~user@2001:470:ea0f:3:329c:23ff:fe3f:1e0d) (Quit: WeeChat 3.6)
03:24:17	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 250 seconds)
03:28:04	→	freeside joins (~mengwong@103.252.202.193)
03:31:19	→	causal joins (~user@50.35.83.177)
03:35:35	×	machinedgod quits (~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 268 seconds)
03:37:47	→	rumraisin joins (~tardis@user/phileasfogg)
03:38:15	×	rumraisin quits (~tardis@user/phileasfogg) (Client Quit)
03:38:38	→	rockystone joins (~rocky@user/rockymarine)
03:38:54	→	Raito_Bezarius joins (~Raito@wireguard/tunneler/raito-bezarius)
03:39:49	→	nate1 joins (~nate@98.45.169.16)
03:42:36	×	Raito_Bezarius quits (~Raito@wireguard/tunneler/raito-bezarius) (Max SendQ exceeded)
03:43:31	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 248 seconds)
03:44:39	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 250 seconds)
03:44:48	×	Lumia quits (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net) (Ping timeout: 264 seconds)
03:45:27	×	zebrag quits (~chris@user/zebrag) (Quit: Konversation terminated!)
03:46:43	→	Lumia joins (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net)
03:46:55	×	adanwan quits (~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
03:47:35	→	adanwan joins (~adanwan@gateway/tor-sasl/adanwan)
03:50:37	→	rockystone joins (~rocky@user/rockymarine)
03:52:10	→	berberman joins (~berberman@user/berberman)
03:54:49	<EvanR>	still working on HyperFunction
03:55:32	×	loras quits (~loras@c-73-139-125-125.hsd1.fl.comcast.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
03:56:41	→	loras joins (~loras@c-73-139-125-125.hsd1.fl.comcast.net)
03:59:45	→	Raito_Bezarius joins (~Raito@wireguard/tunneler/raito-bezarius)
04:00:15	×	razetime quits (~quassel@117.193.4.27) (Ping timeout: 250 seconds)
04:06:15	×	spaced quits (uid572193@user/spaced) (Quit: Connection closed for inactivity)
04:07:52	→	nate1 joins (~nate@98.45.169.16)
04:08:11	→	spaced joins (uid572193@user/spaced)
04:12:35	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 268 seconds)
04:13:29	→	elbear joins (~lucian@188.24.138.239)
04:20:05	×	califax quits (~califax@user/califx) (Remote host closed the connection)
04:20:56	→	califax joins (~califax@user/califx)
04:21:23	×	wroathe quits (~wroathe@user/wroathe) (Ping timeout: 248 seconds)
04:28:14	→	nate1 joins (~nate@98.45.169.16)
04:30:14	→	vn36__ joins (~vn36@123.63.203.210)
04:35:29	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 252 seconds)
04:35:41	→	razetime joins (~quassel@117.193.4.27)
04:36:06	→	Kaladin joins (~Kaladin@157-131-169-214.fiber.dynamic.sonic.net)
04:36:58	×	zxx7529 quits (~Thunderbi@user/zxx7529) (Ping timeout: 246 seconds)
04:43:32	×	FinnElija quits (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
04:44:01	→	FinnElija joins (~finn_elij@user/finn-elija/x-0085643)
04:57:31	→	tbd joins (~user@2a00:6020:4119:a000:37c5:734f:1b84:a7c2)
04:57:36	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 260 seconds)
05:00:25	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 252 seconds)
05:01:46	×	Lumia quits (~Lumia@c-24-34-172-110.hsd1.ma.comcast.net) (Quit: ,-)
05:01:46	<tbd>	I'm trying to write bindings to a C library using FFI and hsc2hs in several forieign imports I
05:01:46	<tbd>	get the warning "expected ‘const char ’ but argument is of type ‘char ’". I typed the input argument as
05:01:46	<tbd>	CString on the Haskell side. Is there anything better?
05:03:34	→	zxx7529 joins (~Thunderbi@user/zxx7529)
05:03:39	×	zxx7529 quits (~Thunderbi@user/zxx7529) (Client Quit)
05:04:13	→	zxx7529 joins (~Thunderbi@user/zxx7529)
05:05:08	×	Kaladin quits (~Kaladin@157-131-169-214.fiber.dynamic.sonic.net) (Quit: Leaving)
05:06:37	→	Kaladin joins (~Kaladin@157-131-169-214.fiber.dynamic.sonic.net)
05:09:58	→	elbear joins (~lucian@188.24.138.239)
05:10:06	→	sagax joins (~sagax_nb@user/sagax)
05:13:03	×	sagax quits (~sagax_nb@user/sagax) (.net .split)
05:13:03	×	spaced quits (uid572193@user/spaced) (.net .split)
05:13:03	×	AkechiShiro quits (~licht@user/akechishiro) (.net .split)
05:13:03	×	pavonia quits (~user@user/siracusa) (.net .split)
05:13:03	×	lbseale quits (~quassel@user/ep1ctetus) (.net .split)
05:13:03	×	raym quits (~aritra@user/raym) (.net .split)
05:13:03	×	Vajb quits (~Vajb@2001:999:504:1841:9e47:1ec7:a52e:1d57) (.net .split)
05:13:04	×	weeezes[m] quits (~weeezesma@2001:470:69fc:105::1:da65) (.net .split)
05:13:04	×	Neosake[m] quits (~neosakema@2001:470:69fc:105::2:989e) (.net .split)
05:13:04	×	drsooch[m] quits (~drsoochma@2001:470:69fc:105::1:c8a1) (.net .split)
05:13:04	×	MangoIV[m] quits (~mangoivma@2001:470:69fc:105::2:8417) (.net .split)
05:13:04	×	elvishjerricco quits (~elvishjer@2001:470:69fc:105::6172) (.net .split)
05:13:04	×	polykernel[m] quits (~polykerne@user/polykernel) (.net .split)
05:13:04	×	JensPetersen[m] quits (~juhp@2001:470:69fc:105::6e9) (.net .split)
05:13:04	×	kadoban quits (~kadoban@user/kadoban) (.net .split)
05:13:04	×	SeanKing[m] quits (~seankingm@2001:470:69fc:105::cf9c) (.net .split)
05:13:04	×	Killy quits (~killy@2001:470:69fc:105::2:6ec1) (.net .split)
05:13:04	×	nicmollel[m] quits (~nicmollel@2001:470:69fc:105::1:feeb) (.net .split)
05:13:04	×	fgaz quits (~fgaz@2001:470:69fc:105::842) (.net .split)
05:13:04	×	ghoulpine quits (xfnw@tilde.team) (.net .split)
05:13:04	×	remexre quits (~remexre@user/remexre) (.net .split)
05:13:04	×	dibblego quits (~dibblego@haskell/developer/dibblego) (.net .split)
05:13:04	×	GoldsteinQ quits (~goldstein@goldstein.rs) (.net .split)
05:13:04	×	joeyh quits (joeyh@2600:3c03::f03c:91ff:fe73:b0d2) (.net .split)
05:13:04	×	poscat quits (~poscat@2408:8206:4823:fd6f:98ab:5c38:136c:5932) (.net .split)
05:13:04	×	xsarnik quits (xsarnik@lounge.fi.muni.cz) (.net .split)
05:13:04	×	stilgart quits (~Christoph@chezlefab.net) (.net .split)
05:13:04	×	n1essa quits (3d621153a5@2604:bf00:561:2000::df7) (.net .split)
05:13:04	×	sa quits (sid1055@id-1055.tinside.irccloud.com) (.net .split)
05:13:04	×	ralu1 quits (~ralu@static.211.245.203.116.clients.your-server.de) (.net .split)
05:13:04	×	nibelungen quits (~asturias@2001:19f0:7001:638:5400:3ff:fef3:8725) (.net .split)
05:13:04	×	sviermsung quits (E3Ya4Aww1k@user/s4msung) (.net .split)
05:13:04	×	whatsupboy quits (~whatsupbo@user/scobydoo) (.net .split)
05:13:04	×	bsima quits (~bsima@2604:a880:400:d0::19f1:7001) (.net .split)
05:13:04	×	agander_m quits (sid407952@id-407952.tinside.irccloud.com) (.net .split)
05:13:04	×	SrPx quits (sid108780@id-108780.uxbridge.irccloud.com) (.net .split)
05:13:04	×	wafflepirate quits (sid467876@id-467876.ilkley.irccloud.com) (.net .split)
05:13:04	×	dispater- quits (~dispater@mail.brprice.uk) (.net .split)
05:13:04	×	orcus quits (~orcus@user/brprice) (.net .split)
05:13:04	×	integral quits (sid296274@user/integral) (.net .split)
05:13:04	×	PotatoGim_ quits (sid99505@id-99505.lymington.irccloud.com) (.net .split)
05:13:04	×	cln quits (sid336875@id-336875.ilkley.irccloud.com) (.net .split)
05:13:04	×	ysh____ quits (sid6017@id-6017.ilkley.irccloud.com) (.net .split)
05:13:04	×	feliix42 quits (~felix@gibbs.uberspace.de) (.net .split)
05:13:04	×	sooch_ quits (sid533113@id-533113.hampstead.irccloud.com) (.net .split)
05:13:04	×	christiaanb quits (sid84827@id-84827.lymington.irccloud.com) (.net .split)
05:13:04	×	edmundnoble quits (sid229620@id-229620.helmsley.irccloud.com) (.net .split)
05:13:04	×	supersven quits (sid501114@id-501114.ilkley.irccloud.com) (.net .split)
05:13:04	×	wallymathieu quits (sid533252@id-533252.uxbridge.irccloud.com) (.net .split)
05:13:04	×	AndreasK quits (sid320732@id-320732.uxbridge.irccloud.com) (.net .split)
05:13:04	×	sabx quits (~sabbas@user/sabbas) (.net .split)
05:13:04	×	urdh quits (~urdh@user/urdh) (.net .split)
05:13:04	×	absence quits (torgeihe@hildring.pvv.ntnu.no) (.net .split)
05:13:04	×	AWizzArd quits (~code@gehrels.uberspace.de) (.net .split)
05:13:04	×	emergence quits (emergence@2607:5300:60:5910:dcad:beff:feef:5bc) (.net .split)
05:13:04	×	rawles quits (~x@user/rawles) (.net .split)
05:13:05	×	totbwf quits (sid402332@id-402332.uxbridge.irccloud.com) (.net .split)
05:13:05	×	edwardk quits (sid47016@haskell/developer/edwardk) (.net .split)
05:13:05	×	dixie quits (~dixie@real.wilbury.sk) (.net .split)
05:13:05	×	acidsys quits (~crameleon@openSUSE/member/crameleon) (.net .split)
05:13:05	×	thonkpod_ quits (~thonkpod@user/thonkpod) (.net .split)
05:13:05	×	hamishmack quits (sid389057@id-389057.hampstead.irccloud.com) (.net .split)
05:13:05	×	drewr quits (~drew@user/drewr) (.net .split)
05:13:05	×	yushyin quits (w8oD1vlcZ2@mail.karif.server-speed.net) (.net .split)
05:13:09	→	absence_ joins (torgeihe@hildring.pvv.ntnu.no)
05:13:12	→	dixie joins (~dixie@real.wilbury.sk)
05:13:12	→	AWizzArd joins (~code@gehrels.uberspace.de)
05:13:13	→	totbwf joins (sid402332@id-402332.uxbridge.irccloud.com)
05:13:13	→	dibblego joins (~dibblego@122-199-1-30.ip4.superloop.com)
05:13:14	→	Vajb joins (~Vajb@2001:999:504:1841:9e47:1ec7:a52e:1d57)
05:13:15	→	xsarnik joins (xsarnik@lounge.fi.muni.cz)
05:13:16	→	joeyh joins (joeyh@2600:3c03::f03c:91ff:fe73:b0d2)
05:13:16	→	nibelungen joins (~asturias@2001:19f0:7001:638:5400:3ff:fef3:8725)
05:13:16	→	ralu1 joins (~ralu@static.211.245.203.116.clients.your-server.de)
05:13:17	→	ysh____ joins (sid6017@id-6017.ilkley.irccloud.com)
05:13:17	→	sooch_ joins (sid533113@id-533113.hampstead.irccloud.com)
05:13:18	→	hamishmack joins (sid389057@id-389057.hampstead.irccloud.com)
05:13:20	→	spaced joins (uid572193@user/spaced)
05:13:26	→	rawles joins (~x@user/rawles)
05:13:28	→	cln joins (sid336875@id-336875.ilkley.irccloud.com)
05:13:28	→	AndreasK joins (sid320732@id-320732.uxbridge.irccloud.com)
05:13:29	×	dibblego quits (~dibblego@122-199-1-30.ip4.superloop.com) (Changing host)
05:13:29	→	dibblego joins (~dibblego@haskell/developer/dibblego)
05:13:29	→	pavonia joins (~user@ip5f5bd7bd.dynamic.kabel-deutschland.de)
05:13:29	→	supersven joins (sid501114@id-501114.ilkley.irccloud.com)
05:13:33	→	n1essa joins (3d621153a5@2604:bf00:561:2000::df7)
05:13:37	→	yushyin joins (wEE1cEPkfk@mail.karif.server-speed.net)
05:13:39	→	edmundnoble joins (sid229620@id-229620.helmsley.irccloud.com)
05:13:39	→	wafflepirate joins (sid467876@id-467876.ilkley.irccloud.com)
05:13:41	→	thonkpod_ joins (~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d)
05:13:41	→	christiaanb joins (sid84827@id-84827.lymington.irccloud.com)
05:13:42	→	AkechiShiro joins (~licht@2a01:e0a:5f9:9681:1473:3dff:fe42:56a9)
05:13:46	→	whatsupboy joins (~whatsupbo@2a01:4f9:c011:4b51::1)
05:13:47	→	PotatoGim_ joins (sid99505@id-99505.lymington.irccloud.com)
05:13:49	→	SrPx joins (sid108780@id-108780.uxbridge.irccloud.com)
05:14:02	×	pavonia quits (~user@ip5f5bd7bd.dynamic.kabel-deutschland.de) (Changing host)
05:14:02	→	pavonia joins (~user@user/siracusa)
05:14:07	→	edwardk joins (sid47016@2a03:5180:f:3::b7a8)
05:14:13	×	thonkpod_ quits (~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d) (Changing host)
05:14:13	→	thonkpod_ joins (~thonkpod@user/thonkpod)
05:14:26	→	sa joins (sid1055@id-1055.tinside.irccloud.com)
05:14:27	×	edwardk quits (sid47016@2a03:5180:f:3::b7a8) (Changing host)
05:14:27	→	edwardk joins (sid47016@haskell/developer/edwardk)
05:14:29	→	integral joins (sid296274@id-296274.lymington.irccloud.com)
05:14:29	→	wallymathieu joins (sid533252@id-533252.uxbridge.irccloud.com)
05:14:37	×	integral quits (sid296274@id-296274.lymington.irccloud.com) (Changing host)
05:14:37	→	integral joins (sid296274@user/integral)
05:14:40	→	agander_m joins (sid407952@2a03:5180:f::6:3990)
05:14:49	→	remexre joins (~remexre@user/remexre)
05:14:51	→	dispater joins (~dispater@user/brprice)
05:14:55	→	asan joins (~asansanwa@150.129.181.196)
05:14:57	→	feliix42 joins (~felix@gibbs.uberspace.de)
05:15:05	→	urdh joins (~urdh@user/urdh)
05:15:08	→	lbseale joins (~quassel@user/ep1ctetus)
05:15:08	→	poscat joins (~poscat@114.245.106.84)
05:15:13	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 248 seconds)
05:15:37	→	acidsys joins (~crameleon@openSUSE/member/crameleon)
05:15:38	→	orcus joins (~orcus@user/brprice)
05:15:43	→	bsima joins (~bsima@2604:a880:400:d0::19f1:7001)
05:16:29	→	sviermsung joins (cqQjNIqEOU@user/s4msung)
05:16:30	→	ghoulpine joins (xfnw@tilde.team)
05:16:32	<jackdk>	tbd: can you provide a complete example?
05:16:37	→	GoldsteinQ joins (~goldstein@goldstein.rs)
05:18:07	→	fgaz joins (~fgaz@2001:470:69fc:105::842)
05:18:11	→	stilgart joins (~Christoph@chezlefab.net)
05:18:18	→	sabx joins (~sabbas@user/sabbas)
05:18:21	→	raym joins (~aritra@user/raym)
05:18:41	→	nicmollel[m] joins (~nicmollel@2001:470:69fc:105::1:feeb)
05:18:42	→	Killy joins (~killy@2001:470:69fc:105::2:6ec1)
05:18:48	→	SeanKing[m] joins (~seankingm@2001:470:69fc:105::cf9c)
05:19:08	×	AkechiShiro quits (~licht@2a01:e0a:5f9:9681:1473:3dff:fe42:56a9) (Quit: WeeChat 3.7)
05:19:42	→	AkechiShiro joins (~licht@user/akechishiro)
05:19:48	→	kadoban joins (~kadoban@user/kadoban)
05:19:49	→	JensPetersen[m] joins (~juhp@2001:470:69fc:105::6e9)
05:20:08	→	polykernel[m] joins (~polykerne@user/polykernel)
05:20:19	→	MangoIV[m] joins (~mangoivma@2001:470:69fc:105::2:8417)
05:20:20	→	elvishjerricco joins (~elvishjer@2001:470:69fc:105::6172)
05:20:54	→	drsooch[m] joins (~drsoochma@2001:470:69fc:105::1:c8a1)
05:20:55	→	Neosake[m] joins (~neosakema@2001:470:69fc:105::2:989e)
05:21:44	→	weeezes[m] joins (~weeezesma@2001:470:69fc:105::1:da65)
05:22:02	<tbd>	https://github.com/thomasbach-dev/hs-rrd/blob/rrd-create/src/RRDTool/LowLevel.hsc#L34
05:23:09	<tbd>	Here is the function declaration in the headers: https://github.com/oetiker/rrdtool-1.x/blob/master/src/rrd.h#L248
05:24:26	→	sagax joins (~sagax_nb@user/sagax)
05:26:12	×	berberman quits (~berberman@user/berberman) (Ping timeout: 264 seconds)
05:28:35	→	takuan joins (~takuan@178-116-218-225.access.telenet.be)
05:29:01	→	elbear joins (~lucian@188.24.138.239)
05:29:06	→	titibandit joins (~titibandi@xdsl-78-34-208-230.nc.de)
05:29:38	×	merijn quits (~merijn@c-001-001-006.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
05:30:42	×	raym quits (~aritra@user/raym) (Ping timeout: 264 seconds)
05:32:21	→	raym joins (~aritra@user/raym)
05:33:39	×	zxx7529 quits (~Thunderbi@user/zxx7529) (Quit: zxx7529)
05:33:42	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 264 seconds)
05:39:36	<jackdk>	I cannot replicate your warning on GHC 9.2.2 (which came from shell.nix, I assume). What GHC are you working on?
05:41:48	×	Kaladin quits (~Kaladin@157-131-169-214.fiber.dynamic.sonic.net) (Quit: Leaving)
05:42:35	×	raym quits (~aritra@user/raym) (Ping timeout: 252 seconds)
05:42:37	<[Leary]>	/exit
05:42:43	×	[Leary] quits (~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
05:42:58	→	[Leary] joins (~Leary]@user/Leary/x-0910699)
05:43:19	→	raym joins (~aritra@user/raym)
05:46:18	→	elbear joins (~lucian@188.24.138.239)
05:51:01	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
05:55:07	→	lisbeths joins (uid135845@id-135845.lymington.irccloud.com)
05:56:47	→	kenran joins (~user@user/kenran)
06:05:35	→	Axman6 joins (~Axman6@user/axman6)
06:06:52	→	chomwitt joins (~chomwitt@2a02:587:dc1e:5e00:35ee:8105:5f30:c2c7)
06:07:01	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
06:09:23	×	jao quits (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 250 seconds)
06:13:48	→	zeenk joins (~zeenk@2a02:2f04:a311:7000:aa5:d3dd:854f:9922)
06:15:55	→	yelllloowwww joins (~igloo@76.209.246.53)
06:16:48	→	vn36__ joins (~vn36@123.63.203.210)
06:18:54	→	rockystone joins (~rocky@user/rockymarine)
06:19:30	→	elbear joins (~lucian@188.24.138.239)
06:19:51	×	raym quits (~aritra@user/raym) (Ping timeout: 260 seconds)
06:20:26	→	mbuf joins (~Shakthi@49.205.87.29)
06:21:02	×	yelllloowwww quits (~igloo@76.209.246.53) (Quit: Igloo IRC: https://iglooirc.com)
06:21:12	→	gmg joins (~user@user/gehmehgeh)
06:23:56	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
06:24:31	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 260 seconds)
06:24:38	→	yelllloowwww joins (~igloo@76.209.246.53)
06:25:11	×	Midjak quits (~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
06:27:16	×	Sgeo quits (~Sgeo@user/sgeo) (Read error: Connection reset by peer)
06:27:30	×	yelllloowwww quits (~igloo@76.209.246.53) (Client Quit)
06:28:53	→	cfricke joins (~cfricke@user/cfricke)
06:29:40	×	jpds quits (~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
06:29:40	×	bitdex quits (~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
06:29:40	×	chexum quits (~quassel@gateway/tor-sasl/chexum) (Write error: Connection reset by peer)
06:30:04	→	chexum joins (~quassel@gateway/tor-sasl/chexum)
06:30:15	→	jpds joins (~jpds@gateway/tor-sasl/jpds)
06:31:18	→	bitdex joins (~bitdex@gateway/tor-sasl/bitdex)
06:33:38	<tbd>	jackdk: interesting, it is ghc 9.2.2.
06:36:06	<tbd>	the warning made perfect sense to me. I guess CString is translated to `char *`, but the
06:36:06	<tbd>	function is declared to take a `const char *`.
06:38:38	<jackdk>	Your reported error talks about a `const char **` - two stars, so I'd look at how you map the `argv` permission
06:38:43	→	berberman joins (~berberman@user/berberman)
06:38:43	<jackdk>	s/permission/parameter/
06:40:27	<tbd>	Here is the output of my compilation btw: https://pastebin.com/HJKPQyz0
06:42:01	→	elbear joins (~lucian@188.24.138.239)
06:42:02	<tbd>	Yeah, correct, I'm using `Ptr CString` which feels right. :)
06:43:06	<tbd>	I just do not have a clue at all what to do with the `const`.
06:44:16	→	rockystone joins (~rocky@user/rockymarine)
06:45:42	<jackdk>	I would try a GHC issue, and if you get a good answer make a PR against the users guide
06:46:45	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
06:48:06	→	hask joins (~robert@ext-1-087.eduroam.chalmers.se)
06:48:14	<hask>	hello!
06:48:39	<hask>	I have a quick question -- If I need to get something unique to a forkIO'd thread, any suggestions?
06:49:11	<hask>	E.g the ThreadID type is stated to be abstract, so it seems unsuitable to deconstruct it and access the identifier inside
06:49:28	<hask>	I essentially need to generate a directory whose name is unique to the current thread
06:50:47	<tbd>	hask: Can the temporary package what you need?
06:51:11	<hask>	Right, from a first look this seems to be exactly what I need
06:51:14	<jackdk>	The problem you're describing might be well-solved by `mkdtemp` from `unix`
06:51:15	<hask>	Thanks
06:51:41	<jackdk>	orrr the `temporary` package tbd mentions, which has a more ergonomic interface
06:52:00	<hask>	Temporary seem quite intuitive
06:52:04	<jackdk>	Agreed
06:52:16	<hask>	Thanks for the help
06:52:47	<hask>	Hm, before I proceed, my own current usecase for this is to generate unique directories, but there might be other applications for what I am thinking
06:53:13	<hask>	If you disregard my mentioned case above, and consider the original problem, how could I get a unique 'secret' inside a specific thread?
06:54:07	<hask>	I see that I got a weird nickname here btw -- for transparency, I am Robert Krook
06:55:48	→	raym joins (~aritra@user/raym)
06:55:58	<tbd>	hask: Not exactly sure what the requirements are here, but I guess the best way is to pass it
06:55:58	<tbd>	in from the outside.
06:57:07	→	michalz joins (~michalz@185.246.207.200)
07:01:34	→	tbd` joins (~user@2a00:6020:4119:a000:c9f0:5478:d0b7:cde5)
07:03:29	→	nate1 joins (~nate@98.45.169.16)
07:04:18	<[Leary]>	hask: ThreadId is abstract, but that abstract interface includes Show, and show is presumably injective. You can use that String directly or hash it or whatnot.
07:05:26	<[Leary]>	Another option is to write a wrapper over `forkIO` that generates and provides a unique symbol, using e.g. Data.Unique.
07:05:56	×	tbd quits (~user@2a00:6020:4119:a000:37c5:734f:1b84:a7c2) (Ping timeout: 260 seconds)
07:06:18	→	lortabac joins (~lortabac@2a01:e0a:541:b8f0:6bf9:1eed:edc8:e002)
07:06:23	<jackdk>	Or generate something like a guid?
07:06:25	→	kenran` joins (~user@user/kenran)
07:06:25	→	coot joins (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
07:07:53	×	kenran quits (~user@user/kenran) (Ping timeout: 250 seconds)
07:08:01	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 252 seconds)
07:09:12	<talismanick>	How can I enable brittany support in HLS?
07:13:57	×	raym quits (~aritra@user/raym) (Ping timeout: 250 seconds)
07:14:43	→	merijn joins (~merijn@86-86-29-250.fixed.kpn.net)
07:16:26	<tomsmeding>	disco-dave[m]: wtf TIL about that issue. Thanks I hate it...
07:18:30	×	sagax quits (~sagax_nb@user/sagax) (Remote host closed the connection)
07:18:37	<dminuoso>	Im falling in love with flatparse https://gist.github.com/dminuoso/a888cc62b0d5d862f5db157e8519e2dc
07:19:21	<dminuoso>	It even brings TH helpers to unroll this loop for literals. :)
07:20:01	→	raym joins (~aritra@user/raym)
07:20:06	<Axman6>	looks like C to me :P
07:20:31	<dminuoso>	You should see the rest of my module :P
07:20:37	<Axman6>	trying to understand what's actually going on here, since nothing's being returned
07:20:56	<dminuoso>	scanXX# is a primitive that will parse and match against a word XX bits wide exactly
07:21:25	<Axman6>	oh, this is matching a bytestring literal?
07:21:30	<dminuoso>	Yes
07:21:31	<Axman6>	"literal", you know what I mean
07:21:35	<Axman6>	lovely
07:21:50	<dminuoso>	And instead of doing this in Word8 chunks, this will use native word sizse
07:21:58	<tomsmeding>	is this faster than comparing lengths and then calling out to memcmp()
07:22:00	<Axman6>	I wrote similar code for the last attempt of text-utf8 before theone that finally succeeded
07:22:08	<dminuoso>	tomsmeding: Mmmm!
07:22:27	<Axman6>	yeah that's the correct solution - but there are probably small lengths where this is faster
07:22:34	<tomsmeding>	Axman6: fair
07:22:54	<tomsmeding>	but reimplementing memcmp() is always fraught :p
07:22:58	<tomsmeding>	performance-wise
07:23:02	<Axman6>	yeah
07:23:05	<dminuoso>	Well you can just unsafe FFI call into memcmp
07:23:21	<tomsmeding>	still has a non-zero overhead, even though small
07:23:32	<tomsmeding>	but I expect that to be faster for sufficiently long bytestrings
07:23:49	<dminuoso>	Indeed, I mean I just intend to match small bytestring literals like "integer"
07:23:55	<Axman6>	I reckon you'd be able to find a small length where just doing the check in Haskell is faster than making the call to memcmp
07:24:33	<dminuoso>	I do some benchmarking then
07:24:44	<tomsmeding>	at those lengths, given that length "integer" < 8, I wouldn't even be sure whether the 64-bit stage actually helps you -- one more check for potentially little benefit
07:24:58	<Axman6>	criterion should be able to tell you where the crossover point (on your system) is
07:25:06	<dminuoso>	tomsmeding: I dont think that matters realistically.
07:25:11	<tomsmeding>	:p
07:25:12	<dminuoso>	quotRem will compile into a single machine instruction
07:25:29	<dminuoso>	So the only price is an additional branch that may not be used
07:25:36	<tomsmeding>	yeah it's miniscule
07:26:06	<tomsmeding>	it was only half-serious, but in microbenchmarks like memcmp() on length 7 (!), all bets are off
07:26:15	×	spaced quits (uid572193@user/spaced) (Quit: Connection closed for inactivity)
07:26:48	<dminuoso>	You have to be super careful to clear the cache between runs
07:27:01	<tomsmeding>	or to not
07:27:10	<dminuoso>	Well I guess both and then compare results.
07:27:12	<tomsmeding>	depends on whether you want to time the cold or the hot case :p
07:27:31	<dminuoso>	So this is an interesting case
07:27:44	<tomsmeding>	dependnig on how the input string gets to you, some part of it might already be in cache
07:28:03	<dminuoso>	For ultra small chunks you will want to include cache, since its likely that stride detectors will prefetch it ahead of time
07:28:15	×	coot quits (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
07:28:22	<dminuoso>	but for large chunks, you definitely want to measure this cold
07:28:26	<dminuoso>	(given that we are in a parser setting)
07:28:37	<Axman6>	also, don't forget the prefetch instructions you can add to this!
07:28:48	<dminuoso>	Does GHC have prefetch prims?
07:28:53	<Axman6>	yep
07:28:59	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Remote host closed the connection)
07:29:18	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
07:29:32	<Axman6>	https://hackage.haskell.org/package/ghc-prim-0.7.0/docs/GHC-Prim.html#g:36
07:29:33	<dminuoso>	So I think prefetch prims would make most sense in the TH unrolled version of this.
07:29:44	<dminuoso>	Because you know how much to prefetch
07:29:47	<Axman6>	yeah
07:30:34	<Axman6>	and if the streing is short enough you wouldn't bother
07:30:56	<Axman6>	string too
07:30:57	<dminuoso>	Mmm, with the TH helper you likely rarely have long enough strings for prefetching to be worth it.
07:30:59	→	acidjnk joins (~acidjnk@p200300d6e7137a21d59bab4b536388a8.dip0.t-ipconnect.de)
07:31:09	<dminuoso>	Or well I guess it is useful if you exceed 8 bytes...
07:31:12	<dminuoso>	Which might not be so rare
07:31:17	→	coot joins (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
07:31:40	<tomsmeding>	are the bytestrings you're matching compile-time constants
07:32:04	<dminuoso>	tomsmeding: Sure! I just wrote `bytestring` because it was a bit more convenient for the parser. :P
07:32:10	<tomsmeding>	if so, decent speedup from computing the straight-line code in advance with TH (not sure that's what you were referring to before)
07:32:36	<tomsmeding>	(one copy for each distinct length)
07:32:53	→	elbear joins (~lucian@188.24.138.239)
07:32:57	<tomsmeding>	or hand-tune per-length per-machine lol
07:32:57	<dminuoso>	https://hackage.haskell.org/package/flatparse-0.3.5.1/docs/src/FlatParse.Basic.html#scanBytes%23
07:32:59	<dminuoso>	This
07:33:30	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
07:33:45	<dminuoso>	Oh actually I realize, I can safe myself the length check if I just test the remaining length once at the beginning
07:33:54	×	chomwitt quits (~chomwitt@2a02:587:dc1e:5e00:35ee:8105:5f30:c2c7) (Quit: Leaving)
07:34:12	<dminuoso>	Oh haha. Actually I dont have any length checks yet. :>
07:34:28	<dminuoso>	Memory corruption barely avoided.
07:34:40	<talismanick>	I'm not a fan of excessively vertical code. Which formatters try to keep functions to fewer, longer lines like Brittany?
07:35:00	<dminuoso>	talismanick: I would try and develop a handwritten style
07:35:07	×	coot quits (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Client Quit)
07:35:17	<talismanick>	?
07:35:26	<Axman6>	yeah Haskell doesn't lend itself particularly well to machine formatting IMO
07:35:38	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Remote host closed the connection)
07:35:55	<Axman6>	imports etc are fine, but actual code often benefits for good hand weitten veritcal alignment
07:35:58	<Axman6>	r*
07:35:59	×	tbd` quits (~user@2a00:6020:4119:a000:c9f0:5478:d0b7:cde5) (Remote host closed the connection)
07:36:14	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
07:36:34	×	whatsupboy quits (~whatsupbo@2a01:4f9:c011:4b51::1) (Quit: brb)
07:37:36	<dminuoso>	I would argue that formatters are rarely a good idea (outside of a very limited scope like imports). Programming languages are not just for communicating with the compiler, they are more importantly for communicating with the programmer. A formatter will generally have a hard time understanding what you want to communicate.
07:37:38	<talismanick>	Really? If I'm reading someone else's code, I typically navigate blockwise (along the AST) with shm.el while looking at the type signature
07:37:54	<dminuoso>	I dont have strict ruels for the most part, I vary formatting locally to express certain facts.
07:38:02	<dminuoso>	Sometimes I add redundant parens because it helps readability
07:38:05	<Axman6>	me too
07:38:07	<talismanick>	I hardly visually parse code... I like to have more on my screen so it's in working memory
07:38:09	<Axman6>	we should be friends dminuoso
07:38:30	<talismanick>	shm.el and paredit.el (its inspiration) are great
07:40:08	<probie>	I'm not a huge fan of vertical alignment, it creates a lot of noise in diffs
07:40:24	<Axman6>	only with poor diff tools
07:40:27	<merijn>	Axman6: See also: https://twitter.com/comerijn/status/1257804634833420292
07:40:34	<Axman6>	code is for me, not diffs
07:40:59	<merijn>	probie: That's why whitespace ignoring diffs exist in literally every diff/version control system that matters :)
07:41:12	<dminuoso>	merijn's remark in the second comment has the really relevant bit:
07:41:19	<dminuoso>	`code is read more often than it's written` (or read in diffs)
07:41:30	<merijn>	I look at diffs a lot
07:41:39	<merijn>	but I also use whitespace ignoring diff :p
07:41:43	→	bitdex_ joins (~bitdex@gateway/tor-sasl/bitdex)
07:41:45	<dminuoso>	I look at code more, given that I constantly read contextual code while Im writing.
07:41:46	×	bitdex quits (~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 258 seconds)
07:41:56	<hask>	exit
07:41:59	×	hask quits (~robert@ext-1-087.eduroam.chalmers.se) (Quit: Lost terminal)
07:42:09	<tdammers>	anyone who has ever reviewed a long-lived PR on a large real-world codebase can tell you that diff ergonomics matter greatly
07:42:33	<dminuoso>	tdammers: That's absolutely fair. For starters, everybody should be using diff3 style over diff2!
07:42:57	<dminuoso>	(It's beyond me how `git` even defaults to `diff2`...)
07:42:58	<talismanick>	I mean, I find it easier to read code when it's a) all on my screen b) structurally navigable (which alleviates the need to space it out vertically for legibility)
07:43:46	<Axman6>	GitHub's UI does a pretty great job these days with showing the core of the diff and ignoring the whitespace changes needed to facilitate it
07:43:47	<tdammers>	and here's the thing with vertical aligning: even with whitespace-ignorant diffing, the merge that inevitably follows is still hampered by it
07:43:48	<talismanick>	so, it really annoyed me when my settings for Brittany (which does what I want, mostly) stopped working (no clue why)
07:44:00	<dminuoso>	Perhaps the biggest problem of vertical alignment is that we use text to communicate code. If we just expressed the AST, then something like formatting could be controlled via a separate style hinting language, potentially even overwritten by rendering preference
07:44:40	<Axman6>	yeah every few years someone reinvents flexible tabs and then no one ever gets them working
07:44:50	<tdammers>	if you use newlines + indentation instead of vertical alignment, then the textual representation reflects the AST structure
07:44:55	<Axman6>	the world needs more Unison
07:45:10	<talismanick>	I was actually just thinking of mentioning Unison lol
07:45:15	<dminuoso>	tdammers: Mmm, can you elaborate on that?
07:45:16	<talismanick>	(not sure if it's offtopic or not)
07:45:36	<Axman6>	Unison is like Haskell#
07:45:38	<talismanick>	making the hashed representation the canonical one fixes so much
07:45:54	<dminuoso>	\|> looks elixirish.
07:46:01	<merijn>	Structural editing and structural VC are the way
07:46:12	<merijn>	But no one wanted to fund my PhD on those :p
07:46:20	<dminuoso>	merijn: Sandy Maguire did work on that.
07:46:27	<dminuoso>	It just headed a different way than originally planned...
07:46:32	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Remote host closed the connection)
07:46:32	<talismanick>	merijn: thoughts on https://github.com/vcmiraldo/hdiff?
07:46:47	<Axman6>	404
07:46:50	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
07:46:53	<dminuoso>	Wingman was supposed to be a structural editing mechanism, arosen from the idea of what it would take to enable programming on a tablet while sitting on a bench in the park
07:46:55	<talismanick>	https://github.com/VictorCMiraldo/hdiff
07:47:04	<dminuoso>	But wingman has become something...; else..
07:47:07	<talismanick>	remembered his handle wrong lol
07:47:16	<tdammers>	dminuoso: tricky over IRC, but I'll try. The idea is that every AST node (or actually CST, but let's squint a little here) is either represented as a single line of code, or as one line followed by the sub-nodes, indented one level deeper
07:48:09	<tdammers>	this way, you never need to vertically align anything beyond the natural indentation, and that natural indentation already produces the correct alignments - except when you keep a node collapsed on a single line
07:48:20	<dminuoso>	Yeah gotcha
07:48:27	<merijn>	talismanick: Pretty neat stuff
07:48:29	<talismanick>	My impression is that it's to darcs('s patch-based model) as Unison is to Haskell
07:49:03	<talismanick>	or, at least, could serve as a basis for such
07:49:07	<merijn>	talismanick: Somewhat relatedly, in the category of Haskell superpowers there's a diff library for ADTs that produces diff for arbitrary ADT values
07:49:13	<Axman6>	wasn't there an alternative syntax someone made for Haskell that was more more indentation based? sounds like what you're talking about tdammers
07:49:41	<tdammers>	Axman6: I don't think you need an alternative syntax for that; plain Haskell gets you 99% there, you just need to follow the conventions consistently
07:49:46	<talismanick>	Axman6: are you talking about the Markdown-related one?
07:49:51	<tdammers>	(which, I admit, I don't always do either...)
07:50:04	<Axman6>	so each function's arguments were on new lines and indented more than the function, and if arguments to that function were other functions, there was no need for brackets, because you'd just indent the arguments more
07:50:16	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 260 seconds)
07:50:16	<tdammers>	oh, like that, eww
07:50:37	<tdammers>	"layout on crack", a.k.a. "python"
07:51:04	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
07:51:04	<dminuoso>	tdammers: But yeah it makes perfect sense. This is like the common tree printing algorithm.
07:51:12	<tdammers>	dminuoso: exactly.
07:51:39	<Axman6>	https://gist.github.com/axman6-da/586937ed83233823a138c1e247a3bc1d
07:51:49	<talismanick>	https://web.archive.org/web/20220905031105/https://chrisdone.com/posts/z/ ?
07:51:57	→	tromp joins (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
07:52:07	<Axman6>	uh, wrong
07:52:17	<tdammers>	Axman6: yeah, I get it, but IMO that causes a truckload of other problems (as it does in Python)
07:52:19	<Axman6>	fixed
07:52:38	<talismanick>	Axman6: ^ ?
07:53:10	<talismanick>	idk why, but it 404's on the live page (even though it's linked to as a "Popular Article")
07:53:45	<talismanick>	not that Z has been a tasteful name for a language this past year >_>
07:53:56	<Axman6>	I meant my code was wrong, and I fixed it
07:54:20	<talismanick>	I meant, is the link I sent what you were talking about?
07:54:25	→	machinedgod joins (~machinedg@d198-53-218-113.abhsia.telus.net)
07:54:36	<Axman6>	yeah that looks about right
08:01:36	×	razetime quits (~quassel@117.193.4.27) (Ping timeout: 264 seconds)
08:04:39	×	lisbeths quits (uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
08:07:32	→	coot joins (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
08:11:29	×	shriekingnoise quits (~shrieking@186.137.167.202) (Quit: Quit)
08:13:20	<talismanick>	merijn: link to that diff library?
08:13:40	<talismanick>	phadej's tree-diff?
08:14:11	→	fserucas joins (~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
08:14:43	<merijn>	yeah
08:14:50	<merijn>	It's pretty amazing for debugging
08:15:10	talismanick	scribbles down ideas for using new toy
08:15:36	<merijn>	It's the kinda shit that makes you think all your work in other languages is stone age nonsense
08:17:07	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 248 seconds)
08:17:27	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
08:17:36	<talismanick>	oh, gdiff looks nice... been playing around lately with GADTs and free monads in polysemy
08:18:02	<talismanick>	too bad it's so old
08:21:33	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
08:22:50	→	teo joins (~teo@user/teo)
08:22:55	<dminuoso>	So?
08:23:08	<dminuoso>	This is the type of library that is simply... done.
08:23:15	<dminuoso>	It has no non-base dependencies to ever bump.
08:23:26	→	vn36 joins (~vn36@123.63.203.210)
08:23:35	<dminuoso>	And it has a liberal base constraint that, in all likelihood, will work for a long time.
08:24:28	<dminuoso>	There's not really any relevant open issues either
08:26:35	→	stiell_ joins (~stiell@gateway/tor-sasl/stiell)
08:26:38	<tdammers>	it's ridiculous how the idea that code "ages" has spread
08:26:38	→	razetime joins (~quassel@117.193.4.27)
08:28:49	<merijn>	tdammers: Seems easy to understand if you only ever do JS/python development :p
08:29:02	<merijn>	because there anything that wasn't used the past month probably is broken xD
08:29:31	×	chexum quits (~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
08:29:50	×	titibandit quits (~titibandi@xdsl-78-34-208-230.nc.de) (Remote host closed the connection)
08:29:59	<dminuoso>	Im personally a big fan of stable APIs too. If your code works 10 years from now, that's a big plus.
08:30:13	→	chexum joins (~quassel@gateway/tor-sasl/chexum)
08:30:45	<dminuoso>	But that gets into a different kind of discussion, as that's a compromise between initial release speed, good ergonomics and stability.
08:31:03	<dminuoso>	One usually must take the backseat
08:31:38	<tdammers>	merijn: yeah, but that's the ridiculous bit. the code itself doesn't actually "age", it's still exactly the same code. it's just that people decide every other week that the execution environment must change in incompatible ways, for some reason.
08:32:08	<dminuoso>	tdammers: Hah what is amazing, is how many compatibility shims and libraries exist in the JS world.
08:32:32	<dminuoso>	The fact that you have entire repositories of compiler plugins designed just for forward or backward compability is just absurd.
08:33:07	<dminuoso>	But things like `base-compat-batteries` have started to become more and more popular on hackage too
08:34:33	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 252 seconds)
08:34:48	<merijn>	Adding forward compat to old base versions is a lot more sound than a lot of the stuff happening in the JS world, though
08:34:59	<merijn>	So I don't think you can put those at the same level
08:35:13	<tdammers>	I guess it's a natural development for a language whose origins trace back to the browser wars and weaponized incompatibilities
08:35:48	<Hecate>	tbh I wouldn't overhype the usage of base-compat-batteries, it's really not used directly that much
08:36:01	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
08:36:07	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
08:36:55	→	zer0bitz joins (~zer0bitz@2001:2003:f748:2000:3d5a:c60:7a1a:1513)
08:37:02	<merijn>	It has a whopping 21 reverse dependencies
08:37:45	<dminuoso>	It's in aeson.
08:37:56	<dminuoso>	Which means a quarter of hackage has it.
08:38:07	<merijn>	yeah, but if aeson dropped it, they wouldn't
08:38:21	<dminuoso>	aeson does not simply drop a dependency. they add.
08:38:23	<dminuoso>	:)
08:40:11	×	talismanick quits (~talismani@2601:200:c100:c9e0::1b0b) (Remote host closed the connection)
08:40:40	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
08:41:01	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Ping timeout: 260 seconds)
08:41:28	<probie>	Is there something smaller than base that one can depend on and isn't tied to specific GHC versions?
08:43:00	<dminuoso>	Well you can use.. no base?
08:43:00	→	MajorBiscuit joins (~MajorBisc@145.94.164.10)
08:43:08	<dminuoso>	:p
08:43:31	<dminuoso>	I suppose `ghc-prim` would work
08:44:12	×	loras quits (~loras@c-73-139-125-125.hsd1.fl.comcast.net) (Ping timeout: 264 seconds)
08:46:21	×	szkl quits (uid110435@uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
08:46:37	<tomsmeding>	is ghc-prim not tied to ghc versions?
08:47:50	→	rockystone joins (~rocky@user/rockymarine)
08:48:08	→	kuribas joins (~user@ptr-17d51eoxcqlpawtoc5a.18120a2.ip6.access.telenet.be)
08:48:44	→	azimut joins (~azimut@gateway/tor-sasl/azimut)
08:49:13	<tomsmeding>	should be noted, if you're interested in this space, that GHC always makes a module GHC.Prim available, built-into the compiler; that module is not in the ghc-prim docs
08:50:15	×	tzh quits (~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
08:53:00	<merijn>	tomsmeding: It is
08:53:22	<tomsmeding>	right, so it's not really an answer to probie's question :p
08:53:25	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
08:54:43	<probie>	I want to be able to write something that will work "as is" in 5 years time without just closing my eyes and declaring a very optimistic base upper bound
08:54:55	<merijn>	probie: You can't
08:55:09	<dminuoso>	The expectation is completely unreasonable.
08:55:13	<merijn>	probie: But otoh, realistically, breaking changes in base are a Big Deal (TM)
08:55:22	<dminuoso>	You expect to work with an unspecified future compiler and magically expect it to be compatible.
08:55:33	<dminuoso>	These two things are incompatible
08:55:46	<merijn>	probie: If you use a conservative subset of base then the odds of it breaking are pretty damn small
08:55:49	<dminuoso>	Unless there was ever a memorando of understanding, that breaking changes are never introoduced
08:55:53	<dminuoso>	Like in the linux kernel
08:56:06	<merijn>	probie: I have some libraries where the only changes the past years are "bump base version"
08:57:05	<merijn>	btw, most underrated Haskell ecosystem feature is packdeps providing an RSS feed notifying you when your upperbounds exclude the most recent version of a dependency
08:57:39	<merijn>	I just have RSS feeds for my packages to see if/when I need to revisit bounds and don't think about otherwise
08:57:43	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
08:58:11	<dminuoso>	RSS sits right along IRC. Something ancient and "aged".
08:58:25	<dminuoso>	People just stopped using it in favour of drastically more complicated and less reliable things
08:58:37	<dminuoso>	Twitter and Matrix. :p
08:58:40	→	elbear joins (~lucian@188.24.138.239)
08:58:50	<merijn>	RSS is still amazing
08:58:53	<dminuoso>	So is IRC!
08:59:29	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 252 seconds)
08:59:48	→	wonko joins (~wjc@2a0e:1c80:2:0:45:15:19:130)
09:00:09	×	TrueBlue[m] quits (~busterblu@2001:470:69fc:105::1:d7e8) (Quit: You have been kicked for being idle)
09:03:37	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 268 seconds)
09:03:42	<merijn>	dminuoso: Have you seen the bazqux RSS aggregator?
09:05:19	×	razetime quits (~quassel@117.193.4.27) (Ping timeout: 250 seconds)
09:05:41	→	CiaoSen joins (~Jura@p200300c9570723002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
09:05:49	→	razetime joins (~quassel@117.193.4.27)
09:11:18	→	jmorris joins (uid537181@id-537181.uxbridge.irccloud.com)
09:11:35	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
09:14:22	→	__monty__ joins (~toonn@user/toonn)
09:14:32	→	rockystone joins (~rocky@user/rockymarine)
09:16:19	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
09:19:51	→	`2jt joins (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net)
09:22:47	→	nate1 joins (~nate@98.45.169.16)
09:22:57	×	vn36 quits (~vn36@123.63.203.210) (Ping timeout: 252 seconds)
09:24:50	→	vn36_ joins (~vn36@123.63.203.210)
09:27:43	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 252 seconds)
09:31:29	×	azimut quits (~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
09:31:56	→	azimut joins (~azimut@gateway/tor-sasl/azimut)
09:37:31	×	ft quits (~ft@p3e9bc57b.dip0.t-ipconnect.de) (Quit: leaving)
09:54:58	→	jumper149 joins (~jumper149@base.felixspringer.xyz)
09:56:11	<jumper149>	Does GHC collect garbage concurrently, when compiled with `-threaded` or do I need anything else? I found `--nonmoving-gc`, but the manual says "Hopefully, you won’t need any of these in normal operation".
09:56:17	→	elbear joins (~lucian@188.24.138.239)
09:56:27	→	raehik1 joins (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
09:57:58	<merijn>	jumper149: No, GC is always stop the world. The non-moving GC aims to stop the world for shorter, bounded times, but still stop the world
09:58:15	<merijn>	jumper149: Also, why do you think you need concurrent GC?
09:58:24	<geekosaur>	there is parallel gc but until 9.2.x it didn't work well
09:58:36	<merijn>	geekosaur: Even in 9.2 it's not great afaik
09:58:39	<geekosaur>	(parallel != cooncurrent)
09:59:11	<merijn>	geekosaur: Even Simon Marlow recommended non-parallel GC when (did it already happen?) GHC makes -threaded the default
10:00:20	<geekosaur>	if it happened it'd be in 9.4
10:00:37	→	Kaiepi joins (~Kaiepi@142.68.249.28)
10:00:43	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
10:00:57	<geekosaur>	but I think it hasn't happened yet
10:01:02	<geekosaur>	maybe 9.6
10:02:09	×	econo quits (uid147250@user/econo) (Quit: Connection closed for inactivity)
10:02:27	×	califax quits (~califax@user/califx) (Ping timeout: 258 seconds)
10:05:55	×	razetime quits (~quassel@117.193.4.27) (Ping timeout: 248 seconds)
10:17:39	<dminuoso>	Axman6: Mmm, we should take cache line alignment into consideration too!
10:17:48	<jumper149>	Is there anything fundamental, that makes parallel gc hard? I expected it to be quite straightforward? The addresses in memory are accessible by any thread, right?
10:18:06	<dminuoso>	Blindly just grabbing 64 byte chunks is likely not efficient if you cross cache lines.
10:18:20	<dminuoso>	That's actually a problem in the TH unrolled helper too.
10:19:00	×	CiaoSen quits (~Jura@p200300c9570723002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
10:19:02	<geekosaur>	jumper149, that's actually part of the problem. you need to at some point stop all capabilities to do updates, since otherwise any thread might try to access memory while it's being moved
10:19:25	<dminuoso>	I mean for small strings around the size of 8, it will increase thrashing.
10:19:41	<dminuoso>	Though.. mmm. I dont think you can get around that here
10:21:54	<merijn>	jumper149: Also in many cases the parallelism just doesn't gain you much
10:21:57	<merijn>	It's kinda niche
10:22:08	<merijn>	parallelism is great if you have a large working set
10:22:27	<merijn>	But large working sets are bad anyway and generational GC already helps make that less of an issue
10:23:04	<merijn>	Lazy code tends to allocate tons and produce lots of garbage, so these are things GHC's GC are tuned for. Allocation is dirt cheap and garbage is free
10:23:40	→	szkl joins (uid110435@id-110435.uxbridge.irccloud.com)
10:23:43	→	afotgkmnzj7asv3r joins (~afotgkmnz@2001:470:69fc:105::c24b)
10:23:45	<merijn>	The downside is that concurrent GC is kinda hard with that design. But concurrent GC is mostly relevant for code that can't tolerate a GC pause (i.e. only really real time code)
10:24:06	<juri_>	merijn: and security related.
10:24:10	<merijn>	But if you don't have real time code, concurrent GC is most likely gonna be lower efficiency than GC pauses
10:24:11	×	`2jt quits (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net) (Ping timeout: 250 seconds)
10:24:29	<juri_>	(making two code paths take the same time always, in a lazy garbage collected language is hard)
10:25:11	<merijn>	juri_: Sure, but anyone asking these questions doesn't know enough to be writing security code to begin with :)
10:25:32	<merijn>	because that's the least of your issues with most languages
10:26:03	<jumper149>	I can agree, I didn't think about security at all :D
10:26:36	<juri_>	fair. :D
10:27:04	→	razetime joins (~quassel@117.193.4.27)
10:27:30	→	vglfr joins (~vglfr@145.224.100.100)
10:27:53	→	califax joins (~califax@user/califx)
10:30:50	<merijn>	jumper149: For most code that isn't real time, the thing you care about it "throughput" (or efficiency) i.e. what percentage of CPU time/cycles is spent on "work" vs spent on "GC". If "long" GC pauses get better efficiency, your code will (overall) take shorter to run than code with lower efficiency
10:31:10	<jumper149>	Overall I was just thinking, whether real time applications were possible with GHC. But there is really no way to take influence on the gc? Or are there primites to delay gc for some time for example?
10:31:22	<merijn>	jumper149: And in general GHC's GC produces pretty good efficiency
10:31:33	<merijn>	jumper149: It depends on how tight your deadlines are, etc.
10:31:48	<merijn>	But in general GHC's runtime isn't really designed with real time in mind
10:31:49	<jumper149>	merijn: I fully understand the efficiency vs latency
10:32:16	<merijn>	There's no (theoretical) reason you couldn't produce a more real time focussed runtime that would let you write real time code in Haskell
10:32:25	<jumper149>	Ok, I guess imperative languages like rust still have the edge in this case
10:32:26	×	xff0x quits (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 260 seconds)
10:32:28	<merijn>	It's just A LOT of work and not many people caring about that
10:32:48	<merijn>	The people who are likely to care about real time would probably just use Rust, yeah
10:33:01	×	vn36_ quits (~vn36@123.63.203.210) (Ping timeout: 260 seconds)
10:33:05	<jumper149>	Yeah, I guess the people, that do care, are more into Rust, C++, Zig, etc
10:33:23	<merijn>	jumper149: Note that it's not necessarily because imperative languages are better. It's more that "doing low level and real time stuff" was a core goal of Rust from the start
10:33:29	<merijn>	So every system has been designed with that in mind
10:33:39	<tdammers>	I think the big elephant in the room with realtime Haskell is memory allocations, yeah. The key thing you want with RT is keep allocations out of the RT-critical parts of the code, and Haskell just doesn't give you much control over that
10:33:45	<juri_>	i know some people who real time "in haskell". they use haskell to write C. ;)
10:34:00	<merijn>	juri_: Yeah, you might like Ivory (I think it was?)
10:34:02	<merijn>	eh
10:34:09	<merijn>	s/juri_/jumper149
10:34:09	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
10:34:22	<merijn>	It's a Haskell DSL for generating cryptographic code in C
10:34:42	<merijn>	I think there's a couple of other too
10:34:44	<dminuoso>	For what its worth, tracking ownership is possible in functional languages too. Clean does it attain huge performance boosts, as it can turn pure updates into in-place memory manipulation using its type system.
10:35:23	→	vn36 joins (~vn36@123.63.203.210)
10:35:26	<merijn>	Right, the focus on lazy + application performance has just moved Haskell into a direction where optimising for realtime wasn't a concern for anyone actually working on the language
10:35:46	<jumper149>	merijn: That's pretty cool, but I didn't even have any actual TODO in mind ^^
10:36:24	<jumper149>	Yeah, I can see how it can go into that direction with the focus on lazyness
10:36:54	<jumper149>	Thanks for the help though :)
10:37:00	<merijn>	jumper149: And also, have a look at Clash (completely different thing, but still neat!)
10:38:28	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
10:38:31	→	shapr joins (~user@2a02:8106:31:b200:3858:16dd:1a2:d1d1)
10:40:38	→	beteigeuze joins (~Thunderbi@2001:8a0:61b5:6101:f0c:e4e3:bfdc:91df)
10:41:43	→	`2jt joins (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net)
10:51:40	×	yushyin quits (wEE1cEPkfk@mail.karif.server-speed.net) (Quit: WeeChat 3.4.1)
10:51:50	→	yushyin joins (U26EzVMO8P@mail.karif.server-speed.net)
10:52:11	<juri_>	clash is awesome. one of these days.. :)
10:54:46	→	jao joins (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
10:57:20	→	Guest54 joins (~Guest54@base.felixspringer.xyz)
10:57:55	×	Guest54 quits (~Guest54@base.felixspringer.xyz) (Client Quit)
11:05:37	×	vn36 quits (~vn36@123.63.203.210) (Ping timeout: 252 seconds)
11:06:45	<dminuoso>	merijn: If you find a poor soul wanting to do a PhD, I really would like a P4 variant of it!
11:06:51	<dminuoso>	>:)
11:07:24	<dminuoso>	Though sadly, I think the P4 user base is incredibly small and limited already.
11:08:32	<shapr>	what did I miss?
11:08:38	<shapr>	a P4 variant of what?
11:08:42	<dminuoso>	Of clash
11:08:45	<shapr>	oh
11:08:51	<dminuoso>	well "variant" is a bit far stretched
11:08:56	<shapr>	I know clash, what's P4?
11:09:11	×	vglfr quits (~vglfr@145.224.100.100) (Ping timeout: 260 seconds)
11:09:18	<dminuoso>	Its a programming language for controlling forwarding planes in networking gear.
11:09:30	→	vglfr joins (~vglfr@145.224.100.100)
11:09:31	<dminuoso>	For high performance routers and switches
11:10:15	<dminuoso>	Fixed function ASICs have largely become a thing of the past for the same reasons general purpose CPUs run on microcode
11:10:27	<shapr>	oh interesting
11:10:51	→	vn36__ joins (~vn36@123.63.203.210)
11:11:13	<shapr>	Is P4 sufficiently close to Verilog that clash would do the right thing?
11:11:18	<shapr>	or is there some other clash I don't know?
11:11:22	<dminuoso>	No. P4 is roughly similar to say megaparsec. :P
11:11:27	<shapr>	oh, ok
11:12:03	<dminuoso>	Essentially its a way to build stateful parsers but part of a networking pipeline
11:12:04	<geekosaur>	if you hated yourself you could probably reimplement megaparsec in verilog 🙂
11:12:11	<dminuoso>	That can decode and handle packets in nanosecond time
11:13:00	<dminuoso>	shapr: https://github.com/p4lang/tutorials/blob/master/exercises/basic_tunnel/solution/basic_tunnel.p4
11:13:06	<dminuoso>	This is an example of a P4 program
11:21:06	×	jmorris quits (uid537181@id-537181.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
11:23:02	→	xff0x joins (~xff0x@2405:6580:b080:900:4d83:b51f:a73e:c986)
11:25:18	←	jakalx parts (~jakalx@base.jakalx.net) (Error from remote client)
11:29:11	×	jmdaemon quits (~jmdaemon@user/jmdaemon) (Ping timeout: 250 seconds)
11:30:46	<merijn>	dminuoso: Can do a postdoc ;)
11:30:53	<merijn>	dminuoso: P4 is the routing shit, right?
11:31:05	<dminuoso>	Or switching, or encapsulation, but yeah.
11:31:20	<merijn>	dminuoso: my old group used to a bunch of shit like for SDN stuff
11:31:36	<dminuoso>	OpenFlow?
11:31:46	<merijn>	My promotor was doing a bunch of that, they wrote some P4 on GPU routing too
11:31:51	<merijn>	openflow and a bunch of other stuff
11:31:55	<dminuoso>	Neato
11:36:13	→	elbear joins (~lucian@188.24.138.239)
11:39:38	×	shapr quits (~user@2a02:8106:31:b200:3858:16dd:1a2:d1d1) (Ping timeout: 268 seconds)
11:40:27	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 250 seconds)
11:45:26	×	werneta quits (~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
11:50:47	sshine_	is now known as sshine
11:53:50	→	Profpatsch joins (~Profpatsc@static.88-198-193-255.clients.your-server.de)
11:54:07	<sshine>	does anyone have a link to some write-up discussing why the Def type class isn't popular among Haskellers?
11:55:01	<Profpatsch>	sshine: Mostly cause a) it’s not in base so effort to import and an additional dependency b) it’s inflexible compared to the default* pattern
11:55:16	<geekosaur>	I don't have a link but I can explain it. defaults are contextual, not per type
11:55:38	<Profpatsch>	c) it’s hard for reader because it infers data from context
11:55:42	<Profpatsch>	*for the reader
11:56:05	<merijn>	Also, "default" doesn't generalise
11:56:12	<merijn>	Like, what the hell is "the default Integer"?
11:56:19	<sshine>	Profpatsch, what's "the default* pattern"?
11:56:21	<Profpatsch>	merijn: 0 according to go :P
11:56:32	<merijn>	Almost all values have multiple sensible defaults and Def elevates one fairly randomly
11:56:42	<Profpatsch>	sshine: if you have a type like HttpOptions you provide a function defaultHttpOptions
11:56:53	<merijn>	The "most useful" case of Def is when you use it transitively to initialise a bunch of fields, but those defaults aren't general
11:56:58	<Profpatsch>	meaning you can also have a function defaultHttpOptionsSsl or something
11:57:30	<sshine>	I'm recording your answers, all of which align perfectly with what I believe, but I'm asking if anyone knows a write-up that I can refer to, kind of like when you write a Wikipedia article about your own opinion and you can't say "Scientists say..." just because you're a scientist. :-P
11:57:36	<merijn>	sshine: What does "instance Def Foo where def = ..." give me that "myDefault :: Foo; myDefault = ..." does not?
11:57:44	<merijn>	sshine: Fuck yes I can :p
11:57:57	<merijn>	I've been using "the doctor says so" to justify anything I want the past month!
11:57:57	<sshine>	merijn, citation needed!
11:58:02	<Profpatsch>	sshine: maybe you can write one called “why you shouldn’t use the Default trait/typeclass pattern and alternatives”
11:58:13	<merijn>	sshine: "Merijn Verstraaten, personal communication on IRC" :)
11:58:14	<sshine>	merijn, an apple a day keeps yourself away? whoops!
11:58:43	<merijn>	Science got lame when we stopped citing "personal communication" :p
11:58:51	<geekosaur>	but tbh my main reference for Default being bad is https://github.com/xmonad/xmonad/commit/383ffb772e4a
11:59:01	<Profpatsch>	the Default pattern is something that sounds cool on first thought, then Rust puts it into its stdlib, then people start thinking about it in depth :PP
12:00:14	<merijn>	Some things just aren't written down, because they're too obvious
12:00:32	<Profpatsch>	merijn: my rule is that everything is obvious once you’ve internalized it
12:00:39	<sshine>	https://i.imgflip.com/6x7dz2.jpg
12:00:39	<Profpatsch>	but everything warrants documenting
12:00:51	<merijn>	Now I'm thinking about the guy arguing on reddit that dogs don't understand "finger pointing", because there was no research establishing they could >.>
12:01:09	<merijn>	Source: "I have interacted with the real world"
12:01:20	<sshine>	Profpatsch, I wish "then people start thinking about it" was what happened, but it's more like "then people start implementing Default for EVERY FREAKING THING THEY CAN"
12:01:20	<Profpatsch>	merijn: oh there’s a great trolley problem one about this
12:01:43	<Profpatsch>	I hope I saved it somewhere
12:01:49	<merijn>	sshine: I blame English for conflating doctor and "physician" as if the latter isn't just a trade with pretensions :p
12:04:00	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 264 seconds)
12:05:29	<sshine>	merijn, blame Default instances ;)
12:05:32	×	cfricke quits (~cfricke@user/cfricke) (Ping timeout: 268 seconds)
12:05:59	<sshine>	everyone knows doctors fix humans
12:07:05	×	poscat quits (~poscat@114.245.106.84) (Read error: Connection reset by peer)
12:07:15	<sshine>	geekosaur, thanks for giving me a concrete example of why Default is bad. :)
12:07:19	→	poscat joins (~poscat@2408:8206:4823:fd6f:98ab:5c38:136c:5932)
12:08:05	<jackdk>	one of these days I'll get around to writing "`Default`? With respect to what? Do you mean `Monoid`?" Until then, I recommend the aesthetically-pleasing instances at https://hackage.haskell.org/package/acme-default
12:08:16	→	elbear joins (~lucian@188.24.138.239)
12:12:34	<sshine>	jackdk, lol! "Current default False chosen by ertes, the answer to the question whether mniip has a favourite Bool."
12:12:43	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
12:13:39	→	elbear joins (~lucian@188.24.138.239)
12:15:24	<sshine>	another language feature that gets abused by my colleagues new to Rust is 'impl From<X> for Y' and then replace all named functions with .into(), because the first transformation of one type to another might just be the canonical. all your function compositions become these .into() chains. let bar: Bar = foo.into(); let baz: Baz = bar.into();
12:16:19	<sshine>	I also abuse language features that I discovered recently. I just spend more time exploring language features and apply the abuse in pet projects.
12:17:30	→	jakalx joins (~jakalx@base.jakalx.net)
12:18:01	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 260 seconds)
12:18:15	<merijn>	sshine: I write them in obscure gists to show off :p
12:18:43	<merijn>	Still proud of this atrocity: https://gist.github.com/merijn/6130082
12:22:38	<sshine>	merijn, hehe
12:27:16	<Profpatsch>	jackdk: that package makes the point pretty well :P
12:28:05	<Profpatsch>	oh, and RIP ertes
12:28:22	×	bitdex_ quits (~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
12:28:23	×	coot quits (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
12:28:33	×	jao quits (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 250 seconds)
12:30:18	<jumper149>	merijn: You asked "what is the default Integer". I raise "What is the Semigroup on Integers?". This is a general problem with typeclasses. Idris solves it by having named implementations (instances), so you can have a Semigroup instance named `Plus` and one named `Mult` for example.
12:31:00	<jumper149>	In Haskell you just have to choose. Or you use newtypes I guess
12:31:28	<tdammers>	newtypes are kinda like the accepted "solution" for when you want more than one instance
12:31:32	<merijn>	jumper149: I'm not 100% convinced naming solves the problem :p
12:32:02	<jackdk>	If we had a better hierarchy than `Num` that had a `Ring` somewhere, we could make the canonical semigroup for numeric types plus-ish, and then replace `(<>)` with `(+)` everywhere
12:32:57	<jumper149>	merijn: Does `Double` have satisfy a ring structure?
12:33:09	<jumper149>	s/have//
12:33:20	<tdammers>	that's an orthogonal issue
12:34:02	<[Leary]>	jackdk: I'd rather we had `(+) :: Semigroup (Sum a) => a -> a -> a`, `(*) :: Semigroup (Product a) => a -> a -> a`.
12:34:26	<jumper149>	[Leary]: Honestly a nice idea.
12:34:31	<tdammers>	Numerical typeclasses on Double are wrong, but in a practical "but they should" kind of way; the issue with Semigroup Int is that a typeclass is fundamentally the wrong thing for modelling semigroups, it's just that we don't have anything better
12:34:46	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
12:34:59	<tdammers>	(or alternatively: naming the Semigroup typeclass after semigroups is wrong, but too tempting not to)
12:35:02	<dminuoso>	Are there efficient show numerical routines for bytestring like `Int -> ByteString`?
12:35:08	<dminuoso>	Well. Functions!
12:35:11	<sshine>	what are some examples of when speaking of defaults makes sense? besides "a configuration file" or "a default file path"
12:35:12	<jumper149>	Maybe C++ overloading was the best solution all along x)
12:35:19	<merijn>	dminuoso: What does you mean by "show numerical"
12:35:23	<merijn>	jumper149: Oh god no
12:35:28	→	elbear joins (~lucian@188.24.138.239)
12:35:35	<lortabac>	if you want you can have named instances in Haskell by adding a type parameter to the class
12:35:37	<dminuoso>	merijn: what `show 10` would do, but directly on a bytestring buffer.
12:35:43	<tdammers>	note that I didn't say typeclasses are wrong in general. they're one honking useful language feature
12:35:48	<merijn>	sshine: Default configuration often make sense, but defining one as a value instead of Def makes 0 difference in effort
12:35:58	<dminuoso>	merijn: bytestring already comefs with `readInteger` and `readInt`, just want something to roundtrip with that.
12:36:14	<tdammers>	and in fact we can model semigroups correctly, but it's a bit awkward, because it requires passing the semigroup itself around
12:36:17	<merijn>	sshine: The only "value add" of Def is that you can invoke it recursively (instantiating fields with their defaults), but since defaults aren't general, that doesn't work
12:36:40	<sshine>	merijn, I agree :) but I'm trying to justify the notion that "a default" makes sense. you have to put a concept on a pedestal to shoot it down.
12:37:07	<sshine>	merijn, right, I noted that down in the tl;dr version as "Defaults are useful for transitive derivation, but risk context drift causing errors"
12:37:12	<tdammers>	in practice, the most whopping advantage of `def` is that you get to use the same short identifier for all your default values XD
12:38:01	<jackdk>	Combine with Applicative for `def <$> def <> def <> def <*> def...`
12:38:23	<Profpatsch>	instance Def a => Def ((->) e) where
12:38:36	<Profpatsch>	forgot the a
12:38:39	<Profpatsch>	but you get the idea
12:39:18	<Profpatsch>	jackdk: what’s the default applicative functor
12:39:22	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
12:39:50	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
12:40:17	<merijn>	sshine: I think the example of http/SSL options make sense as example when "a default" makes sense
12:40:27	<merijn>	90% of programmers want to "just make a connection"
12:40:41	<merijn>	And a config that "Just Works (TM)" can save a lot of time and be very convenient
12:41:06	<merijn>	And in general any form of "application config" where there is a sensible default that "just works" and gets overridden makes sense
12:41:08	<Profpatsch>	merijn: that’s why you usually have a function that wraps makeHttpConnection defaultOptions
12:42:01	×	asan quits (~asansanwa@150.129.181.196) (Quit: This computer has gone to sleep)
12:44:10	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Ping timeout: 246 seconds)
12:46:02	→	asansanwal joins (~asansanwa@150.129.181.196)
12:47:08	×	asansanwal quits (~asansanwa@150.129.181.196) (Client Quit)
12:48:48	→	coot joins (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
12:50:22	<Profpatsch>	Is there a recommended way to deal with sum types in contrafunctors?
12:50:46	<Profpatsch>	I have a simple contrafunctor newtype Enc from = Enc (from -> Encoding)
12:51:04	<Profpatsch>	And a bunch of combinators for constructing an Enc
12:51:40	<Profpatsch>	But sum :: (from -> Encoding) -> Enc from does not feel good to use
12:51:58	<Profpatsch>	Mostly because I don’t control Encoding (it’s from aeson)
12:52:35	×	adanwan quits (~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
12:53:04	→	adanwan joins (~adanwan@gateway/tor-sasl/adanwan)
12:55:05	→	loras joins (~loras@c-73-139-125-125.hsd1.fl.comcast.net)
12:59:18	<jumper149>	Profpatsch: How about `sum $ \case ...`
13:00:26	→	waleee joins (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
13:00:29	<jumper149>	Which should be the same as `Enc \case` I guess
13:02:02	<Profpatsch>	jumper149: yeah, I don’t like the way that you have to jump into the “internals”
13:02:22	<Profpatsch>	cause at some point you can just write a function `a -> Encoding` :P
13:02:59	<jumper149>	Are you looking for https://hackage.haskell.org/package/base-4.17.0.0/docs/Data-Functor-Contravariant.html#v:contramap ?
13:03:18	→	littlefinger joins (~littlefin@pool-74-102-98-242.nwrknj.fios.verizon.net)
13:04:29	→	jonathanx_ joins (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se)
13:04:54	×	jonathanx quits (~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Ping timeout: 264 seconds)
13:05:28	<Profpatsch>	jumper149: yeah that’s the main reason the newtype is there, so that you can use contramap. But maybe a bit weak as a use-case.
13:05:44	<[Leary]>	I'm not sure I understand the question, but I know you can write e.g. `Enc a -> Enc b -> Enc (Either a b)`. It's possible you can combine that with some prism magic to make it more general.
13:05:53	<Profpatsch>	esp if it doesn’t work very well for Enc Foo data Foo = Foo Int \| Bar Char
13:07:04	<Profpatsch>	[Leary]: I’m afraid the case match needs to be in there somewhere, otherwise you don’t get exhaustiveness checking.
13:07:15	<jumper149>	Not sure, why `Enc Foo` would be a problem here, if they both end up inside `Encoding`.
13:07:38	<Profpatsch>	jumper149: yeah but it would be great if you could use the existing Enc combinators
13:08:33	<jumper149>	What are they?
13:08:48	<Profpatsch>	stuff like map :: (Coercible k Text) => Enc v -> Enc (Map k v)
13:16:26	×	paddymahoney quits (~paddymaho@cpe9050ca207f83-cm9050ca207f80.cpe.net.cable.rogers.com) (Read error: Connection reset by peer)
13:16:34	<jumper149>	I cannot see the problem, sorry ^^
13:19:27	<Profpatsch>	maybe it’s a brain worm
13:20:43	×	causal quits (~user@50.35.83.177) (Quit: WeeChat 3.6)
13:21:26	×	tromp quits (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
13:24:17	→	nate1 joins (~nate@98.45.169.16)
13:24:43	→	abrar joins (~abrar@static-108-2-152-54.phlapa.fios.verizon.net)
13:28:59	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 252 seconds)
13:33:23	×	vglfr quits (~vglfr@145.224.100.100) (Ping timeout: 252 seconds)
13:33:49	<[Leary]>	Profpatsch: One way to make function newtypes more ergonomic is to give them a nice application operator. With that in hand, there's nothing to stop you from leveraging existing combinators to deal with the sum components, e.g. `Enc \case Foo a -> encInt $~ a; Bar c -> encChar $~ c`.
13:35:32	→	tromp joins (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
13:36:17	<Profpatsch>	[Leary]: oh hell, getting away from weird operators is my main reason why I’m wrapping aeson interfaces :P
13:38:27	→	thegeekinside joins (~thegeekin@189.180.97.156)
13:40:38	→	Sgeo joins (~Sgeo@user/sgeo)
13:48:16	→	shriekingnoise joins (~shrieking@186.137.167.202)
13:52:41	→	CiaoSen joins (~Jura@p200300c9570723002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
13:58:30	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 268 seconds)
13:58:50	→	finsternis joins (~X@23.226.237.192)
14:00:09	×	MajorBiscuit quits (~MajorBisc@145.94.164.10) (Ping timeout: 252 seconds)
14:01:03	→	MajorBiscuit joins (~MajorBisc@145.94.164.10)
14:02:56	→	vglfr joins (~vglfr@145.224.100.100)
14:03:12	×	[Leary] quits (~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
14:04:02	→	cfricke joins (~cfricke@user/cfricke)
14:05:53	→	stef204 joins (~stef204@user/stef204)
14:07:08	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 268 seconds)
14:09:07	<probie>	How do you define `($~)`? `($~) :: Coercible x (a -> b) => x -> a -> b` is not particularly ergonomic
14:15:28	→	elbear joins (~lucian@188.24.138.239)
14:20:08	→	[Leary] joins (~Leary]@user/Leary/x-0910699)
14:22:05	→	o-90 joins (~o-90@gateway/tor-sasl/o-90)
14:24:06	→	rockystone joins (~rocky@user/rockymarine)
14:25:50	×	o-90 quits (~o-90@gateway/tor-sasl/o-90) (Remote host closed the connection)
14:28:06	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 268 seconds)
14:30:05	<[Leary]>	probie: If I don't need to support more than one type at the same time then I wont think too hard; `newtype Foo = Foo{ ($~) :: A -> B }` works just fine.
14:34:31	→	jao joins (~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
14:35:53	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
14:36:40	<probie>	Right, I thought you wanted something for all newtyped functions (or at least several of them). That makes much more sense
14:39:27	→	jero98772 joins (~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c)
14:40:16	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
14:43:15	×	MajorBiscuit quits (~MajorBisc@145.94.164.10) (Quit: WeeChat 3.6)
14:45:48	→	DavidBinder joins (~DavidBind@134.2.10.18)
14:46:23	→	MajorBiscuit joins (~MajorBisc@145.94.164.10)
14:48:25	<jonathanx_>	So I spend a lot of time fixing up import statements that get caught by --pedantic. Is there a way to automatically remove unwanted imports? I'm on vscode/HLS
14:48:38	<jonathanx_>	(idk if I've asked this before, been a hectic week and I can't find it in the logs)
14:52:15	×	ChaiTRex quits (~ChaiTRex@user/chaitrex) (Ping timeout: 258 seconds)
14:52:18	<merijn>	Wait, since when is there a --pedantic? :o
14:52:48	<geekosaur>	looks to me like there is a "remove all redundant imports" code action
14:53:23	×	waleee quits (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 248 seconds)
14:54:06	→	ChaiTRex joins (~ChaiTRex@user/chaitrex)
14:54:10	<geekosaur>	jonathanx_, ^^
14:54:55	×	MajorBiscuit quits (~MajorBisc@145.94.164.10) (Quit: WeeChat 3.6)
14:55:13	→	MajorBiscuit joins (~MajorBisc@145.94.164.10)
14:55:53	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 252 seconds)
14:59:50	→	rockystone joins (~rocky@user/rockymarine)
15:01:22	×	infinity0 quits (~infinity0@pwned.gg) (Remote host closed the connection)
15:03:07	×	arahael quits (~arahael@210.185.98.153) (Ping timeout: 246 seconds)
15:03:49	×	dibblego quits (~dibblego@haskell/developer/dibblego) (Ping timeout: 246 seconds)
15:04:16	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 260 seconds)
15:08:09	→	dibblego joins (~dibblego@122-199-1-30.ip4.superloop.com)
15:08:09	×	dibblego quits (~dibblego@122-199-1-30.ip4.superloop.com) (Changing host)
15:08:09	→	dibblego joins (~dibblego@haskell/developer/dibblego)
15:08:19	→	LukeHoersten joins (~LukeHoers@user/lukehoersten)
15:09:29	→	infinity0 joins (~infinity0@pwned.gg)
15:11:34	→	elbear joins (~lucian@188.24.138.239)
15:12:38	→	gurkenglas joins (~gurkengla@p548ac72e.dip0.t-ipconnect.de)
15:16:05	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 268 seconds)
15:17:37	×	lortabac quits (~lortabac@2a01:e0a:541:b8f0:6bf9:1eed:edc8:e002) (Quit: WeeChat 2.8)
15:17:39	→	arahael joins (~arahael@59-102-114-6.tpgi.com.au)
15:18:21	×	kenran` quits (~user@user/kenran) (Remote host closed the connection)
15:19:05	→	telser joins (~quassel@user/telser)
15:19:05	×	telser quits (~quassel@user/telser) (Client Quit)
15:19:39	→	rockystone joins (~rocky@user/rockymarine)
15:21:33	×	merijn quits (~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
15:24:13	→	Midjak joins (~Midjak@82.66.147.146)
15:25:15	×	LukeHoersten quits (~LukeHoers@user/lukehoersten) (Quit: My MacBook has gone to sleep. ZZZzzz…)
15:29:11	→	mgd joins (~mgd@85.210.228.38)
15:29:51	→	LukeHoersten joins (~LukeHoers@user/lukehoersten)
15:32:50	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
15:36:10	<Profpatsch>	yes there is a code action
15:43:59	×	LukeHoersten quits (~LukeHoers@user/lukehoersten) (Quit: My MacBook has gone to sleep. ZZZzzz…)
15:44:01	×	tromp quits (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
15:45:26	→	nate1 joins (~nate@98.45.169.16)
15:45:37	→	asansanwal joins (~asansanwa@150.129.181.196)
15:45:45	×	asansanwal quits (~asansanwa@150.129.181.196) (Client Quit)
15:47:38	→	merijn joins (~merijn@86-86-29-250.fixed.kpn.net)
15:48:45	←	jakalx parts (~jakalx@base.jakalx.net) (Error from remote client)
15:55:53	→	jakalx joins (~jakalx@base.jakalx.net)
15:57:36	×	stef204 quits (~stef204@user/stef204) (Quit: WeeChat 3.7)
16:00:35	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Remote host closed the connection)
16:00:53	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
16:03:34	→	asansanwal joins (~asansanwa@150.129.181.196)
16:03:35	→	stef204 joins (~stef204@user/stef204)
16:05:13	×	asansanwal quits (~asansanwa@150.129.181.196) (Client Quit)
16:05:45	→	tromp joins (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
16:09:01	×	CiaoSen quits (~Jura@p200300c9570723002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
16:11:32	→	titibandit joins (~titibandi@xdsl-78-34-208-230.nc.de)
16:15:21	×	MajorBiscuit quits (~MajorBisc@145.94.164.10) (Quit: WeeChat 3.6)
16:19:35	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
16:19:59	×	littlefinger quits (~littlefin@pool-74-102-98-242.nwrknj.fios.verizon.net) (Ping timeout: 244 seconds)
16:21:28	×	stef204 quits (~stef204@user/stef204) (Quit: WeeChat 3.7)
16:23:36	×	tromp quits (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
16:24:48	×	zmt00 quits (~zmt00@user/zmt00) (Read error: Connection reset by peer)
16:25:19	→	vn36__ joins (~vn36@123.63.203.210)
16:28:14	→	zmt00 joins (~zmt00@user/zmt00)
16:30:17	→	tzh joins (~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
16:30:32	×	coot quits (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
16:31:39	×	teo quits (~teo@user/teo) (Ping timeout: 250 seconds)
16:33:10	→	tromp joins (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
16:35:59	→	stef204 joins (~stef204@user/stef204)
16:42:32	×	`2jt quits (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net) (Ping timeout: 268 seconds)
16:46:57	<dminuoso>	What I would like, is a minimal-depends. :S
16:47:17	<dminuoso>	Perhaps even as a default warning in cabal.
16:47:23	×	tromp quits (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
16:48:14	<dminuoso>	I think interface files already expose imported modules (since they are needed for tracking which typeclass instances are in scope), so the basic machinery is already there.
16:49:19	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 268 seconds)
16:53:15	→	VanceIsM7[m] joins (~vanceism7@2001:470:69fc:105::3ad)
16:53:35	×	vglfr quits (~vglfr@145.224.100.100) (Ping timeout: 252 seconds)
16:55:20	<EvanR>	merijn, Ivory is for generating whatever C code. While I can't seem to find the one specifically for crypto, the one that would generate timing uniform primitives in asm...
16:55:48	<EvanR>	(or something, I don't know if that makes sense)
16:57:03	×	kuribas quits (~user@ptr-17d51eoxcqlpawtoc5a.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 27.1))
16:58:13	→	asansanwal joins (~asansanwa@150.129.181.196)
16:58:15	→	coot joins (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
17:00:50	→	econo joins (uid147250@user/econo)
17:01:47	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Remote host closed the connection)
17:02:04	→	hashn3rd joins (~hashn3rd@ip72-221-42-80.ks.ks.cox.net)
17:03:27	×	mgd quits (~mgd@85.210.228.38) (Quit: Client closed)
17:07:11	×	raehik1 quits (~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 250 seconds)
17:07:12	→	Tuplanolla joins (~Tuplanoll@91-159-69-174.elisa-laajakaista.fi)
17:08:41	×	cfricke quits (~cfricke@user/cfricke) (Quit: WeeChat 3.7)
17:11:08	×	hashn3rd quits (~hashn3rd@ip72-221-42-80.ks.ks.cox.net) (Ping timeout: 244 seconds)
17:11:21	×	pavonia quits (~user@user/siracusa) (Quit: Bye!)
17:16:41	→	vglfr joins (~vglfr@145.224.100.100)
17:18:56	<Guillaum[m]>	Is there a way to attach arbitrary data to an object info table. A bit similar to the data attached in info table and which can be queried by https://hackage.haskell.org/package/base-4.17.0.0/docs/GHC-Stack-CCS.html#v:whereFrom, but I would like to attach arbitrary data.
17:19:34	<Guillaum[m]>	Use case: I'd like to add debuging informations about the creation context of an object, but I don't want to be intrusive in my AST.
17:19:36	×	zmt00 quits (~zmt00@user/zmt00) (Ping timeout: 260 seconds)
17:21:41	→	zmt00 joins (~zmt00@user/zmt00)
17:25:26	×	juri_ quits (~juri@84-19-175-179.pool.ovpn.com) (Ping timeout: 260 seconds)
17:25:56	→	`2jt joins (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net)
17:30:41	×	beteigeuze quits (~Thunderbi@2001:8a0:61b5:6101:f0c:e4e3:bfdc:91df) (Ping timeout: 260 seconds)
17:34:49	<geekosaur>	https://downloads.haskell.org/ghc/9.4.2/docs/users_guide/extending_ghc.html#source-annotations ?
17:35:20	<geekosaur>	otherwise I think not; the info table's format is fixed by how GC uses it
17:35:46	→	EsoAlgo joins (~EsoAlgo@129.146.136.145)
17:36:47	<geekosaur>	(I pointed to 9.4 but I think they go back to 7.0 and are certainly in 8.x)
17:37:35	×	gmg quits (~user@user/gehmehgeh) (Remote host closed the connection)
17:37:44	<geekosaur>	if you really need to alter the info table you'll need to ask in #ghc
17:38:18	→	spaced joins (uid572193@user/spaced)
17:38:29	→	gmg joins (~user@user/gehmehgeh)
17:39:00	→	natechan joins (~nate@98.45.169.16)
17:42:14	<jumper149>	dminuoso: There is `-Wunused-packages` for GHC.
17:44:05	×	asansanwal quits (~asansanwa@150.129.181.196) (Quit: This computer has gone to sleep)
17:44:09	<Guillaum[m]>	geekosaur: thank you.
17:46:30	×	mbuf quits (~Shakthi@49.205.87.29) (Quit: Leaving)
17:48:35	×	DavidBinder quits (~DavidBind@134.2.10.18) (Quit: Leaving)
17:52:01	<EvanR>	> text "ab\tcd"
17:52:02	<lambdabot>	ab cd
17:52:14	→	juri_ joins (~juri@79.140.121.220)
17:52:33	<EvanR>	which god decides how many spaces a tab is here
17:56:03	→	littlefinger joins (~littlefin@pool-74-102-98-242.nwrknj.fios.verizon.net)
17:57:01	×	juri_ quits (~juri@79.140.121.220) (Ping timeout: 252 seconds)
17:57:55	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 248 seconds)
17:58:04	→	juri_ joins (~juri@84-19-175-179.pool.ovpn.com)
17:58:32	<EvanR>	hopefully not Loki
17:59:58	→	werneta joins (~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
18:08:03	×	crns quits (~netcrns@user/crns) (Ping timeout: 248 seconds)
18:09:20	→	crns joins (~netcrns@p4ff5e713.dip0.t-ipconnect.de)
18:09:20	×	crns quits (~netcrns@p4ff5e713.dip0.t-ipconnect.de) (Changing host)
18:09:20	→	crns joins (~netcrns@user/crns)
18:09:53	→	zkSNOOP joins (~username@ptr-21zvp7p1ecvdx6mr7hf.18120a2.ip6.access.telenet.be)
18:13:19	→	Topsi joins (~Topsi@dyndsl-095-033-095-014.ewe-ip-backbone.de)
18:14:51	→	tromp joins (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
18:16:03	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Remote host closed the connection)
18:16:15	×	razetime quits (~quassel@117.193.4.27) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
18:18:04	×	loras quits (~loras@c-73-139-125-125.hsd1.fl.comcast.net) (Ping timeout: 246 seconds)
18:18:10	→	elbear joins (~lucian@188.24.138.239)
18:19:21	<jonathanx_>	I'm experimenting with an effect lib that comes with a GHC plugin to disambiguate stuff. Using the plugin, ghc compiles fine, but HLS still thinks that the build is broken. How do I make HLS recognize ghc plugins?
18:22:56	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 268 seconds)
18:25:37	×	jbayardo quits (~jbayardo@20.83.116.49) (Ping timeout: 252 seconds)
18:25:39	<geekosaur>	that's probably a question for #haskell-language-server
18:27:16	×	Alex_test quits (~al_test@178.34.163.70) (Ping timeout: 260 seconds)
18:28:26	×	AlexZenon quits (~alzenon@178.34.163.70) (Ping timeout: 260 seconds)
18:29:06	→	freeside joins (~mengwong@103.252.202.193)
18:29:30	<monochrom>	EvanR: Pessimistically I'm pretty sure it's Loki or someone isomorphic to Loki. Look at how everyone disagrees on the number, and on top of that, also voices that propose that there should be no mapping at all. Right, I have read a web page stating both "tab is not any number of spaces" and "tab does not even mean the next designated column, tab is just tab".
18:30:40	<EvanR>	this calls for category theory
18:30:53	→	elbear joins (~lucian@188.24.138.239)
18:31:39	→	Alex_test joins (~al_test@178.34.163.70)
18:31:51	<darkling>	Or just a proper standard that unifies all the existing standards.
18:32:02	<darkling>	It wouldn't have to be very long. Just the parts that everyone can agree on.
18:32:09	<geekosaur>	hollow laugh
18:32:11	<darkling>	"Tabs are." possibly
18:32:23	→	AlexZenon joins (~alzenon@178.34.163.70)
18:32:55	×	raym quits (~aritra@user/raym) (Ping timeout: 268 seconds)
18:32:55	geekosaur	notes that an old typewriter he had had fixed tabs. ½ inch
18:33:15	<[exa]>	pls could tabs finally start doing actual tabulation not just "maybe 8 spaces yolo"
18:33:35	<monochrom>	Once upon a time, programmers gathered together and were like "let's collaborate on a super-project that develops the ultimate program, it will be so powerful that it will rival God". God cannot let that happen, so God simply said, "let every programmer disagrees on what tab means", and that suffices to dissolve the project. >:)
18:33:36	<geekosaur>	if you were lucky that was 5 characters
18:33:37	→	cdimitroulas joins (~cdimitrou@17.232.83.98)
18:33:57	<geekosaur>	the Tab of Babel
18:34:00	×	sammelweis quits (~quassel@2601:401:8200:2d4c:bd9:d04c:7f69:eb10) (Ping timeout: 264 seconds)
18:34:06	<darkling>	The Tabulator of Babel?
18:34:09	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 268 seconds)
18:34:26	→	jbayardo joins (~jbayardo@20.83.116.49)
18:35:09	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 250 seconds)
18:36:45	<EvanR>	sadly, the question remains. If you print out tabs to stdio where does the spacing come from
18:37:02	<jonathanx_>	geekosaur: thanks, I'll check there
18:37:06	<monochrom>	The terminal.
18:37:29	<geekosaur>	the terminal emulator
18:37:35	<geekosaur>	which may or may not be sane
18:37:40	<geekosaur>	fsvo sane
18:37:50	<EvanR>	the terminal, it's not the OS, the c library, the runtime system, ...
18:37:53	<monochrom>	Hell, the terminal doesn't insert spaces either. It just works in terms of screen positions.
18:38:00	<darkling>	"What is it, doctor?" "I'm afraid it's terminal."
18:38:22	<monochrom>	Right, except for the terminal, everything else preserves the '\t' character as is.
18:38:48	<[exa]>	literal indentation heaven ^
18:39:22	<monochrom>	And the terminal just plays with screen coordinates. In fact, if it retains memory (for copy-paste), it remembers the '\t' too, no change.
18:39:24	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 264 seconds)
18:39:37	<EvanR>	cool so I can adjust the tabs globally
18:39:45	<EvanR>	except within vim
18:40:08	<geekosaur>	except that prpograms expect to be able to interpret tabs. and $SOMEONE help you if they disagree with your terminal
18:40:25	<EvanR>	what kind of programs
18:40:43	<monochrom>	The unix "expand" utility? >:)
18:40:47	<geekosaur>	editors, indentation-aware compilers/interpreters, etc.
18:41:15	<EvanR>	indentation aware doesn't mean... "number of tabs" ? xD
18:41:34	<monochrom>	Next April 1st, "expand" converts tabs to a monkey face emoji >:)
18:41:45	<EvanR>	looking up expand
18:42:03	<monochrom>	Oh it normal just convert tabs to spaces.
18:42:11	<monochrom>	s/normal/normally/
18:42:18	<geekosaur>	someone apparently hasn't dealt with either haskell or python layout in the presence of tabs
18:42:38	<monochrom>	Well, expand predates those...
18:42:44	<[exa]>	hm guys lemme throw together a very quick idea
18:42:51	<geekosaur>	you get unpleasant surprises if their notion of how tabs work differs from youtr terminal. or your editor
18:42:55	<EvanR>	I read that there's a rule for figuring out layout when tabs are mixed with spaces, but it doesn't involves "tabs = 8 spaces" or such xD
18:43:22	<monochrom>	Or at least the creators of expand had not heard of layout-sensitive languages. They were working with C etc.
18:43:27	<EvanR>	how would haskell know what your editor is set to
18:43:42	<geekosaur>	that's kinda the point
18:43:44	<geekosaur>	it doesn't
18:43:57	<geekosaur>	it's on you to make sure they agree
18:44:34	<monochrom>	Yeah the rule is "go back to what terminals and typewriters actually do, tab expands to enough spaces for the next tabstop, rather than always a constant number of spaces".
18:45:08	<EvanR>	ok, and that's why expand makes no sense
18:45:48	<tdammers>	problem is that terminals and typewriters don't agree on where the next tabstop is
18:46:07	<monochrom>	For the most part I'm OK with the wrong wording "tab is n spaces" whenever all participants knows it's an abbreviation for the correct but long wording.
18:46:08	→	vn36__ joins (~vn36@123.63.203.210)
18:46:16	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
18:46:55	<EvanR>	is that "shortcut" language what is actually meant by the expand manual? xD
18:47:02	<monochrom>	I mean, on other topics there are even worse wrong wordings to pick on, if you want to pick a fight.
18:47:07	<EvanR>	or does it literally replace \t with n spaces
18:47:21	<geekosaur>	EvanR, it at least used to mean that shortcut
18:47:30	<geekosaur>	I haven't checked since the 1980s…
18:47:49	<darkling>	tdammers: The last mechanical typewriter I used had settable tab stops, but they were true "move to the next tab column" tabs, not some fixed number of spaces.
18:48:06	<EvanR>	oh yeah I remember that
18:48:11	<EvanR>	tabstops were cool
18:48:15	<monochrom>	I think "have tabs N characters apart" is close to the right wording, no?
18:48:28	→	rockystone joins (~rocky@user/rockymarine)
18:48:31	<tdammers>	darkling: well yeah, and as long as the Tab key only drives the local, mechanically connected typing apparatus, it's fine. The trouble started when they started making teletypes.
18:48:52	<monochrom>	I mean if you s/tabs/tabstops/ then it is unambiguously right.
18:49:20	<monochrom>	And it is not literally "N spaces".
18:49:58	<EvanR>	yeah, so the key mystery revealed was that tab is not a character but a location on the page
18:50:01	×	wrengr quits (~wrengr@201.59.83.34.bc.googleusercontent.com) (Remote host closed the connection)
18:50:14	<EvanR>	which contradicts everything everyone knows... about ASCII
18:50:14	→	codaraxis___ joins (~codaraxis@user/codaraxis)
18:50:38	→	ft joins (~ft@p3e9bc57b.dip0.t-ipconnect.de)
18:50:39	<darkling>	And what does LF do? :)
18:51:11	<EvanR>	carriage return obv
18:51:28	<EvanR>	and CR moves the page up xD
18:51:36	×	adanwan quits (~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
18:51:39	<darkling>	Hey, I was stirring with that spoon!
18:52:07	<monochrom>	Well you need a wire format that accomodates both "actual data for humans" and "metadata/instructions for the machine".
18:52:13	→	adanwan joins (~adanwan@gateway/tor-sasl/adanwan)
18:52:34	<EvanR>	that sounds like a bad sequel to the matrix
18:52:56	<darkling>	ROFL
18:53:00	<monochrom>	This is why tab and LF and etc are "control characters". Meaning, for the machine to move to locations, not for the ABC123 for humans.
18:53:04	×	stef204 quits (~stef204@user/stef204) (Quit: WeeChat 3.7)
18:53:24	<darkling>	It's just that they've undergone semantic drift in the lsat 50 years.
18:53:51	×	codaraxis__ quits (~codaraxis@user/codaraxis) (Ping timeout: 252 seconds)
18:54:14	<monochrom>	But then, once you have both in the same stream/wire, the same mentality as Lisp's "program and data can be unified" is the next logical conclusion slippery slope.
18:54:23	×	Tuplanolla quits (~Tuplanoll@91-159-69-174.elisa-laajakaista.fi) (Ping timeout: 268 seconds)
18:55:05	→	wrengr joins (~wrengr@201.59.83.34.bc.googleusercontent.com)
18:56:06	<EvanR>	ok so operational semantics. Category theory would be useless, nevermind
18:57:20	×	cdimitroulas quits (~cdimitrou@17.232.83.98) (Quit: Connection closed)
18:58:02	→	raym joins (~aritra@user/raym)
18:59:02	<EvanR>	I was reading that when ascii was being invented (some time in the 5th century?) there were other options like shift between text mode and control mode, but not shifting modes was the decision and the rest is history
19:00:21	<EvanR>	imagine if plain text files had to shift modes xD (ok, now we have unicode)
19:01:24	→	freeside joins (~mengwong@103.252.202.193)
19:05:24	×	gmg quits (~user@user/gehmehgeh) (Quit: Leaving)
19:06:21	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 260 seconds)
19:06:22	<geekosaur>	uh, you do know about SI and SO?
19:06:43	<geekosaur>	> ord '\SI'
19:06:44	<lambdabot>	15
19:07:35	<geekosaur>	that said, earlier character sets used shift codes a lot more (BAUDOT, RADIX32, etc.)
19:08:48	→	Tuplanolla joins (~Tuplanoll@91-159-69-34.elisa-laajakaista.fi)
19:09:44	<EvanR>	yeah, maybe it was that any control would be unavailable in text mode
19:10:15	<EvanR>	the text would be out of control
19:10:40	<vn36__>	hahaha
19:13:46	×	coot quits (~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
19:17:31	→	arcadewise joins (52968ed80d@2604:bf00:561:2000::3df)
19:19:15	<arcadewise>	Hi! I'm trying to apply a function to a value i recieved from io, without having to do it on a seprate line, is there a way to do that? currently i get the value like this `s1 <- prompt "First sentence: "`, but ideally i could call `scntNum` on the result before i store it in `s1`
19:20:03	×	Kaiepi quits (~Kaiepi@142.68.249.28) (Read error: Connection reset by peer)
19:20:07	<EvanR>	fmap :: (a -> b) -> IO a -> IO b
19:20:16	<EvanR>	IO post processor
19:20:27	→	Kaiepi joins (~Kaiepi@142.68.249.28)
19:21:08	<dminuoso>	Also as its infix variant <$>
19:21:14	<EvanR>	s1 <- fmap scntNum (prompt "First sentence: ")
19:21:15	<dminuoso>	Or with flipped arguments <&>
19:21:15	<EvanR>	or
19:21:26	<EvanR>	s1 <- scntNum <$> prompt "First sentence: "
19:21:54	<arcadewise>	thank you so much!
19:24:45	<EvanR>	if foldr is a catamorphism, is there a fancy word for foldl or foldl'
19:25:02	←	jakalx parts (~jakalx@base.jakalx.net) (Error from remote client)
19:25:07	<dminuoso>	loop?
19:25:12	<dminuoso>	:S
19:26:17	<dminuoso>	But seriously, isnt foldl a catamorphism too?
19:26:24	<dminuoso>	It's just a into a different algebra
19:30:47	<EvanR>	:thonk:
19:31:42	×	jpds quits (~jpds@gateway/tor-sasl/jpds) (Ping timeout: 258 seconds)
19:32:46	→	jakalx joins (~jakalx@base.jakalx.net)
19:33:06	→	jpds joins (~jpds@gateway/tor-sasl/jpds)
19:33:22	→	zebrag joins (~chris@user/zebrag)
19:35:27	→	freeside joins (~mengwong@103.252.202.193)
19:36:09	<dminuoso>	Okay so messing a lot with flatparse made me realize, that parsing UTF8 data is.. quite annoying . :S
19:38:06	×	Kaiepi quits (~Kaiepi@142.68.249.28) (Remote host closed the connection)
19:38:41	→	Kaiepi joins (~Kaiepi@142.68.249.28)
19:39:43	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 250 seconds)
19:40:08	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 268 seconds)
19:42:11	→	liz joins (~liz@cpc84585-newc17-2-0-cust60.16-2.cable.virginm.net)
19:43:36	×	Kaiepi quits (~Kaiepi@142.68.249.28) (Ping timeout: 264 seconds)
19:45:57	→	TheCreatorOfCrea joins (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de)
19:49:35	×	elbear quits (~lucian@188.24.138.239) (Ping timeout: 252 seconds)
19:49:46	<TheCreatorOfCrea>	Hello. :) … I noticde that there a separate type syntax and even kind syntax in Haskell. I just read about GADT and data kinds and kind signatures and such, and it seems to approaches functionality duplication with “reqular” syntax. … I know there’s languages with more powerful type systems, so… Is there an alternative approach of just
19:49:47	<TheCreatorOfCrea>	making type declarations in regular Haskell, so only one syntax is needed?
19:50:26	<dminuoso>	TheCreatorOfCrea: Actually, the kind and type system has long been merged into a singular system.
19:50:32	→	pavonia joins (~user@user/siracusa)
19:50:41	×	fserucas quits (~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7) (Ping timeout: 260 seconds)
19:51:01	<TheCreatorOfCrea>	dminuoso: Hmm, that sounds great. Can you point me in the right direction for reading about it?
19:51:08	<EvanR>	Maybe you are being tempted by Dependent Types, where kinds are just types, and values work as is at the type level
19:51:13	<geekosaur>	look for TypeInType
19:51:20	<TheCreatorOfCrea>	dminuoso: (I have no idea what to enter into the search engine for this.)
19:51:59	<geekosaur>	also, you may be interested in https://en.wikipedia.org/wiki/%CE%A9mega
19:52:03	<dminuoso>	TheCreatorOfCrea: The extension was called TypeInType, which over the course of the versions has become redundant.
19:52:14	<dminuoso>	THat is, TypeInType is in effect whether you enable it or not.
19:52:22	<dminuoso>	In short, `Type :: Type` holds.
19:52:29	<geekosaur>	where every level works exactly the same way: value level, type level, kind level, sort level, and up infinitely
19:52:45	<dminuoso>	Where `Type` is a more modern and better name for `*`
19:52:57	<EvanR>	values work at the type level now?
19:53:20	<EvanR>	or that still requires DataKinds
19:53:26	<c_wraith>	no, that's the one set that wasn't collapsed.
19:53:36	<c_wraith>	DataKinds doesn't give you arbitrary values, just constructors
19:53:39	<geekosaur>	no, I was talking about Ωmega
19:53:46	<EvanR>	oh
19:54:21	<TheCreatorOfCrea>	dminuoso: Ok… does this allow you to define types as just regular functions, without the separate `::` syntax? Or does the `::` just allow you to write function-like syntax behind it. (I’m admittedly out of my depth here, so bear with my vague questions and just assume what you think makes the most sense. :)
19:54:42	<dminuoso>	TheCreatorOfCrea: No, it just collapses everything above type into just types.
19:54:51	<geekosaur>	haskell does not yet have dependent types, or type level functions, or other fancies
19:54:59	<dminuoso>	TheCreatorOfCrea: before expressions had types, types had kinds, kinds had sorts, and above that everything was just an infinite singletons tack in haskell at least.
19:55:12	<TheCreatorOfCrea>	dminuoso: Ah, so if I understan correctly, it does away with the kind syntax right?
19:55:26	<dminuoso>	TheCreatorOfCrea: well the kind syntax was always the same as the type syntax
19:55:35	<dminuoso>	TheCreatorOfCrea: what changes is that kinds and types are the same thing now.
19:55:51	<dminuoso>	Or they exist in the same universe, rather.
19:56:30	<TheCreatorOfCrea>	geekosaur: But it sounds like that is a goal, right? Because that would make me like the direction Haskell’s taking much more. :-) (Provided they manage to make it easy to actually use. :)
19:56:45	<geekosaur>	that last is quite a sticking point though
19:56:59	<TheCreatorOfCrea>	dminuoso: Sorts? wow. :D takes step back
19:57:11	<geekosaur>	and iirc typechecking of general type level functions is undecidable
19:57:11	<EvanR>	if haskell makes dependent types easy to use I'll eat my hat
19:57:28	<geekosaur>	so you'd lose type inference and other nice things
19:57:30	<TheCreatorOfCrea>	dminuoso: True, the syntax was the same. But yeah, that sounds really great.
19:57:31	<dolio>	Instead of harder to use than normal?
19:57:38	<geekosaur>	maybe it's just inference that's undecidable
19:57:45	<EvanR>	exactly
19:58:04	<dminuoso>	TheCreatorOfCrea: Well, in truth its actually very undesirable in general.
19:58:25	<TheCreatorOfCrea>	geekosaur: about undecidability: Yeah, I thought there might be a conceptual hindrance like that there. :)
19:58:57	<geekosaur>	and I'm not sure you can usefully infer dependent types either
19:58:58	<TheCreatorOfCrea>	EvanR: Which type of had shall I serve you then, good sir? opens fancy hat shop site
19:59:08	<dminuoso>	TheCreatorOfCrea: It violates logical consistencies in the type system, which would not happen if you have an infinite tower of types. But it turns out that Haskell already is inconsistent, so making that change doesnt make this worse.
19:59:26	<geekosaur>	the whole point of them being providing proofs of things that can't otherwise be proven
20:00:55	<EvanR>	when programming in idris, even though you can't freewheel put no type signatures anywhere, writing code haskell style with top level signatures often does work, with inference figuring out the rest of the function
20:01:21	<dminuoso>	TheCreatorOfCrea: The expression for the alternative is a stratified universe (hierarchy), where you have an infinite tower of such universes. Agda is an example of a language that has this.
20:02:00	<TheCreatorOfCrea>	dolio: I’m torn about “harder to use”. With time, I found that it only demands you actually make decisions that need to be made to obtain reliable yet fast code, which is what I like; but it was merely the way it was communicated, that was quite sub-optimal. So I think it’s like quantum physics: It’s easy once you can wrap your head
20:02:01	<TheCreatorOfCrea>	around it. But it takes somebody to wrap his head around it first, before he can explain it to you at the Feyman “freshman level”. And we’re not really there yet. :)
20:02:17	<c_wraith>	it's worth pointing out that inconsistent is not the same as unsafe. Inconsistency can be made safe by inserting runtime checks.
20:02:34	<EvanR>	"quantum physics is easy once you get your head around it" --not feynmann
20:02:40	<c_wraith>	and all the ways haskell is inconsistent does so. Sort of incidentally, but it works out!
20:03:00	<geekosaur>	everyone keeps forgetting the "think really hard" part…
20:03:16	<c_wraith>	On the other hand, Haskell has lots of unsafe functions that really are unsafe...
20:03:26	<dolio>	I'm not saying dependent types are hard to use. I'm saying the things people do in GHC to fake them are much worse than using a language with dependent types.
20:03:31	<dminuoso>	c_wraith: Heh, was about to say that GHC does not have runtime checks for infinite loops.. until I realized it does!
20:03:47	<geekosaur>	only for the easy to detect ones
20:04:02	<EvanR>	compile time checks for infinite loops would be better
20:04:07	<c_wraith>	Well, and it never executes code that depends on the infinite loop!
20:04:08	<TheCreatorOfCrea>	dminuoso: What did you refer to, when you said it was undesirable?
20:04:52	<dminuoso>	TheCreatorOfCrea: See Girard's paradox
20:05:01	<c_wraith>	like... (case (let x = x in x) of () -> "hello") - I'd argue this checks for an infinite loop, in some sense.
20:05:09	<dminuoso>	You can roughly think of this as Russels paradox in the type system.
20:05:19	→	Kaiepi joins (~Kaiepi@142.68.249.28)
20:08:09	<TheCreatorOfCrea>	EvanR: My thought too: As long as the compiler can tell me whether it cannot infer a type, and ask me to either provide or remove it, I’m fine with that. I’m no fan of implicitisms anyway. The many levels of implicit things you have to keep in mind is the biggest hindrance to using Haskell for me. (I’m the type who can’t stand the
20:08:10	<TheCreatorOfCrea>	non-descriptive identifiers of mathematics though. To me they just look like deliberate obfuscation and gatekeeping. But I am willing to chalk that up to just different ways of thinking. )
20:08:45	<EvanR>	the difference between math type inference and haskell type inference is that it's reliable when it works
20:09:15	<EvanR>	it's not going to infer something totally wrong
20:09:34	<EvanR>	the whole principal type thing
20:09:39	<c_wraith>	I'd argue that non-meaningful identifiers are often more appropriate in Haskell than in math. It's common to write code in haskell that's so generic that there is no meaningful name for something.
20:10:04	<dminuoso>	Monad being one such example :>
20:10:07	<TheCreatorOfCrea>	c_wraith: about runtime checks: I’m using Haskell partially because it is able to move those checks to compile time though. :) But yeah, doing runtime checks it what Java does, AFAIK, and it’s not _that_ slow nowadays. I definitely prefer my life support machine to have runtime checks and be a little bit more expensive due to it. ;)
20:10:18	<c_wraith>	is theFirstArgumentToThisFunction more meaningful than x?
20:10:55	→	freeside joins (~mengwong@103.252.202.193)
20:11:11	×	takuan quits (~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
20:11:33	<EvanR>	the main problem with runtime checks is when they finally happen...
20:11:47	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 250 seconds)
20:11:50	<c_wraith>	I agree that it's reasonable to view type system inconsistencies as potential performance issues.
20:11:57	<dminuoso>	EvanR: Be honest. When was the last time you used `evaluate`?
20:13:12	<EvanR>	objection. relevance!
20:14:05	<EvanR>	TheCreatorOfCrea, also, on invisible type inference, it's not invisible. You can always query ghci for the type of something
20:14:19	<TheCreatorOfCrea>	c_wraith: Yes, you are right. In case of truly generic code, you cannot give the identifiers non-generic names. The trouble with that was, that in practice, for example, I hardly ever see the point of such generic things. E.g. yes, the concept of the monoid is nice. And I certainly wrote code that could implement the monoid class. But… why? All
20:14:19	<TheCreatorOfCrea>	it gives me is that I can now use operators that obfuscate what my code does even more. :)
20:14:22	→	rockystone joins (~rocky@user/rockymarine)
20:14:59	<EvanR>	abstraction is supposed to be for the opposite of obfuscation
20:15:11	<EvanR>	to draw attention only to the important parts of what's going on
20:15:22	<EvanR>	in the case of monoids, combining stuff
20:15:26	<c_wraith>	what it gives you is the ability to use your type in places that abstract over all Monoid instances
20:15:32	<dminuoso>	TheCreatorOfCrea: the main usefulness of many classes like monoid isnt as much using `(<>)` as opposed to say `(++)`, but its for when you write code that is polymorphic over any monoid, where the caller can decide what they want.
20:15:48	<TheCreatorOfCrea>	dminuoso: At least `evaluate` is not the thing that it is in languages like JS. XD
20:15:58	<dminuoso>	Or when you want to emphasize laws, such that you can on the spot use the laws to associate things around, or add a mempty in some spot.
20:16:37	×	zer0bitz quits (~zer0bitz@2001:2003:f748:2000:3d5a:c60:7a1a:1513) (Read error: Connection reset by peer)
20:16:46	<c_wraith>	:t M.alterF
20:16:47	<lambdabot>	(Functor f, Ord k) => (Maybe a -> f (Maybe a)) -> k -> M.Map k a -> f (M.Map k a)
20:16:59	<TheCreatorOfCrea>	EvanR: You have to query it though. BTW: Is there a code editor that just always shows this, without needing to press any shortcun even? Purely due to where the cursor currently is?
20:16:59	<EvanR>	I should say proper abstraction, if your monoid generic code is really generic, it doesn't matter what monoid is used. Of course you see that messed up a lot in clojure, java, which always peeks around abstractions
20:17:29	<c_wraith>	I love how powerful that function is. it can do about half the things Data.Map supports, based on your choice if Functor
20:17:29	→	vn36__ joins (~vn36@123.63.203.210)
20:17:58	<EvanR>	I'm not the editor fu guy, sorry
20:18:22	<c_wraith>	and there are a lot of cases where you can create a new Functor to add new functionality
20:18:52	<c_wraith>	Monoid is a bit less general, but it's still really useful
20:19:09	<dminuoso>	c_wraith: By the way, I recall from a previous discussion you mentioned (a,) as an interesting functor for alterF, and Ive begun to understand why.
20:19:13	<TheCreatorOfCrea>	EvanR: Hmm, humans don’t do well with abstraction though. E.g. in 3D games you easily get lost if every wall texture is abstracted to look the same. It’s the same trap every novice coder falls in, to generalize everything until he ends up with a one super-generic thing like “evaluate”, that just takes a whole new language as its parameter
20:19:14	<TheCreatorOfCrea>	again. ;)
20:19:25	<EvanR>	see we're talking past each other again
20:19:31	→	talismanick joins (~talismani@96-67-197-217-static.hfc.comcastbusiness.net)
20:19:35	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 250 seconds)
20:19:43	<EvanR>	I say abstraction is structure, you say abstraction is lack of structure
20:20:01	<c_wraith>	dminuoso: ah, cool. I like returning a computed result and the updated map at the same time!
20:20:28	<EvanR>	`eval' is a good example of the second kind
20:20:42	<TheCreatorOfCrea>	dminuoso: Thanks for that point about monoids. It was useful to repeat that, and I agree. I’ll have to ponder it though, as it still feels uneasy. :)
20:21:33	<talismanick>	if I define `f .> v = liftM2 f v`, what infix{r,l,} declaration makes do what I want in `(<>) .> fst (drop 1 . snd)`?
20:21:42	<EvanR>	visualizations of structure is another topic though
20:22:09	<talismanick>	(where the alternative was the working-but-ugly-looking `liftM2 (<>) fst (drop 1 . snd)`)
20:22:13	<dminuoso>	TheCreatorOfCrea: That notion extends very well into monad, by the way. To a beginner, the term `Monad` is a red herring because it abstracts over something not necessarily relevant to the beginner themself, much like Monoid abstracts over say Integer addition.
20:22:29	<talismanick>	makes .> do what I want*
20:22:31	<c_wraith>	talismanick: it's the only infix operator in that expression. it doesn't matter.
20:23:01	<c_wraith>	well. the only infix operator at that level
20:23:11	<talismanick>	Then why is it giving me an error?
20:23:24	<c_wraith>	we'd need more context to know.
20:23:32	<dminuoso>	TheCreatorOfCrea: THere's a kind of symmetry in polymorphic things: When something has a `Monad` constraint it doesnt mean you have to know what Monad abstracts over to use it, it just means "As long as your type T has Monad T, you can use it at at that type". Its rather the author of that Monad polymorphic definition that has/wants to understand it.
20:23:48	<dminuoso>	(Replace `Monad` with an arbitrary typeclass)
20:24:13	<TheCreatorOfCrea>	EvanR: Ah, okay, if abstraction is structure by your definition, I’d agree. I implied abstraction is generalization to a more general pattern, as that was the definition I learned. But maybe those can be the same idea, if we simply think that there can be /many/ general patterns, which add structure again.
20:24:33	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Remote host closed the connection)
20:24:43	<dminuoso>	The caller has the obligation/freedom to pick a particular type, but the implementor is writing over an unknown choice, so their implementation has to work with any possible type the user might choose. There is a kind of duality here.
20:24:55	<talismanick>	nvm, fixed it
20:24:56	<EvanR>	by melting away the unnecessary parts to leave the important structure, you could say that is a kind of generalization too
20:25:06	→	waleee joins (~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340)
20:25:25	<EvanR>	since it leaves the door open for other things to act as drop in replacements
20:25:41	<EvanR>	different implementations, same interface
20:25:45	×	jargon quits (~jargon@184.101.208.112) (Remote host closed the connection)
20:26:12	<EvanR>	but eval, taking a string and "run it", leaves you with very little to go on
20:26:48	<EvanR>	too much generalization if anything
20:26:54	<dminuoso>	The two benefits of `Monad` is just avoiding needlessly naming things with the same shape `mapMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b`, `concatMap :: [a] -> (a -> [b]) -> [b]`, `ioThen :: IO a -> (a -> IO b) -> IO b`, which I guess is just for convenience (remembering fewer names), and allowing folks to write generically over any such thing. The laws themselves are unrelated to the typeclass
20:26:56	<dminuoso>	(as each individual such function already has these laws, whether a typeclass exists or not)
20:27:02	<dminuoso>	(Or equivalently with monoid, or any other typeclass)
20:27:55	<TheCreatorOfCrea>	dminuoso: I used to be at a level where I understood “A monad is just a monoid in the category of endofunctors! What’s the problem!” and it actually was easy to me! (Thanks to Bartosz Milewski’s YouTube series on category theory, which is really good.) But I forgot it all again. :( … But monads are a great example, because the main
20:27:55	<TheCreatorOfCrea>	problem in that they are badly explained. E.g. what do we expect when we start our explanation by telling novices that it is considered a big riddle and hard to understand? It’s not. It’s just an interface for things with certain rules.
20:28:43	<dminuoso>	TheCreatorOfCrea: The monad problem is as if you were introducing monoids to students in first class before talking about things like adding numbers. students get confused, dont know what you are talking about and why its a useful thing.
20:29:13	<EvanR>	that's the worst explanation of a Monad ever xD
20:29:21	×	wonko quits (~wjc@2a0e:1c80:2:0:45:15:19:130) (Ping timeout: 268 seconds)
20:29:41	<Rembane>	EvanR: Challenge accepted! :D
20:29:51	<dminuoso>	I think the single most important and best article on `Monad` is https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/
20:30:03	<talismanick>	Monoids aren't hard to explain if you can explain what a free group is (and substitute monoid for group)
20:30:07	→	chomwitt joins (~chomwitt@2a02:587:dc1e:5e00:e9e7:bb14:f272:9a4b)
20:30:15	<c_wraith>	I've said it before and I'll say it again: I finally figured out what the heck is going on with Monad when I started learning Parsec and was like "wait, do notation just works!"
20:30:15	→	rockystone joins (~rocky@user/rockymarine)
20:30:26	<talismanick>	then, "endofunctor" just means m(m a) = m a, but you also can't pull a back out
20:30:28	<Rembane>	talismanick: What's a free group?
20:30:39	<dminuoso>	@remember talismanick Monoids aren't hard to explain if you can explain what a free group is (and substitute monoid for group)
20:30:39	<lambdabot>	Done.
20:31:06	<talismanick>	Rembane: so, you could build the integers using {1} and adding/subtracting repeatedly
20:31:30	<talismanick>	if you have some set, the free group is the smallest part which you can build the rest of it out of
20:31:33	<Rembane>	talismanick: All integers? Not only positive ones?
20:31:44	<talismanick>	Rembane: that's for free groups :)
20:31:51	<EvanR>	it's a group so you can do -1
20:31:53	<talismanick>	group = monoid + invertibility
20:32:21	<Rembane>	talismanick: Cool, uh... I don't get it. Are the integers a free group?
20:32:21	<TheCreatorOfCrea>	dminuoso: I would not say it’s needless, because it is imo extremely hard what that generic implementation is that the author of a monad actually chose. E.g. for lists, there are clearly several choices. That insight gets lost when you use the monad. Which, to me, is about as problematic as dynamic languages’ implicit casting. (E.g.
20:32:22	<TheCreatorOfCrea>	JavaScript’s nightmares. ;)
20:32:37	<dminuoso>	Rembane: That's also quite easily explained: First you must understand that a free functor is just left adjoint to a forgetful functor
20:32:41	<talismanick>	{1}, together with + (and its minus) is the free group over the integers
20:33:02	<talismanick>	a group is a set with some operator which takes 2 elements of that set and returns another element
20:33:14	<Rembane>	talismanick: That funny {1}, is that the set consisting of the number one?
20:33:19	<talismanick>	yep!
20:33:29	<talismanick>	because, 4 = 1 + 1 + 1 + 1
20:33:31	<EvanR>	I like how this exposition of free groups is going in reverse from the most abstract back to what a group even is
20:33:32	<Rembane>	Cool, I thought it was some reference to something else at first.
20:33:44	<Rembane>	dminuoso: :D
20:33:45	<Franciman>	talismanick: wait i thought the free group over the integers was (Z, +)
20:33:57	<TheCreatorOfCrea>	dminuoso: Also, I found it very hard to actually realize that my code is just an attempt at re-implementing that monad and I could clarify my code by using the monad. Specifically because it’s so hard to tell what implementation was chosen.
20:34:09	<talismanick>	wait, shoot, you're right
20:34:19	<talismanick>	haven't done abstract algebra in years :D
20:34:29	<dminuoso>	Rembane: As a very simple starter, we can imagine lists to be a free monoid.
20:34:36	<c_wraith>	Franciman: notational difference. 1 is a generator, and there are group notations where you list the generators.
20:34:39	<dminuoso>	(or free monoidS)
20:34:45	<Franciman>	ah ok cool
20:34:48	<EvanR>	you can call Z with + and negate a group, now what about free group
20:34:52	<Franciman>	i used <1> for that
20:34:54	<Franciman>	now it makes sense
20:35:03	<dminuoso>	Rembane: Very roughly the idea is that a free something is the simplest something, that satisfies all the laws of something, without any extra baggage.
20:35:13	<talismanick>	but, yea, if you're given {'a','b'} with the concatenation operator, that's the free group over {'ab', 'aaaba', 'ababa', ...}
20:35:17	<talismanick>	free monoid, I mean
20:35:21	<talismanick>	because you don't have an inverse
20:35:24	<Rembane>	dminuoso: Cool, a minimum working example. handwaves
20:35:29	<TheCreatorOfCrea>	dminuoso: Yes. somehow, monoids and such were trivial to me though. Just an operator and a unit element. Like + and 0, or * and 1.
20:35:51	<EvanR>	the concatenation is what you get when ask for the free monoid over that set
20:35:57	<TheCreatorOfCrea>	dminuoso: I literally read that exact article! :D
20:36:02	<EvanR>	you don't have to start with it
20:36:05	<talismanick>	so, a monad is a monoid (maps back to itself under some operation), which maps back to itself
20:36:15	<dminuoso>	Rembane: and in that sense, a list encapsulates bare monoidal structure, where [A, B] can be imagined as the monoidal combination of A and B.. but without talking what that monoidal combination really is.
20:36:19	<dminuoso>	It's just the general shape.
20:36:26	<talismanick>	so you can sequence them and get back a single one, but it's also a black hole, typewise
20:36:32	<dminuoso>	And you can build things along that monoidal shape, but without actually picking an actual monoid (extra baggage)
20:36:50	<talismanick>	what goes in doesn't come back out, because its only functors... are back into itself! they're endo-functors
20:37:08	<EvanR>	I'm lost
20:37:11	<TheCreatorOfCrea>	talismanick: What I saw: “just means [meaningless letters, maybe a call to mama]” 🤣
20:37:12	<talismanick>	(endo is Greek for "into", "inside")
20:38:52	<talismanick>	TheCreatorOfCrea: so, if you have a monad over a type, "m a", your operations include binding one wrapped value to another (>>=) and wrapping a value in "m" (return), but you aren't given any method to pull a value out
20:38:59	<dminuoso>	Rembane: And similarly, free monads work the same way. You just use an algebraic datatype to build up the monad shape computation `data Free f a = Pure a \| Roll (f (Free f a))` (you can think `Roll` as just a delayed `join` that we can execute once we commit to some particular `f`). You just capture the raw monad shape, without any extra baggage. Do you see the pattern here?
20:39:10	<talismanick>	so, all of its maps which would otherwise go to another type, go back to itself
20:39:17	<dminuoso>	(this is very handwavy, but I think its more usable from a programmer point of view this way)
20:39:18	<talismanick>	once a value is inside, it's stuck there
20:39:29	<EvanR>	so you're saying monads are like burritos
20:39:54	<talismanick>	sure, if burritos destroyed information like black holes
20:39:54	<Rembane>	dminuoso: I see the pattern. Somehow it's easier to see it in the free monad than in the free monoid. Most probably because I've actually used the free monad for implementing stuff.
20:40:05	<EvanR>	monads are like black holes
20:40:09	<TheCreatorOfCrea>	talismanick: The “maps back” explanation is actually a pretty good one, yeah. It partially reminds me of how I had understood it, when it was still fresh. But, the “return” adds one more thing to it, no?
20:40:10	<EvanR>	that is a new one
20:40:14	<talismanick>	I microwave my burritos with Hawking radiation
20:40:20	<dminuoso>	Rembane: Imagine the `,` in the list to be the delayed mappend.
20:40:49	<dminuoso>	with foldMap you can commit to a particular monoid choice
20:41:04	<talismanick>	TheCreatorOfCrea: so, the signature is return :: a -> m a
20:41:11	<Rembane>	dminuoso: Oh, cool. This is good stuff.
20:41:46	<talismanick>	so, if you have some sequence of operations (inside the monad), return means "I'm done, you can stop here and wherever I'm at is the single opaque return value"
20:42:14	<dminuoso>	Rembane: and lack of any associative structure in the list can be thought of proof of associativity embedded.
20:42:29	<EvanR>	terms in a free monoid over a set are like the stem cells, you can replace the <>'s to get the behavior of any other monoid
20:42:42	<dminuoso>	that is [a,b,c] makes no comment about whether ((a,b),c) or (a,(b,c)) so to speak
20:42:45	<EvanR>	specialize into terms in any other monoid
20:42:47	<dminuoso>	its just.. the same.
20:43:01	<talismanick>	if you have readMyList :: IO [Int], you can read your list of Ints from the user and return that list, so you can `xs <- readMyList` inside main :: IO ()
20:43:22	<talismanick>	return is what allows you to write with certainty that m ( m a ) == m a
20:43:31	<Rembane>	dminuoso: That makes sense. The foldr-diagram of the Haskell Wiki is flashing in my brain, but that might be something else.
20:43:36	<dminuoso>	Rembane: though I guess this doesnt really hold true if you look closer. but we do accept (++) to satisfy associativty
20:43:49	<talismanick>	because it lets the inner one finish its work and cleanly merge back into the outer monadic context
20:43:57	<dminuoso>	So there's this cool notion edward once brought up somewhere, where he argued that we could define list also as:
20:44:13	<dminuoso>	newtype List a = List (forall b. Monoid b => (a -> b) -> b)
20:44:40	<TheCreatorOfCrea>	talismanick: Well, you can always pull the value out, by “running” the monad. (Which btw is a really confusing name for that operation, because it only makes sense for IO.) The only monad where you can’t do that in Haskell is the IO monad, no? (Unless GHC allows you to `unsafeInvokeElterGods :: IO a -> (RealWorld, a)` :D
20:45:26	<EvanR>	not all monads have run
20:45:29	<dminuoso>	This also follows from the fact that Foldable itself is fully characterstic for something being list-like, and yet you can define it in terms of `foldr` OR `foldMap`
20:45:37	<EvanR>	all comonads have extract
20:45:57	<talismanick>	I remember once reading a suggestion to reimagine IO as a comonad
20:46:00	<talismanick>	IIRC
20:46:01	→	nate1 joins (~nate@98.45.169.16)
20:46:23	<talismanick>	flew over my head at the time, but I might understand it better now
20:47:39	<geekosaur>	TheCreatorOfCrea, there is unsafePerformIO. and worse ones
20:48:29	<EvanR>	IO a -> (RealWorld, a) looks bad
20:49:12	<[exa]>	that's way beyond unsafe* prefixes
20:49:17	TheCreatorOfCrea	has `fold` flashbacks. … I never* remember which one goes into which direction. All explanations I ever saw still stay ambiguous, since “r” and “l” could still mean either way, depending on which way you mean “right” and “left”.
20:49:29	<dminuoso>	TheCreatorOfCrea: both go the same direcftion./
20:49:33	<geekosaur>	^
20:49:42	<geekosaur>	they associate in different directions
20:49:45	<dminuoso>	TheCreatorOfCrea: the difference between foldr and foldl is in association.
20:49:55	<dminuoso>	its similar to say infixr vs infixl
20:49:55	→	Guest\|32 joins (~Guest\|32@dyn1174-208.insecure.ic.ac.uk)
20:50:07	×	Guest\|32 quits (~Guest\|32@dyn1174-208.insecure.ic.ac.uk) (Client Quit)
20:50:37	<dminuoso>	foldr replaces (:) with a function, associating towards the right
20:50:40	<dminuoso>	foldl replaces (:) with a function, associating towards the left
20:51:33	×	nate1 quits (~nate@98.45.169.16) (Ping timeout: 268 seconds)
20:51:38	<talismanick>	I wish there was a Zip class in Prelude so I could zipWith-apply an n-tuple of functions to an n-tuple of values
20:51:45	<Rembane>	It just struck me. There's no such thing as a foldmiddle, right?
20:51:45	×	littlefinger quits (~littlefin@pool-74-102-98-242.nwrknj.fios.verizon.net) (Ping timeout: 244 seconds)
20:52:02	<dminuoso>	TheCreatorOfCrea: https://upload.wikimedia.org/wikipedia/commons/3/3e/Right-fold-transformation.png https://upload.wikimedia.org/wikipedia/commons/5/5a/Left-fold-transformation.png
20:52:17	<dminuoso>	See that, from left to right, the order of the numbers is the same?
20:52:19	<geekosaur>	how do you associate a binary operation to the middle?
20:52:37	<TheCreatorOfCrea>	geekosaur: I know. I had to use it once. (I used it somewhere, where I could know that it was safe, but the compiler couldn’t know so it was OK. Had to do with implementing dynamically loaded instances of a class, to allow for plugins. But I found better ways to do the same thing now.)
20:53:04	<Rembane>	geekosaur: Like a binary tree perhaps?
20:53:20	<dminuoso>	Mmm well on the grammatical level we have `infix` as an equivalent.
20:53:33	<dminuoso>	A binary tree seems to be the shape here yes
20:53:44	<dminuoso>	But it begs the question of balancing
20:54:13	<monochrom>	For tree structures and most ADTs, perhaps you would like catamorphisms.
20:55:15	<darkling>	I keep reading that word as "cacomorphisms". :/
20:55:36	<dminuoso>	a comorphism!
20:55:42	<dminuoso>	But what does ca mean
20:55:44	<EvanR>	TheCreatorOfCrea, don't remember foldr foldl, rederive it
20:55:45	<monochrom>	On Halloween, you will also hear me bring up pumpkin catmorphisms >:)
20:55:48	<TheCreatorOfCrea>	EvanR: Wouldn’t `virtualMachine :: RealWorld -> IO a -> (RealWorld, a)` make sense though? ^^ Provided one could actually define “RealWorld”. (Maybe merely as `IO b`, so one can drop it into an outer IO monad, after processing it in some way that implements the VM?)
20:55:57	<dminuoso>	TheCreatorOfCrea: that exists.
20:56:09	<dminuoso>	Flip it around, and you have it
20:56:09	<talismanick>	it means a morphism which you shotgun in hell while heavy metal blares
20:56:12	<dminuoso>	https://hackage.haskell.org/package/base-4.17.0.0/docs/GHC-Base.html#v:unIO
20:56:14	<dminuoso>	unIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)
20:56:30	<monochrom>	Preview: https://www.vex.net/~trebla/photo/unorganized/pumpkin-catmorphism.jpg
20:56:47	<darkling>	Scary.
20:56:57	<dminuoso>	TheCreatorOfCrea: and it turns out, making a real world is possible too: https://hackage.haskell.org/package/base-4.17.0.0/docs/GHC-Exts.html#v:realWorld-35-
20:57:17	<dminuoso>	If you combine these two, you have accursedUnutterablePerformIO which will elide all your mutable buffers or worse.
20:57:20	<TheCreatorOfCrea>	dminuoso: Ok, that was actually helpful. :) Now I can blame my lack of understanding on having trouble remembering which direction “associates towards *” means. ;)
20:58:12	<geekosaur>	that's easy though. (a * b) * c vs. a * (b * c) for some operator *
20:58:21	<dminuoso>	TheCreatorOfCrea: Though I think picturing it horizontally is even better: (((z `f` 1) `f` 2) `f` 3) vs (1 `f` (2 `f` (3 `f` z)))
20:59:06	<TheCreatorOfCrea>	talismanick: Isn’t the whole point of tuples that you cannot treat their elements the same? … But I think such functions exist though, for basic levels, no? … In any case, this sounds more like a list without the monomorphism restriction.
20:59:06	×	Vajb quits (~Vajb@2001:999:504:1841:9e47:1ec7:a52e:1d57) (Read error: Connection reset by peer)
20:59:14	→	Vajb joins (~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
20:59:34	<dminuoso>	In effect the former is more like a loop (especially if `f` is strict in its first argument, or that strictness is forced inside the foldl'ing), because it readily computes answers, whereas foldr rather constructs structure.
20:59:48	<dminuoso>	So its really not about direction, they are for different things.
21:00:16	<talismanick>	TheCreatorOfCrea: yeah, but just the case of `apply :: (a->a1,b->b1,...) -> (a,b,...) -> (a1,b1,....)
21:00:43	<talismanick>	err, zipApply
21:01:13	→	darkstardevx joins (~darkstard@50.126.124.156)
21:01:22	<TheCreatorOfCrea>	Rembane: Now you made me think of audio filters. high pass (foldr), low pass (foldl), band pass (foldmiddle), and notch filder (foldouter), plus a merely phase-inverting filter (folddual?). ;)
21:02:31	×	Vajb quits (~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
21:02:35	<TheCreatorOfCrea>	dminuoso: Those images you linked to are exactly what /causes/ my confusion. Thank you for trying to help, but this is a bug in my own mind that I need to fix myself first. ;)
21:02:51	×	tromp quits (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
21:03:09	×	darkstardevx quits (~darkstard@50.126.124.156) (Remote host closed the connection)
21:03:14	→	Vajb joins (~Vajb@2001:999:504:1841:9e47:1ec7:a52e:1d57)
21:03:28	<TheCreatorOfCrea>	dminuoso: Thank you in general, too. It is always a joy to come here… and leave inspired. :)
21:03:33	→	darkstardevx joins (~darkstard@50.126.124.156)
21:05:20	<Rembane>	TheCreatorOfCrea: Muaha! :D
21:06:50	<TheCreatorOfCrea>	dminuoso: `unIO` => 😳
21:08:12	×	johnjaye quits (~pi@173.209.64.74) (Ping timeout: 268 seconds)
21:08:41	<TheCreatorOfCrea>	dminuoso: `import GHC.Magic; main = youShallNotPass -- cause it is unsafe`
21:09:02	<dminuoso>	TheCreatorOfCrea: Let me emphasize: these two primitives are absurdly unsafe.
21:09:28	<dminuoso>	In combination.
21:09:33	<TheCreatorOfCrea>	dminuoso: WTF, `accursedUnutterablePerformIO` is an actual function!!
21:09:36	<dminuoso>	Yes.
21:09:43	<dminuoso>	Take one guess why it was renamed that way.
21:10:03	→	johnjaye joins (~pi@173.209.64.74)
21:10:23	<dminuoso>	Imagine you pry open an IO with that, and you have two IO actions both of which internally do `malloc 4096`. Take one guess what the optimizer will do here.
21:10:34	×	darkstardevx quits (~darkstard@50.126.124.156) (Remote host closed the connection)
21:10:55	→	darkstardevx joins (~darkstard@50.126.124.156)
21:12:58	<TheCreatorOfCrea>	dminuoso: foldl being more like a loop, and foldr constructing structure finally seems to have made it stick for me. Amazin. Let’s see if I remember it the next time. :)
21:13:19	<dminuoso>	TheCreatorOfCrea: note that foldl' should be better used in most cases when you want a loop
21:13:29	<dminuoso>	otherwise you will accumulate thunks for every round.
21:13:36	×	titibandit quits (~titibandi@xdsl-78-34-208-230.nc.de) (Remote host closed the connection)
21:14:12	<TheCreatorOfCrea>	dminuoso: No need to take a guess. I instantly hoogled it, and the documentation speaks for itself. :D
21:14:42	<geekosaur>	the linked bug reports are quite instructive
21:14:52	<TheCreatorOfCrea>	dminuoso: I will definitely use it, just because I like to summon elder gods and watch the world burn. ;) (At least the virtual one that goes away after I reset my computer.)
21:15:08	→	wonko joins (~wjc@2a0e:1c80:2:0:45:15:19:130)
21:15:11	×	gnyeki quits (~gnyeki@user/gnyeki) (Quit: leaving)
21:15:14	<dminuoso>	TheCreatorOfCrea: yeah its fun. you now have mutable buffer, and if later IO actions come to free them, you might double-free that too. or maybe they get elided, free occurs, but the other side keeps using free'd memory!
21:15:27	<dminuoso>	TheCreatorOfCrea: all kinds of memory corruption and bugs.
21:15:29	<dminuoso>	:>
21:15:36	<geekosaur>	(I winced when I read the descriptions; I could already see what was coming. But I suspect I'm a bit more familiar with this than the ByteString devs were back then)
21:15:36	<TheCreatorOfCrea>	dminuoso: I know about `foldl'`. :)
21:16:17	<geekosaur>	aliased buffers because ghc hoists the common allocation out of the loop
21:16:23	<geekosaur>	fun stuff like that
21:16:53	TheCreatorOfCrea	needs MOAR Tardis monad in there! :D
21:17:13	<geekosaur>	(just remember the Tardis monad is slow)
21:17:34	×	`2jt quits (~jtomas@191.red-88-17-199.dynamicip.rima-tde.net) (Ping timeout: 268 seconds)
21:17:36	×	vn36__ quits (~vn36@123.63.203.210) (Ping timeout: 260 seconds)
21:19:29	<TheCreatorOfCrea>	geekosaur: I plan to relocate next to a black hole anyway, so no problem. ;)
21:19:47	×	rockystone quits (~rocky@user/rockymarine) (Ping timeout: 252 seconds)
21:19:59	<dminuoso>	I think you will find out that plan wont work out so well.
21:20:33	×	michalz quits (~michalz@185.246.207.200) (Remote host closed the connection)
21:23:35	<TheCreatorOfCrea>	dminuoso: If you stay at the right distance, actually it does. :D
21:24:38	<dminuoso>	Just be sure to pick one without an accretion disk
21:25:00	<dminuoso>	(Best to check before you fly there)
21:25:03	→	eggplantade joins (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74)
21:25:30	<geekosaur>	still not the greatest of ideas, depending on distance. see Niven's "Neutron Star"
21:27:48	<TheCreatorOfCrea>	geekosaur: I’m more of a Saggitarius A* kinda guy. :P
21:28:15	<geekosaur>	same tidal effects only more so
21:28:18	<dminuoso>	SagA* has a massive accretion disk
21:28:29	<dminuoso>	You will have some serious thermal and radiation problems.
21:28:44	<geekosaur>	you do not want tidal effects between your head and your feet
21:28:59	<dminuoso>	geekosaur: the shear depends on how close to the event horizon you are though
21:29:13	<geekosaur>	that's why I said "depending on distance"
21:29:16	<dminuoso>	RIght.
21:29:26	<dminuoso>	So first we have to establish how expensive TheCreatorOfCrea's tardis computation is
21:29:31	<dminuoso>	And how much time he wants to skip
21:29:51	×	eggplantade quits (~Eggplanta@2600:1700:38c5:d800:253c:9364:4f2a:ce74) (Ping timeout: 260 seconds)
21:30:03	<TheCreatorOfCrea>	geekosaur: Actually, the bigger the hole, the more gradual the tidal effects. If the hole is big enough, you will not even notice you went past the horizon unless you got a window. Your space will have become ”time-like” though. ^^
21:30:26	<dminuoso>	Then we just apply the lorentz transformation, figure out ideal orbit, predict radiation/thermal problems
21:30:40	<dminuoso>	calculate necessary fuel for escape velocity
21:31:30	<dminuoso>	I dont think its well agreed upon what you would observe when crossing the event horizon
21:31:35	<geekosaur>	^
21:31:42	→	abiss27 joins (~abiss27@190.213.236.106)
21:32:03	<geekosaur>	hell, there are still hypotheses that the universe itself is contained within a massive event horizon
21:32:05	<TheCreatorOfCrea>	dminuoso: “It’s almost TOO easy!” -- Garth ;)
21:32:47	<TheCreatorOfCrea>	geekosaur: Yes, and like the big bang, the lack of testability makes it merely yet another creation myth. ^^
21:32:56	<geekosaur>	yep
21:32:58	TheCreatorOfCrea	ducks. ;)
21:33:44	TheCreatorOfCrea	’s porn is existentialism.
21:33:52	←	L29Ah parts (~L29Ah@wikipedia/L29Ah) ()
21:34:28	×	TheCreatorOfCrea quits (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de) (Quit: Client closed)
21:34:32	→	L29Ah joins (~L29Ah@wikipedia/L29Ah)
21:34:41	→	TheCreatorOfCrea joins (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de)
21:34:49	→	rockystone joins (~rocky@user/rockymarine)
21:35:05	→	vn36_ joins (~vn36@123.63.203.210)
21:35:10	×	chomwitt quits (~chomwitt@2a02:587:dc1e:5e00:e9e7:bb14:f272:9a4b) (Remote host closed the connection)
21:35:32	×	TheCreatorOfCrea quits (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de) (Client Quit)
21:35:41	→	TheCreatorOfCrea joins (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de)
21:36:46	iphy_	is now known as iphy
21:37:48	<TheCreatorOfCrea>	What’s the difference between Vector and MArray, btw? They seem to both be mutable arrays…
21:38:37	<TheCreatorOfCrea>	(Ok, MArray seems to be indexed by a definable index, so I guess I already answered my own question.)
21:38:57	→	stackdroid18 joins (14094@user/stackdroid)
21:39:37	→	bitdex joins (~bitdex@gateway/tor-sasl/bitdex)
21:39:57	<EvanR>	there's what's the difference between Vector and Array, and MVector / MArray
21:40:04	<EvanR>	mutability isn't it, since both has both versions
21:40:43	<EvanR>	Array uses an index type, Vector uses Int (and has more API)
21:44:16	×	FinnElija quits (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
21:44:17	×	adanwan quits (~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
21:44:18	→	jmdaemon joins (~jmdaemon@user/jmdaemon)
21:44:21	×	johnjaye quits (~pi@173.209.64.74) (Ping timeout: 252 seconds)
21:44:55	<TheCreatorOfCrea>	EvanR: Ah, OK, that completes the picture.
21:45:01	→	adanwan joins (~adanwan@gateway/tor-sasl/adanwan)
21:45:18	→	FinnElija joins (~finn_elij@user/finn-elija/x-0085643)
21:51:11	×	FinnElija quits (~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
21:51:42	→	FinnElija joins (~finn_elij@user/finn-elija/x-0085643)
21:52:19	→	ddellacosta joins (~ddellacos@86.106.143.65)
21:56:41	×	abiss27 quits (~abiss27@190.213.236.106) (Ping timeout: 260 seconds)
21:58:09	×	ddellacosta quits (~ddellacos@86.106.143.65) (Ping timeout: 268 seconds)
22:10:44	→	ph88 joins (~ph88@tmo-085-129.customers.d1-online.com)
22:11:23	×	TheCreatorOfCrea quits (~TheCreato@2a0a-a546-c344-1-e0bc-1e36-315c-295b.ipv6dyn.netcologne.de) (Quit: Client closed)
22:11:48	×	vglfr quits (~vglfr@145.224.100.100) (Ping timeout: 264 seconds)
22:12:20	→	vglfr joins (~vglfr@145.224.100.100)
22:13:04	→	Feuermagier joins (~Feuermagi@user/feuermagier)
22:14:00	×	zeenk quits (~zeenk@2a02:2f04:a311:7000:aa5:d3dd:854f:9922) (Quit: Konversation terminated!)
22:15:25	×	gurkenglas quits (~gurkengla@p548ac72e.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
22:16:38	×	talismanick quits (~talismani@96-67-197-217-static.hfc.comcastbusiness.net) (Remote host closed the connection)
22:19:14	×	__monty__ quits (~toonn@user/toonn) (Quit: leaving)
22:21:24	×	zkSNOOP quits (~username@ptr-21zvp7p1ecvdx6mr7hf.18120a2.ip6.access.telenet.be) ()
22:31:39	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 252 seconds)
22:37:31	×	wonko quits (~wjc@2a0e:1c80:2:0:45:15:19:130) (Ping timeout: 260 seconds)
22:37:53	×	jumper149 quits (~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.6)
22:40:00	×	vglfr quits (~vglfr@145.224.100.100) (Ping timeout: 264 seconds)
22:43:53	×	jbayardo quits (~jbayardo@20.83.116.49) (Read error: Connection reset by peer)
22:44:12	→	beteigeuze joins (~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
22:47:31	×	acidjnk quits (~acidjnk@p200300d6e7137a21d59bab4b536388a8.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
22:47:43	→	jbayardo joins (~jbayardo@20.83.116.49)
22:52:17	×	Tuplanolla quits (~Tuplanoll@91-159-69-34.elisa-laajakaista.fi) (Quit: Leaving.)
22:53:59	×	Topsi quits (~Topsi@dyndsl-095-033-095-014.ewe-ip-backbone.de) (Read error: Connection reset by peer)
22:59:28	→	wonko joins (~wjc@2a0e:1c80:2:0:45:15:19:130)
22:59:58	→	dimsuz joins (~dima@185.17.128.139)
23:00:53	<dimsuz>	hi! I'm trying to use filepath library, added it to the cabal file, then added 'import System.OsPath' and ghc says it couldn't find such module.
23:01:02	<dimsuz>	I must have missed something obvious
23:01:09	→	freeside joins (~mengwong@103.252.202.193)
23:02:52	<geekosaur>	are you using the right version? older versions only provide System.Filepath; System.OsPath is only in the latest version
23:02:57	<dimsuz>	oh. found the suggestion to use a higher-level library in the README. Will do that, but still curious why won't it import this one
23:03:46	<dimsuz>	geekosaur: I've just added 'filepath' to my cabal file without a strict verision bounds. Perhaps this is the cause then!
23:03:54	<geekosaur>	in particular it's not included with ghc 9.2.x apparently
23:04:04	<dimsuz>	yep, I'm on 9.2 atm
23:04:35	<geekosaur>	then you have filepath 1.4.2.2
23:04:49	<geekosaur>	you would have to specify you want filepath 1.4.100.0
23:05:51	<dimsuz>	I see, thank you! Will go for `path` for now :)
23:06:06	×	freeside quits (~mengwong@103.252.202.193) (Ping timeout: 268 seconds)
23:09:27	×	vn36_ quits (~vn36@123.63.203.210) (Ping timeout: 250 seconds)
23:19:26	→	freeside joins (~mengwong@103.252.202.193)
23:27:09	→	vn36_ joins (~vn36@123.63.203.210)
23:39:56	×	ezzieyguywuf quits (~Unknown@user/ezzieyguywuf) (Ping timeout: 260 seconds)
23:39:57	→	Volt_ joins (~Volt_@c-73-167-119-209.hsd1.ma.comcast.net)
23:42:09	→	vglfr joins (~vglfr@145.224.100.100)
23:42:36	→	ezzieyguywuf joins (~Unknown@user/ezzieyguywuf)
23:46:17	→	off^ joins (~off@c-76-17-6-165.hsd1.ga.comcast.net)
23:54:47	→	jargon joins (~jargon@184.101.208.112)
23:55:05	<EvanR>	parsing statements using this grammar literally works but doesn't seem to produce the logical structure I admittedly made up after years of writing C https://paste.tomsmeding.com/8LrwBK4W
23:55:36	<EvanR>	case is followed by 1 statement, in a switch there's probably multiple statements but it's grouped as a compound
23:56:12	<EvanR>	but that's the official grammar from historical document
23:56:31	<EvanR>	I wonder if there's a better grammar
23:56:40	<geekosaur>	think duff's device 🙂

All times are in UTC on 2022-10-17.