IRCBrowse

2023/05/02

2023-05-02 00:00:47 +0200marinelli(~weechat@gateway/tor-sasl/marinelli) (Remote host closed the connection)
2023-05-02 00:08:30 +0200michalz(~michalz@185.246.207.205) (Remote host closed the connection)
2023-05-02 00:08:33 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-05-02 00:08:34 +0200jmdaemon(~jmdaemon@user/jmdaemon)
2023-05-02 00:14:13 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-05-02 00:14:29 +0200jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.8)
2023-05-02 00:19:05 +0200JustPassingBy(~DontMindM@188.132.236.106)
2023-05-02 00:19:37 +0200Me-me(~Me-me@user/me-me)
2023-05-02 00:19:48 +0200falafel(~falafel@2603-8000-d700-115c-156a-c6f3-3ee5-b716.res6.spectrum.com)
2023-05-02 00:21:05 +0200falafel(~falafel@2603-8000-d700-115c-156a-c6f3-3ee5-b716.res6.spectrum.com) (Remote host closed the connection)
2023-05-02 00:21:27 +0200falafel(~falafel@2603-8000-d700-115c-6c3b-389e-7e69-f43f.res6.spectrum.com)
2023-05-02 00:32:17 +0200acidjnk(~acidjnk@p200300d6e715c464285fef55bd00a3c3.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-05-02 00:35:22 +0200JustPassingBy(~DontMindM@188.132.236.106) (Quit: Client closed)
2023-05-02 00:36:33 +0200tremon(~tremon@83.80.159.219) (Quit: getting boxed in)
2023-05-02 00:40:31 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-5d8c-8b3d-ea84-cebb.rev.sfr.net) (Remote host closed the connection)
2023-05-02 00:41:15 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-5d8c-8b3d-ea84-cebb.rev.sfr.net)
2023-05-02 00:46:12 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-05-02 00:46:34 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-05-02 00:48:23 +0200gurkenglas(~gurkengla@dynamic-046-114-182-194.46.114.pool.telefonica.de) (Ping timeout: 260 seconds)
2023-05-02 00:57:17 +0200biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-05-02 00:57:37 +0200biberu(~biberu@user/biberu)
2023-05-02 00:59:01 +0200dextaa(~DV@user/dextaa) (Quit: Ping timeout (120 seconds))
2023-05-02 00:59:27 +0200dextaa(~DV@user/dextaa)
2023-05-02 01:04:01 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-05-02 01:18:59 +0200Xe(~cadey@tailscale/xe) (Ping timeout: 265 seconds)
2023-05-02 01:20:01 +0200justsomeguy(~justsomeg@user/justsomeguy)
2023-05-02 01:20:54 +0200Xe(~cadey@tailscale/xe)
2023-05-02 01:32:50 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-05-02 01:34:06 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-05-02 01:34:06 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-05-02 01:34:06 +0200wroathe(~wroathe@user/wroathe)
2023-05-02 01:36:48 +0200mauke_(~mauke@user/mauke)
2023-05-02 01:38:05 +0200mauke(~mauke@user/mauke) (Ping timeout: 240 seconds)
2023-05-02 01:38:06 +0200mauke_mauke
2023-05-02 01:49:59 +0200falafel(~falafel@2603-8000-d700-115c-6c3b-389e-7e69-f43f.res6.spectrum.com) (Ping timeout: 260 seconds)
2023-05-02 01:55:23 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe) (Quit: Konversation terminated!)
2023-05-02 02:12:15 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp)
2023-05-02 02:12:51 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 260 seconds)
2023-05-02 02:13:33 +0200crns(~netcrns@p4ff5ee17.dip0.t-ipconnect.de)
2023-05-02 02:13:33 +0200crns(~netcrns@p4ff5ee17.dip0.t-ipconnect.de) (Changing host)
2023-05-02 02:13:33 +0200crns(~netcrns@user/crns)
2023-05-02 02:13:42 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-05-02 02:14:56 +0200gemmaro(~user@240f:74:d1f0:1:ba1:e787:c9e:b1dc)
2023-05-02 02:17:31 +0200caryhartline(~caryhartl@2600:1700:2d0:8d30:8c38:7008:d307:dea1)
2023-05-02 02:26:19 +0200Square2(~Square4@user/square)
2023-05-02 02:29:45 +0200Square(~Square@user/square) (Ping timeout: 268 seconds)
2023-05-02 02:39:41 +0200mcglk(~mcglk@131.191.19.145) (Read error: Connection reset by peer)
2023-05-02 02:41:13 +0200mcglk(~mcglk@131.191.19.145)
2023-05-02 02:45:25 +0200nate1(~nate@98.45.169.16)
2023-05-02 03:03:17 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-05-02 03:04:04 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-05-02 03:10:46 +0200bramhaag(~bramhaag@134.195.121.39) (Read error: Connection reset by peer)
2023-05-02 03:10:53 +0200bramhaag(~bramhaag@134.195.121.39)
2023-05-02 03:11:13 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-05-02 03:11:57 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:fdd9:cd01:9100:d00b)
2023-05-02 03:12:05 +0200finnekit(~finnekit@fsf/member/finnekit) (Ping timeout: 240 seconds)
2023-05-02 03:12:43 +0200lottaquestions(~nick@2607:fa49:503f:6d00:7d78:9c20:dd70:c4c8)
2023-05-02 03:12:59 +0200bramhaag(~bramhaag@134.195.121.39) (Client Quit)
2023-05-02 03:16:13 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:fdd9:cd01:9100:d00b) (Ping timeout: 250 seconds)
2023-05-02 03:16:32 +0200gmg(~user@user/gehmehgeh) (Ping timeout: 240 seconds)
2023-05-02 03:17:22 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-05-02 03:22:27 +0200emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-05-02 03:22:40 +0200bramhaag(~bramhaag@134.195.121.39)
2023-05-02 03:23:56 +0200finnekit(~finnekit@fsf/member/finnekit)
2023-05-02 03:25:45 +0200gmg(~user@user/gehmehgeh)
2023-05-02 03:26:09 +0200finnekit(~finnekit@fsf/member/finnekit) (Client Quit)
2023-05-02 03:26:59 +0200bramhaag(~bramhaag@134.195.121.39) (Client Quit)
2023-05-02 03:37:45 +0200bramhaag(~bramhaag@134.195.121.39)
2023-05-02 03:39:13 +0200finnekit(~finnekit@fsf/member/finnekit)
2023-05-02 03:45:31 +0200bramhaag1(~bramhaag@134.195.121.39)
2023-05-02 03:46:50 +0200bramhaag(~bramhaag@134.195.121.39) (Ping timeout: 268 seconds)
2023-05-02 03:46:50 +0200bramhaag1bramhaag
2023-05-02 03:46:53 +0200finnekit(~finnekit@fsf/member/finnekit) (Ping timeout: 246 seconds)
2023-05-02 03:48:59 +0200nate1(~nate@98.45.169.16) (Ping timeout: 260 seconds)
2023-05-02 03:50:48 +0200bilegeek(~bilegeek@97.sub-174-208-228.myvzw.com)
2023-05-02 03:51:21 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-05-02 03:51:37 +0200jinsunGuest2793
2023-05-02 03:51:37 +0200jinsun__(~jinsun@user/jinsun)
2023-05-02 03:51:37 +0200Guest2793(~jinsun@user/jinsun) (Killed (copper.libera.chat (Nickname regained by services)))
2023-05-02 03:51:38 +0200jinsun__jinsun
2023-05-02 03:53:53 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 246 seconds)
2023-05-02 03:55:25 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 240 seconds)
2023-05-02 03:55:53 +0200bramhaag(~bramhaag@134.195.121.39) (Quit: Ping timeout (120 seconds))
2023-05-02 03:56:01 +0200Square2Square
2023-05-02 03:56:59 +0200bramhaag(~bramhaag@134.195.121.39)
2023-05-02 04:00:31 +0200finnekit(~finnekit@fsf/member/finnekit)
2023-05-02 04:09:10 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-05-02 04:18:52 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp) (Ping timeout: 276 seconds)
2023-05-02 04:23:40 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-05-02 04:27:23 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca)
2023-05-02 04:27:31 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca) (Remote host closed the connection)
2023-05-02 04:29:05 +0200cheater(~Username@user/cheater) (Remote host closed the connection)
2023-05-02 04:30:07 +0200 <Inst_> hmmm, wait
2023-05-02 04:30:11 +0200 <Inst_> does laziness imply backtracking?
2023-05-02 04:30:12 +0200 <Inst_> https://paste.tomsmeding.com/mC81RdPa
2023-05-02 04:30:20 +0200 <Inst_> this can't complete for take 1... length 8
2023-05-02 04:33:24 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 04:33:46 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 04:38:07 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Ping timeout: 250 seconds)
2023-05-02 04:44:47 +0200 <ski> > inRange ((1,1),(7,7)) (3,4)
2023-05-02 04:44:48 +0200 <lambdabot> True
2023-05-02 04:45:01 +0200 <Inst_> thanks
2023-05-02 04:45:15 +0200 <ski> `speculations' could use `filter'
2023-05-02 04:45:31 +0200 <Inst_> https://hackage.haskell.org/package/base-4.18.0.0/docs/Data-Ix.html#v:inRange
2023-05-02 04:45:33 +0200 <Inst_> cool
2023-05-02 04:45:41 +0200 <Inst_> i used filter before, it was a microoptimization to take it out
2023-05-02 04:45:57 +0200 <Inst_> thanks for introducing Ix typeclass to me
2023-05-02 04:47:13 +0200 <ski> repeatedly using `length' there is inefficient. better would be to keep a counter
2023-05-02 04:47:34 +0200 <Inst_> i switched to vec underneath, seems to cause more copying, unfortunately
2023-05-02 04:48:11 +0200 <ski> (you could even use `replicateM_', on `StateT History []')
2023-05-02 04:48:38 +0200 <ski> yea, lists will share tails
2023-05-02 04:48:50 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 04:48:58 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Remote host closed the connection)
2023-05-02 04:49:06 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-05-02 04:49:06 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-05-02 04:49:06 +0200finn_elijaFinnElija
2023-05-02 04:50:25 +0200 <ski> `GetHistoryFailure' is also unused
2023-05-02 04:50:41 +0200td_(~td@i53870907.versanet.de) (Ping timeout: 250 seconds)
2023-05-02 04:50:53 +0200 <Inst_> yeah, i know, was thinking about moving it to either
2023-05-02 04:51:41 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-05-02 04:52:34 +0200td_(~td@i53870911.versanet.de)
2023-05-02 04:52:48 +0200 <ski> and yes, the list monad will give you backtracking
2023-05-02 04:53:02 +0200 <Inst_> or rather list type + laziness = backtracking?
2023-05-02 04:54:38 +0200 <ski> yes
2023-05-02 04:56:19 +0200 <Inst_> what is StateT History [] as a type?
2023-05-02 04:56:19 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 250 seconds)
2023-05-02 04:56:24 +0200 <Inst_> do you mean StateT History ()?
2023-05-02 04:57:00 +0200 <ski> (also some redundant brackets in `generateSolutions')
2023-05-02 04:57:11 +0200 <ski> no, that doesn't kind-check
2023-05-02 04:57:21 +0200 <Inst_> yeah, i know, but it got modded a few times, not necessarily for the better
2023-05-02 04:57:29 +0200 <Inst_> i guess the remaining challenge now is to figure out how to parallelize it intelligently
2023-05-02 04:57:35 +0200 <ski> @kind StateT [(Int,Int)] ()
2023-05-02 04:57:36 +0200 <lambdabot> error:
2023-05-02 04:57:36 +0200 <lambdabot> • Expected kind ‘* -> *’, but ‘()’ has kind ‘*’
2023-05-02 04:57:36 +0200 <lambdabot> • In the second argument of ‘StateT’, namely ‘()’
2023-05-02 04:57:38 +0200 <ski> @kind StateT [(Int,Int)] []
2023-05-02 04:57:39 +0200 <lambdabot> * -> *
2023-05-02 04:57:51 +0200 <Inst_> i just want to figure out how to get it to let me take 1 . fromJust $ getSolutions 8 (1,1)... within a reasonable amount of time
2023-05-02 04:58:25 +0200 <Inst_> ah, i see what you mean
2023-05-02 04:58:37 +0200 <Inst_> since StateT is a monad transformer
2023-05-02 04:58:52 +0200 <ski> being able to prune the state-space tree early, would be nice
2023-05-02 04:59:29 +0200 <ski> (not sure whether there's an opportunity for that, though)
2023-05-02 05:01:50 +0200 <ski> hm .. perhaps one could maintain a graph, keep removing edges, and somehow detect when it becomes disconnected
2023-05-02 05:02:18 +0200jero98772(~jero98772@2800:484:1d84:9000::3) (Remote host closed the connection)
2023-05-02 05:03:54 +0200 <ski> anyway, i guess i would start with the counter, see if that makes a noticable difference
2023-05-02 05:04:49 +0200 <Inst_> yeah, already added it, slight performance improvement on non-vector version
2023-05-02 05:05:38 +0200 <Inst_> what i'm looking for right now is an improved quicksort / treesort, i.e, in the sense that it was used to show off how much nicer a declarative programming paradigm was to an imperative one
2023-05-02 05:06:08 +0200 <ski> "treesort" ?
2023-05-02 05:06:26 +0200 <ski> guess you mean a recursive sort (?)
2023-05-02 05:07:53 +0200 <ski> hm, also wondering if one could do divide-and-conquer, somehow
2023-05-02 05:08:08 +0200 <Inst_> quicksort u = if null u then u else quicksort [lesser | lesser <- u, lesser < head u] <> [head u] <> [greaterOrEqual | greaterOrEqual <- u, greaterOrEqual >= head u]
2023-05-02 05:08:18 +0200 <Inst_> someone else suggested that
2023-05-02 05:08:43 +0200gemmaro(~user@240f:74:d1f0:1:ba1:e787:c9e:b1dc) (Remote host closed the connection)
2023-05-02 05:08:46 +0200 <Inst_> hmmm, that doesn't work
2023-05-02 05:08:52 +0200 <ski> missing one recursive call
2023-05-02 05:08:56 +0200 <Inst_> quicksort u = if null u then u else quicksort [lesser | lesser <- tail u, lesser < head u] <> [head u] <> [greaterOrEqual | greaterOrEqual <- tail u, greaterOrEqual >= head u]
2023-05-02 05:09:07 +0200 <Inst_> quicksort u = if null u then u else quicksort [lesser | lesser <- tail u, lesser < head u] <> [head u] <> quicksort [greaterOrEqual | greaterOrEqual <- tail u, greaterOrEqual >= head u]
2023-05-02 05:09:38 +0200 <ski> pattern-matching to the rescue
2023-05-02 05:09:50 +0200 <Inst_> as a one liner? ;)
2023-05-02 05:09:59 +0200 <Inst_> but that's not in-place
2023-05-02 05:10:02 +0200 <ski> just use `;'
2023-05-02 05:10:04 +0200 <Inst_> so not a true quicksort
2023-05-02 05:10:07 +0200 <ski> right
2023-05-02 05:10:08 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-05-02 05:10:44 +0200 <ski> mergesort is not too bad
2023-05-02 05:10:52 +0200 <Inst_> and no one would write that cancer code, it's pretty much massaged so it can be a one-liner
2023-05-02 05:11:10 +0200 <ski> @type partition
2023-05-02 05:11:11 +0200 <lambdabot> (a -> Bool) -> [a] -> ([a], [a])
2023-05-02 05:11:21 +0200 <Inst_> how well does timsort work in Haskell, since people decided that would be standard?
2023-05-02 05:11:35 +0200 <ski> dunno about that one
2023-05-02 05:13:01 +0200 <Inst_> i wonder if this works without scoped type variables
2023-05-02 05:13:09 +0200 <Inst_> quicksort (u :: [a]) = if null u then u else quicksort [lesser | lesser <- tail u, lesser < head u] <> [head u] <> quicksort [greaterOrEqual | greaterOrEqual <- tail u, greaterOrEqual >= head u] :: [a]
2023-05-02 05:13:31 +0200 <Inst_> seems to work
2023-05-02 05:13:57 +0200 <ski> why would you think it needed those type ascriptions ?
2023-05-02 05:14:18 +0200 <Inst_> the point / joke / parody is to turn quicksort into a one-liner in haskell without use of ;
2023-05-02 05:14:33 +0200 <Inst_> that is the contents of the classic Haskell quicksort stuffed into one line
2023-05-02 05:14:50 +0200 <Inst_> which is also useful as an example of "just because you can,t doesn't mean you should; i.e, give a damn about readability"
2023-05-02 05:14:55 +0200 <ski> i don't really see the point in avoiding `;'
2023-05-02 05:15:40 +0200 <Inst_> abuse of ; is something you can do in any language, only in heavily expression-oriented languages like haskell can you start creating degenerate expression-based code
2023-05-02 05:15:58 +0200 <ski> anyway, you could at least avoid `head' and `tail', if you used an irrefutable pattern-match
2023-05-02 05:17:28 +0200 <Inst_> quicksort u@(~(x:xs) :: [a]) = if null u then u else quicksort [lesser | lesser <- xs, lesser < x] <> [x] <> quicksort [greaterOrEqual | greaterOrEqual <- xs, greaterOrEqual >= x] :: [a]
2023-05-02 05:17:29 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 268 seconds)
2023-05-02 05:19:34 +0200 <ski> hmm, now i'm wondering about a version of quick-sort that'd use three recursive calls
2023-05-02 05:20:44 +0200zer0bitz_(~zer0bitz@2001:2003:f443:d600:5dc3:37f0:5096:1b30)
2023-05-02 05:22:35 +0200zer0bitz(~zer0bitz@2001:2003:f443:d600:799d:b077:ccea:4521) (Ping timeout: 265 seconds)
2023-05-02 05:24:27 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca)
2023-05-02 05:31:37 +0200phma(phma@2001:5b0:2143:d3b8:7a30:9fcb:3105:385a) (Read error: Connection reset by peer)
2023-05-02 05:32:41 +0200phma(phma@2001:5b0:215a:e9f8:70e:a131:7bd8:ec6)
2023-05-02 05:47:57 +0200 <hammond> im confused about the record syntax, say i have data Person = Person {name::String, adddrs::String} and I wanted to pattern match the name portion
2023-05-02 05:48:11 +0200 <hammond> check p.name
2023-05-02 05:49:26 +0200 <hammond> check p.name | p.name == "John" = ... if i pass the check function a person.
2023-05-02 05:57:04 +0200 <ski> check Person {name = "John"} = ...
2023-05-02 06:00:36 +0200 <johnw> I'm here
2023-05-02 06:08:56 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-05-02 06:09:13 +0200 <hammond> even if u do something like `prefixOf`
2023-05-02 06:15:10 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-05-02 06:17:18 +0200 <geekosaur> I think if you want to use record dot then it's `check p | "John" `isPrefixOf` p.name = …`
2023-05-02 06:18:20 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca) (Ping timeout: 260 seconds)
2023-05-02 06:19:11 +0200 <ski> check Person {name = (("John" `isPrefixOf`) -> True),adddrs} = ...
2023-05-02 06:20:05 +0200 <hammond> slick ski
2023-05-02 06:20:08 +0200 <hammond> thanks.
2023-05-02 06:20:45 +0200 <ski> check Person {name,adddrs} | "John" `isPrefixOf` name = ... -- also works, obviously
2023-05-02 06:20:58 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca)
2023-05-02 06:27:48 +0200falafel(~falafel@2603-8000-d700-115c-9bf8-6766-e74e-f083.res6.spectrum.com)
2023-05-02 06:33:29 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (Quit: ZNC - http://znc.in)
2023-05-02 06:35:11 +0200rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-04-174-88-193-177.dsl.bell.ca) (Ping timeout: 268 seconds)
2023-05-02 06:37:02 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2023-05-02 06:37:30 +0200bilegeek(~bilegeek@97.sub-174-208-228.myvzw.com) (Quit: Leaving)
2023-05-02 06:37:53 +0200jargon_(~jargon@184.101.78.160)
2023-05-02 06:38:36 +0200jargon(~jargon@184.101.73.92) (Ping timeout: 250 seconds)
2023-05-02 06:48:39 +0200gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-05-02 06:49:25 +0200gmg(~user@user/gehmehgeh)
2023-05-02 06:54:55 +0200 <hammond> but then say check Person{name,addrs} "John" `isPrefixOf` name = -- return ( registrationNumber, Person)
2023-05-02 06:55:39 +0200 <hammond> or do i have to do (registrationNumber, Person{name=name, addrs=addrs}
2023-05-02 06:55:43 +0200 <hammond> )
2023-05-02 06:56:13 +0200gurkenglas(~gurkengla@dynamic-046-114-182-194.46.114.pool.telefonica.de)
2023-05-02 06:56:41 +0200 <geekosaur> check p@Person{name} | "John" `isPrefixOf` name = return (registrationNumber, p)
2023-05-02 06:56:58 +0200 <hammond> shhh
2023-05-02 06:57:03 +0200 <hammond> ok thx
2023-05-02 06:59:31 +0200mbuf(~Shakthi@49.207.178.186)
2023-05-02 07:13:42 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 250 seconds)
2023-05-02 07:16:12 +0200euandreh(~Thunderbi@189.6.18.7)
2023-05-02 07:18:16 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-05-02 07:21:04 +0200falafel(~falafel@2603-8000-d700-115c-9bf8-6766-e74e-f083.res6.spectrum.com) (Ping timeout: 248 seconds)
2023-05-02 07:31:55 +0200cyphase(~cyphase@user/cyphase) (Ping timeout: 268 seconds)
2023-05-02 07:33:42 +0200mtjm(~mutantmel@2604:a880:2:d0::208b:d001) (Remote host closed the connection)
2023-05-02 07:34:43 +0200trev(~trev@user/trev)
2023-05-02 07:34:56 +0200mtjm(~mutantmel@2604:a880:2:d0::208b:d001)
2023-05-02 07:36:13 +0200cyphase(~cyphase@user/cyphase)
2023-05-02 07:37:26 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-05-02 07:54:43 +0200 <Inst_> i have a problem, wherein i'm addicted to helping people with their Haskell homework, because sometimes the problems get so interesting
2023-05-02 07:55:03 +0200 <Inst_> right now, i'm trying to figure out how to get lazy conditionals, i.e, they evaluate the conditions lazily
2023-05-02 07:55:30 +0200 <Inst_> like, if you want to run simultaneous checks on different options
2023-05-02 07:57:52 +0200CiaoSen(~Jura@tmo-108-9.customers.d1-online.com)
2023-05-02 07:58:21 +0200 <jade[m]> use a tree to simultaneously traverse different possibilities and discard ones that don't match?
2023-05-02 07:59:18 +0200 <jade[m]> not sure if I understood correctly what is asked for
2023-05-02 08:02:25 +0200 <Inst_> someone tried a recursive approach to some problem, i was wondering if i understood laziness correctly, but i realize the problem with their approach, it's because conditionals are strict
2023-05-02 08:02:46 +0200 <Inst_> the solution would be instead to parallelize the process, and when one spark returns with the correct answer, the function returns
2023-05-02 08:03:46 +0200 <Inst_> question is, how do you do that? i mean, it'd be easy to do with mvar and code in IO, but purely?
2023-05-02 08:10:16 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 276 seconds)
2023-05-02 08:11:21 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-05-02 08:18:13 +0200 <Inst_> ehhh, this is intrinsically impure
2023-05-02 08:20:28 +0200michalz(~michalz@185.246.207.197)
2023-05-02 08:26:08 +0200CyberSoul(~ray@2405:201:680a:b174:7b30:abcb:1d56:b23) (Quit: Leaving)
2023-05-02 08:28:04 +0200CyberSoul(~ray@2405:201:680a:b174:7b30:abcb:1d56:b23)
2023-05-02 08:37:01 +0200mncheckm(~mncheck@193.224.205.254)
2023-05-02 08:39:08 +0200Square(~Square4@user/square) (Ping timeout: 268 seconds)
2023-05-02 08:42:37 +0200 <Inst_> maybe the par monad is what i'm looking for?
2023-05-02 08:45:25 +0200acidjnk(~acidjnk@p200300d6e715c460285fef55bd00a3c3.dip0.t-ipconnect.de)
2023-05-02 08:50:20 +0200gurkenglas(~gurkengla@dynamic-046-114-182-194.46.114.pool.telefonica.de) (Ping timeout: 250 seconds)
2023-05-02 08:51:25 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 240 seconds)
2023-05-02 08:59:50 +0200 <somerandomnick[m> is it that you want to short circuit a parallel evaluation of conditionals?
2023-05-02 09:00:12 +0200 <somerandomnick[m> where it is obvious how to achieve this for a sequence of conditionals
2023-05-02 09:02:22 +0200Gremlin8483(~Gremlin84@73.243.250.212)
2023-05-02 09:03:38 +0200 <Gremlin8483> hi, i dont write haskell but wondering how hard it is to build cabal from source, i use a source based distro and trying to build shellcheck which dep on cabal, wondering how difficult it is before i commit, i could also just use prebuilt shellcheck binary. appreciate any insights
2023-05-02 09:04:21 +0200 <Gremlin8483> however if its not too hard i would prefer to build
2023-05-02 09:04:26 +0200 <opqdonut> cabal is usually distributed with GHC, so i guess the bigger problem is building GHC
2023-05-02 09:04:39 +0200 <tomsmeding> Gremlin8483: do you have any other haskell packages already in the distro
2023-05-02 09:04:47 +0200 <tomsmeding> pandoc perhaps?
2023-05-02 09:04:49 +0200 <Gremlin8483> right this is my first time hearing about cabal and it seemed kinda overwheliming
2023-05-02 09:05:00 +0200 <Gremlin8483> tomsmeding no its the only one
2023-05-02 09:05:19 +0200 <Gremlin8483> is ghc a complex software?
2023-05-02 09:05:19 +0200 <opqdonut> is GHC (the haskell compiler) available?
2023-05-02 09:05:30 +0200 <opqdonut> I've heard it is a beast to build
2023-05-02 09:05:36 +0200 <opqdonut> but things might've gotten better over the years
2023-05-02 09:05:38 +0200 <Gremlin8483> i would have to build everything from scratch, i currently have 38 packages on my system total lol
2023-05-02 09:05:46 +0200 <tomsmeding> it's not a beast to build, but it does have its own build system that you have to make do what you want
2023-05-02 09:05:46 +0200 <Gremlin8483> maybe i just stick with the binary then
2023-05-02 09:05:51 +0200 <tomsmeding> ah lol
2023-05-02 09:06:04 +0200 <tomsmeding> you'd also have to decide what to do with haskell dependencies
2023-05-02 09:06:13 +0200 <tomsmeding> as in, other haskell libraries that shellcheck depends on
2023-05-02 09:06:27 +0200 <Gremlin8483> oh i see, sounds like its too difficult for me, but i appreciate the advice fellas
2023-05-02 09:06:49 +0200 <Gremlin8483> wish you all well!
2023-05-02 09:06:55 +0200son0p(~ff@181.136.122.143) (Ping timeout: 260 seconds)
2023-05-02 09:07:24 +0200 <tomsmeding> you could probably do it, none of the steps are individually very hard
2023-05-02 09:07:40 +0200 <Gremlin8483> ill consider it in the future
2023-05-02 09:07:42 +0200 <tomsmeding> but it's a whole lot of infrastructure (that you could indeed share for further haskell packages)
2023-05-02 09:07:54 +0200 <Gremlin8483> being source based i would like to be self sufficient and build every type of software
2023-05-02 09:08:02 +0200 <Gremlin8483> but right now might not be teh right time
2023-05-02 09:08:03 +0200 <tomsmeding> yeah it's cool
2023-05-02 09:08:24 +0200 <tomsmeding> perhaps if you're a bit further into also having things set up for other languages
2023-05-02 09:08:29 +0200 <Gremlin8483> i dont mind the infrastructure, will ahve a dedicated machine for builds
2023-05-02 09:08:38 +0200 <tomsmeding> e.g. python packages, or nodejs packages, or perl/ruby stuff
2023-05-02 09:08:56 +0200 <tomsmeding> then adding haskell packages will be more of the same but different :)
2023-05-02 09:09:14 +0200 <Gremlin8483> tbh i didnt even know software i used had haskell in it
2023-05-02 09:09:20 +0200 <Gremlin8483> but shell check is essential software to me
2023-05-02 09:09:37 +0200 <tomsmeding> but it's more well-known how packaging e.g. python stuff works, so starting there would be a good idea
2023-05-02 09:09:42 +0200 <tomsmeding> Gremlin8483: that's a haskell win I guess :)
2023-05-02 09:10:18 +0200 <Gremlin8483> you gotta rename it shellskellcheck or something
2023-05-02 09:10:21 +0200 <Gremlin8483> advertise it more
2023-05-02 09:10:42 +0200 <tomsmeding> opqdonut: iirc it's now just ./configure; hadrian/build; # grab a few coffees; cp _build/stage-2/ghc somewhere or so
2023-05-02 09:11:06 +0200 <tomsmeding> Gremlin8483: we're in functional programming because we like the interesting programming problems
2023-05-02 09:11:09 +0200 <tomsmeding> not because we like marketing
2023-05-02 09:11:09 +0200 <tomsmeding> :D
2023-05-02 09:11:24 +0200econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-05-02 09:11:34 +0200 <tomsmeding> (some do and have given haskell a serious boost over the past 10 years or so)
2023-05-02 09:11:38 +0200 <Gremlin8483> i spent some time studying functional a few weeks ago, im not a fper but the concepts are important
2023-05-02 09:11:39 +0200 <tomsmeding> *haskell usage
2023-05-02 09:11:46 +0200 <Gremlin8483> you cant ignore it as a programmer
2023-05-02 09:12:02 +0200 <mauke> Gremlin8483: you can't build ghc from source because it is written in haskell
2023-05-02 09:12:06 +0200 <tomsmeding> the ideas are slowly making their way into other languages, which was part of why haskell exists in the first place
2023-05-02 09:12:33 +0200 <tomsmeding> as a platform for working out language ideas and implementation ideas, to advance the field of programming language design and development
2023-05-02 09:12:41 +0200 <Gremlin8483> it doesnt have to be functional or nonfunctional, part of engineering istaking good parts from here and there
2023-05-02 09:12:41 +0200 <tomsmeding> mauke: oh good point lol
2023-05-02 09:13:08 +0200 <Gremlin8483> well how do the creaters do it then, break out the assembly?
2023-05-02 09:13:15 +0200 <Gremlin8483> punch cards?
2023-05-02 09:13:18 +0200 <tomsmeding> Gremlin8483: use an already-built previous-version ghc
2023-05-02 09:13:41 +0200 <tomsmeding> at some point in the past there were other useful implementations
2023-05-02 09:13:44 +0200 <mauke> btw, gcc is written in C++
2023-05-02 09:14:03 +0200 <tomsmeding> currently most haskell code is written using a bunch of language extensions that basically only GHC implements
2023-05-02 09:14:12 +0200 <tomsmeding> which is the same with gcc I guess :p
2023-05-02 09:14:42 +0200 <Gremlin8483> yea its in over my head here
2023-05-02 09:14:56 +0200 <tomsmeding> as in, gcc is written in C++ with gnu extensions
2023-05-02 09:14:56 +0200 <Gremlin8483> good to know, ill save some of this info for the future
2023-05-02 09:15:18 +0200 <Gremlin8483> my distro came with gcc so i didnt have to do anythign with it
2023-05-02 09:15:28 +0200 <tomsmeding> probably installed as a binary ;)
2023-05-02 09:15:35 +0200 <Gremlin8483> dont ask me how to compile the compiler
2023-05-02 09:15:37 +0200 <tomsmeding> you have to start _somewhere_
2023-05-02 09:15:44 +0200 <Gremlin8483> i think asking chatgpt that question would make it blow up
2023-05-02 09:15:59 +0200 <tomsmeding> aren't there projects for making a fully bootstrapped computing platform starting from assembly or something
2023-05-02 09:16:10 +0200 <Gremlin8483> all me know is make, make install
2023-05-02 09:16:29 +0200 <tomsmeding> but at some point you need to make specific choices, like how to type in the machine code for the first assembler :p
2023-05-02 09:17:03 +0200 <tomsmeding> what you consider the baseline of already-compiled stuff is a spectrum, there's multiple different possible choices -- assuming gcc is one of those
2023-05-02 09:17:16 +0200 <Gremlin8483> use haskell to compile gcc which then compiles cabal again, big brain
2023-05-02 09:17:22 +0200 <tomsmeding> *ghc
2023-05-02 09:17:26 +0200 <tomsmeding> ghc != gcc :p
2023-05-02 09:17:30 +0200 <tomsmeding> but yes
2023-05-02 09:17:32 +0200 <opqdonut> this is veering into offtopic, but guix is going all-in on the bootstrapping thing: https://guix.gnu.org/manual/en/html_node/Reduced-Binary-Seed-Bootstrap.html
2023-05-02 09:17:54 +0200 <Gremlin8483> thats a useful topic to me, what does that mean?
2023-05-02 09:18:02 +0200 <Gremlin8483> just they are using another os to build new one?
2023-05-02 09:18:16 +0200 <Gremlin8483> yes build thc, gotcha
2023-05-02 09:18:38 +0200 <opqdonut> basically, they have a sequence of simpler and simpler c compilers to be able to build gcc, and then build the world
2023-05-02 09:18:59 +0200 <Gremlin8483> man they must really hate user's cpu time
2023-05-02 09:19:14 +0200 <tomsmeding> opqdonut: impressive
2023-05-02 09:19:23 +0200 <Gremlin8483> maybe have the user glue together the silicon wafers int he cpu
2023-05-02 09:20:35 +0200 <tomsmeding> opqdonut: very offtopic, but "Work is ongoing to remove all binary blobs from our free software bootstrap stack, working towards a Full Source Bootstrap." -- how do you remove _all_ binary blobs, that sounds fundamentally impossible
2023-05-02 09:21:09 +0200 <Gremlin8483> better fire up the ghc then
2023-05-02 09:21:33 +0200 <opqdonut> tomsmeding: I think they start with a very simple binary (like tens of bytes) that can be verified by hand
2023-05-02 09:21:51 +0200 <opqdonut> I've been meaning to read up on how this stuff actually works, but there's mostly just lots of blog fluff
2023-05-02 09:22:18 +0200 <opqdonut> a bit more info here: https://www.gnu.org/software/mes/manual/mes.html#Stage0
2023-05-02 09:23:10 +0200 <tomsmeding> opqdonut: I see, that's cool
2023-05-02 09:24:01 +0200 <tomsmeding> yeah so they assume just some machine code input, very cool
2023-05-02 09:25:44 +0200jpds2(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2023-05-02 09:26:58 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-05-02 09:26:58 +0200pyook(~puke@user/puke) (Remote host closed the connection)
2023-05-02 09:27:22 +0200pyook(~puke@user/puke)
2023-05-02 09:32:51 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe)
2023-05-02 09:39:05 +0200jpds2(~jpds@gateway/tor-sasl/jpds)
2023-05-02 09:44:43 +0200lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-05-02 09:48:00 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:bef2:f17a:dedf:ac57)
2023-05-02 09:50:29 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-05-02 09:55:26 +0200machinedgod(~machinedg@198.53.218.113)
2023-05-02 10:03:14 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 10:03:46 +0200kuribas(~user@188.118.57.242)
2023-05-02 10:06:07 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-05-02 10:08:21 +0200cfricke(~cfricke@user/cfricke)
2023-05-02 10:08:40 +0200mmhat(~mmh@p200300f1c701f1d6ee086bfffe095315.dip0.t-ipconnect.de)
2023-05-02 10:10:47 +0200mmhat(~mmh@p200300f1c701f1d6ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-05-02 10:11:40 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe) (Quit: Konversation terminated!)
2023-05-02 10:16:59 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-05-02 10:17:27 +0200stefan-_(~cri@42dots.de) (Quit: ZNC 1.8.2+deb2build5 - https://znc.in)
2023-05-02 10:17:43 +0200stefan-_(~cri@42dots.de)
2023-05-02 10:23:52 +0200 <Athas> We are observing this error from a Haskell program:
2023-05-02 10:23:53 +0200 <Athas> mmap 4096 bytes at (nil): Cannot allocate memory
2023-05-02 10:23:58 +0200 <Athas> (Followed by SIGSEGV.)
2023-05-02 10:24:09 +0200 <Athas> Does this error indicate that the Haskell RTS is trying to map page zero?
2023-05-02 10:24:47 +0200 <geekosaur> no, it means the mmap address was unspecified, which means the OS can pick an address.
2023-05-02 10:25:01 +0200 <geekosaur> is this on linux 6.1 or later by any chance?
2023-05-02 10:25:16 +0200 <geekosaur> (kernel)
2023-05-02 10:25:31 +0200 <Athas> Most likely. (I'm forwarding a report from a user; hoping to get more information soon.)
2023-05-02 10:27:44 +0200 <geekosaur> kernels after a certain version switched to a new memory management system which is buggy. there's a hotfix which hasn't been committed yet, in the meantime there's an ugly LD_PRELOAD hack to work around it
2023-05-02 10:29:51 +0200 <merijn> Athas: There's a linux kernel bug that causes that, afaik
2023-05-02 10:30:05 +0200 <Athas> OK, I will blame my user.
2023-05-02 10:30:10 +0200 <geekosaur> http://paste.debian.net/1274454/ is the hack, if it works then you're hitting the maple-tree implementation bug and you need https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git/commit/?h=mm-hotfixes-unstable&id=aa4e… to fix it
2023-05-02 10:30:41 +0200 <geekosaur> or use ghc 9.4+ which changed how they mmap in a way that avoids the bug
2023-05-02 10:30:59 +0200 <Athas> I'm curious why I'm not hitting it myself. I use GHC 9.2.6 and Linux 6.1.25.
2023-05-02 10:31:01 +0200 <merijn> Athas: https://bbs.archlinux.org/viewtopic.php?id=282429
2023-05-02 10:31:13 +0200 <merijn> This bug: https://git.kernel.org/pub/scm/linux/kernel/git/stable/stable-queue.git/commit/queue-6.2/maple_tre…
2023-05-02 10:33:44 +0200kuribas(~user@188.118.57.242) (Read error: Connection reset by peer)
2023-05-02 10:34:02 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-05-02 10:35:34 +0200 <kuribas> If I have a isPermutationOf b, b isPermutationOf c => a isPermutationOf c, can I say that isPermutationOf is transitive?
2023-05-02 10:36:24 +0200 <Athas> Yes, isn't that the definition of transitivity?
2023-05-02 10:37:38 +0200jinsl-(~jinsl@2408:8207:2558:8870:211:32ff:fec8:6aea) (Quit: ZNC - https://znc.in)
2023-05-02 10:37:55 +0200jinsl(~jinsl@123.120.169.188)
2023-05-02 10:38:02 +0200 <kuribas> I think so
2023-05-02 10:39:00 +0200 <kuribas> And symmetry?
2023-05-02 10:39:43 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Remote host closed the connection)
2023-05-02 10:41:55 +0200wiosna(~karangura@209.166.121.87)
2023-05-02 10:42:12 +0200 <wiosna> hello haskellers
2023-05-02 10:42:15 +0200 <kuribas> a isPermutationOf b => b isPermutationOf a
2023-05-02 10:42:25 +0200 <wiosna> seems to be right
2023-05-02 10:42:53 +0200 <wiosna> what is everyone's favorite fibonacci implementation
2023-05-02 10:43:21 +0200 <merijn> > let fibs = 0 : 1 : zipWith (+) fibs (drop 1 fibs) in fibs
2023-05-02 10:43:23 +0200 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,...
2023-05-02 10:43:24 +0200 <kuribas> the matrix version
2023-05-02 10:43:45 +0200 <merijn> > let fibs = 0 : 1 : zipWith (+) fibs (drop 1 fibs) in fibs !! 1000000
2023-05-02 10:43:50 +0200 <kuribas> well, it's my favorite, not everyones
2023-05-02 10:43:51 +0200 <lambdabot> mueval-core: Time limit exceeded
2023-05-02 10:43:55 +0200 <merijn> ok, maybe that was excessive xD
2023-05-02 10:43:58 +0200 <merijn> > let fibs = 0 : 1 : zipWith (+) fibs (drop 1 fibs) in fibs !! 1000
2023-05-02 10:44:00 +0200 <lambdabot> 4346655768693745643568852767504062580256466051737178040248172908953655541794...
2023-05-02 10:46:30 +0200 <wiosna> wow this bot is so cool
2023-05-02 10:48:38 +0200phma(phma@2001:5b0:215a:e9f8:70e:a131:7bd8:ec6) (Read error: Connection reset by peer)
2023-05-02 10:49:15 +0200phma(~phma@host-67-44-208-157.hnremote.net)
2023-05-02 10:56:26 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp)
2023-05-02 10:56:52 +0200gurkenglas(~gurkengla@dynamic-046-114-182-194.46.114.pool.telefonica.de)
2023-05-02 11:01:20 +0200chexum_(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 240 seconds)
2023-05-02 11:01:56 +0200chexum(~quassel@gateway/tor-sasl/chexum)
2023-05-02 11:05:06 +0200shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 250 seconds)
2023-05-02 11:16:18 +0200czy(~user@host-140-24.ilcub310.champaign.il.us.clients.pavlovmedia.net)
2023-05-02 11:30:11 +0200JScript(~JScript@103.137.12.134)
2023-05-02 11:30:14 +0200JScript(~JScript@103.137.12.134) (Max SendQ exceeded)
2023-05-02 11:30:44 +0200JScript(~JScript@103.137.12.134)
2023-05-02 11:39:31 +0200 <mikko> is it possible to have "specialized" instances of a class like this https://bpa.st/ZRY32
2023-05-02 11:39:51 +0200 <mikko> so it would have a default implementation for every type that implements Show but some types might have a more specific implementation
2023-05-02 11:40:12 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 11:40:24 +0200ubert1(~Thunderbi@2a02:8109:abc0:6434:e31:8ae3:609:552d)
2023-05-02 11:40:53 +0200 <geekosaur> take a look at https://downloads.haskell.org/ghc/9.6.1/docs/users_guide/exts/default_signatures.html
2023-05-02 11:41:42 +0200 <geekosaur> that said, if you don't need a more specific type for the default then you don't need an extension; you can simply provide a default implementation in the class definition
2023-05-02 11:44:32 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Ping timeout: 250 seconds)
2023-05-02 11:52:09 +0200bontaq(~user@69.119.155.132) (Ping timeout: 265 seconds)
2023-05-02 11:52:46 +0200wiosna(~karangura@209.166.121.87) (Ping timeout: 268 seconds)
2023-05-02 11:53:18 +0200 <geekosaur> oh, sorry, you can not provide a default instance for all `Show`able types
2023-05-02 11:53:30 +0200 <geekosaur> it will overlap with every other instance
2023-05-02 11:54:48 +0200 <mikko> ah that explains why i'm having trouble getting it to compile
2023-05-02 11:55:36 +0200 <geekosaur> the rule is, contexts on an instance are checked at the use site, instance selection does not take contexts into account
2023-05-02 11:55:37 +0200marinelli(~weechat@gateway/tor-sasl/marinelli)
2023-05-02 11:56:33 +0200 <geekosaur> and can't because the instance selection may take place in code that doesn't know and may select the wrong instance as a result
2023-05-02 11:57:00 +0200 <geekosaur> (it only needs to know about the class to compile)
2023-05-02 12:00:21 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de) (Quit: leaving)
2023-05-02 12:10:51 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp) (Ping timeout: 248 seconds)
2023-05-02 12:12:37 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp)
2023-05-02 12:13:17 +0200 <mikko> are there any workarounds besides writing an instance separately for each type implementing Show?
2023-05-02 12:14:27 +0200 <dminuoso> mikko: Yes, default signatures like geekosaur mentioned.
2023-05-02 12:14:49 +0200 <dminuoso> But dispatching based on whether or not an instance exists doesn't really work.
2023-05-02 12:15:44 +0200 <dminuoso> The primary reason is that you can't supply evidence that an instance does *not* exist.
2023-05-02 12:15:56 +0200 <dminuoso> You can only supply evidence that it does.
2023-05-02 12:17:06 +0200 <mikko> with that in mind, how would you implement something like this?
2023-05-02 12:17:40 +0200 <dminuoso> Well so in principle you can have that instance for Joinable
2023-05-02 12:17:55 +0200 <dminuoso> If you make it Overlapping, then you can supply specific instances that will take precedence
2023-05-02 12:18:24 +0200 <mikko> doesn't that still have the same issue of dispatching based on whether or not an instance exists
2023-05-02 12:18:30 +0200 <dminuoso> Not quite
2023-05-02 12:18:50 +0200 <dminuoso> What you can use, is the instance selection algorithm
2023-05-02 12:19:03 +0200 <dminuoso> See https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/instances.html#overlapping-instances
2023-05-02 12:19:27 +0200 <mikko> it says status deprecated :/
2023-05-02 12:19:31 +0200 <dminuoso> That's fine
2023-05-02 12:19:55 +0200 <dminuoso> It's only the LANGUAGE extension that is deprecated.
2023-05-02 12:20:24 +0200 <dminuoso> But the {-# OVERLAPPING #-} and {-# OVERLAPPABLE #-} pragmas, as well as the rest of the semantics, holds.
2023-05-02 12:20:43 +0200 <dminuoso> I think the whole text should be moved into a different non-deprecated section for clarity
2023-05-02 12:20:48 +0200 <mikko> oh you mean i don't even need the language extension to do that?
2023-05-02 12:21:06 +0200 <dminuoso> Well, you need the {-# OVERLAPPING #-} or {-# OVERLAPPABLE #-} pragmas
2023-05-02 12:21:15 +0200 <dminuoso> In some sense they are extensions to the language
2023-05-02 12:21:20 +0200 <dminuoso> Just not formal LANGUAGE extensions
2023-05-02 12:21:26 +0200 <dminuoso> Strangely enough.
2023-05-02 12:21:43 +0200 <dminuoso> In that text, below, you can see:
2023-05-02 12:21:48 +0200 <dminuoso> ```Now suppose that, in some client module, we are searching for an instance of the target constraint (C ty1 .. tyn). The search works like this:```
2023-05-02 12:21:57 +0200 <dminuoso> The block that follows gives the exact semantics how GHC selects an instance.
2023-05-02 12:22:03 +0200 <dminuoso> Or how it fails
2023-05-02 12:22:34 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-05-02 12:22:45 +0200ub(~Thunderbi@p200300ecdf15588e8ba3eaebe9e1d757.dip0.t-ipconnect.de)
2023-05-02 12:23:08 +0200ubert(~Thunderbi@p548c9793.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-05-02 12:23:08 +0200ubert1ubert
2023-05-02 12:23:17 +0200 <dminuoso> Very very roughly, for your case, we can say if we have `instance {-# OVERLAPPABLE #-} Show a => Joinable a where ...` and `instance {-# OVERLAPPING #-} Joinable T` (note that you can leave one of the two pragmas away if you like), then it will always select the second instance if `Joinable T` is looked up.
2023-05-02 12:23:28 +0200 <dminuoso> And the reason is that `Joinable T` is "more specific" than `Joinable a`
2023-05-02 12:23:54 +0200 <dminuoso> Take additional note
2023-05-02 12:24:59 +0200 <dminuoso> `Eliminate any candidate IX for which there is another candidate IY such that ***both*** of the following hold:` (emphasis added by me)
2023-05-02 12:25:04 +0200 <ncf> mikko: here's an example of a class with a default implementation for Show instances https://hackage.haskell.org/package/prettyprinter-1.7.1/docs/Prettyprinter.html#t:Pretty
2023-05-02 12:25:05 +0200 <dminuoso> `IY is strictly more specific than IX`
2023-05-02 12:25:12 +0200 <dminuoso> `IX is overlappable or IY is overlapping`
2023-05-02 12:25:17 +0200 <mikko> nice, so this works: https://bpa.st/TMJE4
2023-05-02 12:25:48 +0200 <dminuoso> mikko: Great. For brevity you can leave OVERLAPPING away.
2023-05-02 12:26:00 +0200 <dminuoso> It's sufficient for just one side to have it.
2023-05-02 12:26:13 +0200 <dminuoso> And its just less typing work to have it on the less specific instance, since you only need it once.
2023-05-02 12:26:41 +0200 <mikko> got it, thanks
2023-05-02 12:27:13 +0200 <mikko> although i think i'll have to read through those docs a few more times before i really understand what's going on :D
2023-05-02 12:27:35 +0200 <dminuoso> It's very subtle and hard to grok for the average user.
2023-05-02 12:28:21 +0200 <dminuoso> mikko: Roughly we can condense is down to this: GHC will look up all matching instances. If no instance matches, it fails. If they match, it will "eliminate" any instance that is "strictly less specific *and* overlappable by the other"
2023-05-02 12:28:28 +0200 <dminuoso> By eliminate this means from the pool of potential instances.
2023-05-02 12:29:14 +0200 <dminuoso> And if only one remains, it will use it. If multiple remains - outside of other (here irrelevant) language features - it will error with "overlapping instances"
2023-05-02 12:29:56 +0200 <dminuoso> Ah well, in truth there's that extra final setp of in-scope constraints
2023-05-02 12:30:06 +0200 <dminuoso> And there's some very subtle relevancy:
2023-05-02 12:30:32 +0200 <dminuoso> Any constraints on an instance are not considered for instance *selection*
2023-05-02 12:31:16 +0200 <dminuoso> So given `instance Foo a => Bar a`, then `Foo` is not considered for the purpose of *selecting* an instance. Conversely this means `instance Foo a => Bar a` matches *all* types, irrespective of whether an instance Foo exists or not.
2023-05-02 12:31:37 +0200CiaoSen(~Jura@tmo-108-9.customers.d1-online.com) (Ping timeout: 268 seconds)
2023-05-02 12:31:39 +0200 <dminuoso> Which can be counter intuitive
2023-05-02 12:33:19 +0200euandreh(~Thunderbi@189.6.18.7)
2023-05-02 12:36:25 +0200 <dminuoso> So if you had `data S = S` (without a Show instance), and you did not have any overlapping/overlappable pragmas, and then wrote both `instance Show a => Joinable a ...` and `instance Joinable T`, you will have overlapping instances, even though it seems the first instance shouldn't be considered.
2023-05-02 12:36:48 +0200 <dminuoso> (Because the algorithm will not consider constraints for the purpose of selecting candidates)
2023-05-02 12:36:59 +0200 <dminuoso> Oh I meant `instance Joinable S`
2023-05-02 12:37:10 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp) (Ping timeout: 268 seconds)
2023-05-02 12:38:29 +0200paul_j(~user@2001:8b0:dea0:f3c9:cd47:c8b0:d6:5463) (Quit: Asta la vista)
2023-05-02 12:44:20 +0200wiosna(~karangura@209.166.121.87)
2023-05-02 12:56:33 +0200inversed(~inversed@bcdcac82.skybroadband.com)
2023-05-02 12:58:05 +0200 <tomsmeding> the fact that the instance head is not considered when selecting instances basically means that instance search is greedy
2023-05-02 12:58:12 +0200 <tomsmeding> it will never backtrack
2023-05-02 12:58:43 +0200 <tomsmeding> now the term "greedy" is not very precisely defined, but it may be helpful as intuition
2023-05-02 12:59:42 +0200 <tomsmeding> you can't do prolog with type class resolution
2023-05-02 12:59:46 +0200 <dminuoso> Mmm, greedy and backtracking are not mutually exclusive. This is in fact the reason many regex provide denial of service vectors.
2023-05-02 13:00:23 +0200 <dminuoso> Arguably greedyness can exponentially drive up backtracking
2023-05-02 13:01:56 +0200 <dminuoso> (Greedy is a mode of ambiguity resolution, no?)
2023-05-02 13:04:47 +0200jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 246 seconds)
2023-05-02 13:05:25 +0200 <fbytez> Is there a standard function like: `nullOr tr fls x = if null x then tr else fls` ?
2023-05-02 13:05:54 +0200 <fbytez> Like `either` and `maybe`.
2023-05-02 13:06:32 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 240 seconds)
2023-05-02 13:07:02 +0200 <tomsmeding> dminuoso: greedy is a mode of ambiguity resolution where there is always a way to full resolve the ambiguity
2023-05-02 13:07:06 +0200 <tomsmeding> *to fully
2023-05-02 13:07:16 +0200 <tomsmeding> I'd say if you're greedy, then you have no backtracking
2023-05-02 13:07:41 +0200 <dminuoso> tomsmeding: Consider a PCRE regex: .*foo
2023-05-02 13:07:43 +0200 <tomsmeding> :t \a b x -> if null x then a else b
2023-05-02 13:07:44 +0200 <lambdabot> Foldable t => p -> p -> t a -> p
2023-05-02 13:07:54 +0200 <dminuoso> tomsmeding: This will require some form of backtracking, otherwise it cannot ever match.
2023-05-02 13:08:06 +0200 <tomsmeding> @hoogle a -> a -> [b] -> a
2023-05-02 13:08:07 +0200 <lambdabot> No results found
2023-05-02 13:08:14 +0200 <dminuoso> At least if .* is resolved greedily.
2023-05-02 13:08:25 +0200 <tomsmeding> dminuoso: so then it can't be resolved greedily :p
2023-05-02 13:08:30 +0200 <tomsmeding> who says that regex matching is greedy
2023-05-02 13:08:39 +0200 <tomsmeding> I'd say it isn't
2023-05-02 13:08:40 +0200 <dminuoso> tomsmeding: greedy in regex means as much as possible.
2023-05-02 13:08:48 +0200 <tomsmeding> ah, different greedy
2023-05-02 13:08:55 +0200 <tomsmeding> greedy as in longest match, not greedy as in algorithm design
2023-05-02 13:09:19 +0200 <dminuoso> tomsmeding: How are they different?
2023-05-02 13:09:33 +0200 <tomsmeding> I guess my "greedy" is basically equivalent to "no backtracking"
2023-05-02 13:09:38 +0200 <tomsmeding> hence perhaps why you don't have a word for it :p
2023-05-02 13:09:47 +0200 <dminuoso> tomsmeding: longest match in regex is a greedy algorithm.
2023-05-02 13:09:54 +0200 <dminuoso> its a local optimization problem.
2023-05-02 13:09:54 +0200 <tomsmeding> dminuoso: https://en.wikipedia.org/wiki/Greedy_algorithm
2023-05-02 13:09:59 +0200 <dminuoso> Yes, I am aware.
2023-05-02 13:10:21 +0200 <dminuoso> Greedy algorithms are about local optimization, not global optimization.
2023-05-02 13:10:24 +0200 <tomsmeding> is there a greedy algorithm for matching regex?
2023-05-02 13:10:29 +0200 <tomsmeding> yes
2023-05-02 13:10:39 +0200 <dminuoso> tomsmeding: Of course, most regex employ greedy matching
2023-05-02 13:10:53 +0200 <tomsmeding> well, partially greedy, because they also backtrack
2023-05-02 13:10:54 +0200 <tomsmeding> ;)
2023-05-02 13:10:57 +0200 <dminuoso> Which is why `.*foo` will match `quuxfoo`
2023-05-02 13:11:02 +0200 <dminuoso> At least in most implementations
2023-05-02 13:11:10 +0200 <dminuoso> tomsmeding: those two are orthogonal.
2023-05-02 13:11:19 +0200 <tomsmeding> or if they NFA the thing and run the automaton, I'm not sure that's "greedy" by any useful definition
2023-05-02 13:11:39 +0200 <dminuoso> tomsmeding: the backtracking merely means that the locally chosen maximum wont work with the rest.
2023-05-02 13:11:56 +0200 <dminuoso> Which is why I said these two things go hand in hand in regex.
2023-05-02 13:11:59 +0200 <tomsmeding> right
2023-05-02 13:12:03 +0200 <dminuoso> You cant really have greedyness without backtracking
2023-05-02 13:12:06 +0200 <tomsmeding> in regex not
2023-05-02 13:12:14 +0200 <dminuoso> Well you could, it just woudlnt make them useful in most situations
2023-05-02 13:12:18 +0200 <tomsmeding> in instance selection yes, precisely because of this head-doesn't-matter restriction!
2023-05-02 13:12:31 +0200 <tomsmeding> that's the whole point
2023-05-02 13:12:37 +0200 <tomsmeding> regex matching cannot be _fully_ greedy
2023-05-02 13:12:47 +0200 <tomsmeding> the problem is too hard for that
2023-05-02 13:12:52 +0200 <dminuoso> "fully greedy" would require some definition of what that even means
2023-05-02 13:13:04 +0200 <dminuoso> given that greedyness implicitly is about *local* optimization, it sounds like a contradiction
2023-05-02 13:13:11 +0200 <tomsmeding> whenever you have a choice, choose one and commit to that choice
2023-05-02 13:13:25 +0200 <tomsmeding> "fully greedy" being that all choices in the algorithm are local
2023-05-02 13:13:27 +0200 <dminuoso> tomsmeding: oh, no that is simple.
2023-05-02 13:13:32 +0200 <dminuoso> that is excessively simple to do for regex
2023-05-02 13:13:36 +0200 <dminuoso> it just wouldnt be very useful
2023-05-02 13:13:38 +0200freeside(~mengwong@122.11.248.245)
2023-05-02 13:13:46 +0200 <tomsmeding> oh sure
2023-05-02 13:14:01 +0200 <tomsmeding> as in, it wouldn't match "quuxfoo" with /.*foo/ ?
2023-05-02 13:14:27 +0200 <dminuoso> Plenty of regex can even turn off backtracking on portions
2023-05-02 13:14:32 +0200 <dminuoso> tomsmeding: right.
2023-05-02 13:14:52 +0200 <freeside> question re WASM -- I see Asterius has been mothballed on Github in favour of the merged WASM backend in 9.6, but how do I build something that has significant dependencies? If I understand correctly, stack and cabal aren't fully wasm-enabled
2023-05-02 13:15:12 +0200 <tomsmeding> dminuoso: yes of course, for many problems for which there is no sensible greedy solution, you can still try to write a greedy algorithm and see how far it gets. Sometimes that's very useful
2023-05-02 13:15:40 +0200 <tomsmeding> dminuoso: so my point about instance selection is that the algorithm there _is_ greedy -- as opposed to the prolog semantics, which aren't (fully)
2023-05-02 13:15:44 +0200 <dminuoso> tomsmeding: like I said, I think its silly to call this "fully greedy"
2023-05-02 13:15:51 +0200 <dminuoso> its still greedy, just without backtracking
2023-05-02 13:16:01 +0200 <dminuoso> backtracking is about undoing the greedy choices
2023-05-02 13:16:02 +0200 <tomsmeding> well I'm only introducing "fully greedy" because what you call "greedy" I'd call "partially greedy" :p
2023-05-02 13:16:16 +0200 <dminuoso> well, "partially greedy" is certainly uncommon terminology
2023-05-02 13:16:32 +0200 <tomsmeding> yeah, because it's not a greedy algorithm if it backtracks in common terminology :p
2023-05-02 13:16:44 +0200 <dminuoso> because greediness in all algorithmic contexts is always about expanding to some local maximum
2023-05-02 13:17:01 +0200 <dminuoso> tomsmeding: I guess it depends on the perspecftive.
2023-05-02 13:17:06 +0200 <tomsmeding> anyway this is offtopic :p
2023-05-02 13:17:08 +0200 <dminuoso> right
2023-05-02 13:18:03 +0200 <dminuoso> freeside: I feel WASM hit the scene without much documentation or information how to do anything with it.
2023-05-02 13:18:08 +0200 <dminuoso> It feels rushed.
2023-05-02 13:19:17 +0200 <dminuoso> https://cabal.readthedocs.io/en/stable/search.html?q=wasm&check_keywords=yes&area=default
2023-05-02 13:19:20 +0200 <dminuoso> This is not comforting.
2023-05-02 13:19:20 +0200 <freeside> mmm. I'm seeing asterius's readme has an ahc-cabal for building things with deps, but, like you say, now that the repo is archived, one is left wondering if that functionality made it into regular cabal
2023-05-02 13:19:31 +0200 <dminuoso> While I understand these projects are separate, from a user experience point of view its a bit sad.
2023-05-02 13:20:05 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-05-02 13:20:15 +0200 <dminuoso> https://gitlab.haskell.org/ghc/ghc-wasm-meta
2023-05-02 13:20:23 +0200 <dminuoso> This is all the documentation you are being given right now
2023-05-02 13:20:41 +0200 <tomsmeding> wasm in ghc is definitely not ready for intensive use, but I guess the people working on asterius/ghcjs are now working on making wasm in ghc better, so naturally there is no time any more for asterius/ghcjs
2023-05-02 13:21:20 +0200 <tomsmeding> so the result is that the new thing is not yet ready when the old thing is mothballed -- nothing to be done about that, and now at least we _have_ a partially-complete ghc wasm backend :p
2023-05-02 13:21:25 +0200 <tomsmeding> as opposed to none
2023-05-02 13:21:42 +0200 <dminuoso> Sure, I think no mention of something rather incomplete in the release notes would have been better
2023-05-02 13:22:02 +0200 <dminuoso> Perhaps a teaser, but some "we now have wasm, GOOD LUCK!" is not very helpful
2023-05-02 13:22:44 +0200 <freeside> is "partially complete" like "partially greedy"
2023-05-02 13:23:00 +0200 <dminuoso> Only tomsmeding can say!
2023-05-02 13:28:30 +0200 <tomsmeding> freeside: :')
2023-05-02 13:29:01 +0200 <tomsmeding> my "partially greedy" meant "some components of the algorithm are greedy"
2023-05-02 13:29:08 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de)
2023-05-02 13:29:37 +0200 <tomsmeding> my "partially complete" meant "(more-than-half)-complete"
2023-05-02 13:29:52 +0200ubert(~Thunderbi@2a02:8109:abc0:6434:e31:8ae3:609:552d) (Remote host closed the connection)
2023-05-02 13:29:52 +0200ububert
2023-05-02 13:29:55 +0200 <tomsmeding> I first wanted to write "half-complete" but then realised that that would be an unfair characterisation of the work
2023-05-02 13:30:05 +0200ubert1(~Thunderbi@2a02:8109:abc0:6434:f753:ade8:fcc8:e633)
2023-05-02 13:30:26 +0200 <tomsmeding> it _looks_ half-complete from the outside, but I don't think that's accurate in terms of work hours
2023-05-02 13:31:18 +0200 <dminuoso> I have a job that produces log output. Some external services want to visualize that log output and do so by polling. With the polling I would get some offset (to skip any chunks the receiver has seen so far).
2023-05-02 13:31:34 +0200 <dminuoso> The log is, currently anyway, held in memory only
2023-05-02 13:31:59 +0200 <dminuoso> While its being polled, the producer amends it
2023-05-02 13:32:05 +0200freeside(~mengwong@122.11.248.245) (Ping timeout: 246 seconds)
2023-05-02 13:32:28 +0200 <dminuoso> What kind of data structure would be ideally suited here? Naively Id just use files because that offers me exactly the interface needed.
2023-05-02 13:35:28 +0200wiosna(~karangura@209.166.121.87) (Ping timeout: 248 seconds)
2023-05-02 13:35:54 +0200 <tomsmeding> dminuoso: naively just a Map from (monotonically increasing) ID to log message, where an offset is simply the ID of the last-seen message
2023-05-02 13:37:01 +0200 <tomsmeding> can chunk up stuff to reduce Map overhead, and one can probably figure out a way to do regular chunking, GC style, in a way that it doesn't increase time complexity
2023-05-02 13:37:23 +0200 <dminuoso> Mmm that sounds just wrong.
2023-05-02 13:39:48 +0200 <dminuoso> Perhaps I should just admit that this is a C-style problem.
2023-05-02 13:40:10 +0200 <tomsmeding> I mean, you could mutable vector your way out of this :p
2023-05-02 13:41:06 +0200 <dminuoso> Mm, do I get much benefit from an unboxed mutable vector over just holding a `ForeignPtr Word8`?
2023-05-02 13:41:43 +0200 <dminuoso> The `ForeignPtr` can trivially be turned into ByteString at least!
2023-05-02 13:42:10 +0200 <dminuoso> So even a simple offset n is just `BS.drop n`
2023-05-02 13:42:50 +0200 <tomsmeding> not if you don't want to any of the meaning of the word8s :p
2023-05-02 13:44:03 +0200 <dminuoso> My contract will be that its just terminal data (i.e. unicode)
2023-05-02 13:44:07 +0200 <dminuoso> I wont even pretend to verify this.
2023-05-02 13:44:18 +0200 <dminuoso> (Any decoding bug will be handled leniently anyway)
2023-05-02 13:44:40 +0200 <dminuoso> So its just utf8 encoded stuff.
2023-05-02 13:45:03 +0200 <tomsmeding> then go buffer of Word8 all the way
2023-05-02 13:46:05 +0200 <dminuoso> Heck, I could even steal the buffer and stuff it into a Text!
2023-05-02 13:46:09 +0200 <dminuoso> as long as I use text-2.0
2023-05-02 13:46:17 +0200 <dminuoso> :P
2023-05-02 13:46:20 +0200 <dminuoso> What could possibly go wrong!
2023-05-02 13:46:53 +0200 <dminuoso> But on a more serious note, I can just use decodeUtf8Lenient as well
2023-05-02 13:47:41 +0200wiosna(~karangura@209.166.121.87)
2023-05-02 13:52:10 +0200wiosna(~karangura@209.166.121.87) (Ping timeout: 260 seconds)
2023-05-02 13:55:13 +0200CiaoSen(~Jura@tmo-108-9.customers.d1-online.com)
2023-05-02 14:03:23 +0200 <merijn> dminuoso: You can turn the ForeignPtr into a Storable vector easily too :p
2023-05-02 14:06:22 +0200 <dminuoso> Im very very tempted to just use files anyway, because the entire interface is already there.
2023-05-02 14:06:28 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 276 seconds)
2023-05-02 14:08:22 +0200euandreh(~Thunderbi@189.6.18.7)
2023-05-02 14:26:07 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-05-02 14:28:16 +0200trev(~trev@user/trev) (Quit: trev)
2023-05-02 14:32:43 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-05-02 14:32:58 +0200tr_ev(~trev@user/trev)
2023-05-02 14:34:00 +0200Me-me(~Me-me@user/me-me) (Quit: Something has gone terribly, terribly wrong, that being that I'm not here any more.)
2023-05-02 14:36:41 +0200euandreh1(~Thunderbi@189.6.18.7)
2023-05-02 14:37:05 +0200euandreh(~Thunderbi@189.6.18.7) (Read error: Connection reset by peer)
2023-05-02 14:37:06 +0200euandreh1euandreh
2023-05-02 14:39:49 +0200fryguybob(~fryguybob@cpe-24-94-50-22.stny.res.rr.com) (Quit: leaving)
2023-05-02 14:43:00 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 14:47:20 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Ping timeout: 246 seconds)
2023-05-02 14:54:14 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-05-02 14:58:20 +0200tr_evtrev
2023-05-02 15:00:21 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-05-02 15:00:24 +0200vulfe(~vulfe@207.229.148.168)
2023-05-02 15:09:49 +0200extor(~extor@ns3018124.ip-149-202-82.eu) (Remote host closed the connection)
2023-05-02 15:16:46 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se)
2023-05-02 15:16:48 +0200acidjnk(~acidjnk@p200300d6e715c460285fef55bd00a3c3.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2023-05-02 15:20:31 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp)
2023-05-02 15:22:08 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 248 seconds)
2023-05-02 15:22:35 +0200 <tomsmeding> dminuoso: use files in a tmpfs
2023-05-02 15:23:30 +0200euandreh(~Thunderbi@189.6.18.7)
2023-05-02 15:23:43 +0200 <dminuoso> tomsmeding: If only this was controllable from haskell itself. :p
2023-05-02 15:23:57 +0200 <dminuoso> withTmpfsTemporaryFile
2023-05-02 15:24:23 +0200 <tomsmeding> hah
2023-05-02 15:24:30 +0200 <tomsmeding> I guess needing this is pretty niche
2023-05-02 15:27:10 +0200 <dminuoso> Yeah.
2023-05-02 15:30:02 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se) (Quit: Client closed)
2023-05-02 15:32:29 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-05-02 15:32:29 +0200wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-05-02 15:32:29 +0200wroathe(~wroathe@user/wroathe)
2023-05-02 15:36:39 +0200extor(~extor@2001:41d0:1004:636::1)
2023-05-02 15:45:25 +0200wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2023-05-02 15:48:39 +0200thegeekinside(~thegeekin@189.217.90.138)
2023-05-02 15:48:56 +0200caryhartline(~caryhartl@2600:1700:2d0:8d30:8c38:7008:d307:dea1) (Quit: caryhartline)
2023-05-02 15:59:59 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-05-02 16:03:20 +0200vulfe(~vulfe@207.229.148.168) (Ping timeout: 246 seconds)
2023-05-02 16:03:51 +0200extor(~extor@2001:41d0:1004:636::1) (Quit: ZNC 1.8.2+deb2build5 - https://znc.in)
2023-05-02 16:04:03 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se)
2023-05-02 16:05:13 +0200vulfe(~vulfe@207.229.148.168)
2023-05-02 16:06:02 +0200extor(~extor@ns3018124.ip-149-202-82.eu)
2023-05-02 16:08:00 +0200catern(~sbaugh@2604:2000:8fc0:b:a9c7:866a:bf36:3407) (Remote host closed the connection)
2023-05-02 16:08:27 +0200vulfe(~vulfe@207.229.148.168) (Remote host closed the connection)
2023-05-02 16:08:43 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 248 seconds)
2023-05-02 16:15:17 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au)
2023-05-02 16:15:17 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au) (Changing host)
2023-05-02 16:15:17 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-05-02 16:21:11 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-05-02 16:21:30 +0200CiaoSen(~Jura@tmo-108-9.customers.d1-online.com) (Ping timeout: 260 seconds)
2023-05-02 16:23:49 +0200shriekingnoise(~shrieking@186.137.175.87)
2023-05-02 16:24:32 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 248 seconds)
2023-05-02 16:35:12 +0200wiosna(~karangura@209.166.121.87)
2023-05-02 16:38:04 +0200img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2023-05-02 16:38:52 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se) (Quit: Client closed)
2023-05-02 16:40:50 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au)
2023-05-02 16:40:50 +0200dibblego(~dibblego@122-199-1-30.ip4.superloop.au) (Changing host)
2023-05-02 16:40:50 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-05-02 16:43:01 +0200img(~img@user/img)
2023-05-02 16:47:10 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se)
2023-05-02 16:50:14 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 16:50:15 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-05-02 16:51:47 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 16:53:15 +0200 <ncf> does ghc make any difference between using | otherwise and just repeating the pattern with no guard?
2023-05-02 16:53:44 +0200 <ncf> e.g. f x | p = ...; | otherwise = ... vs f x | p = ...; f x = ...
2023-05-02 16:54:17 +0200 <merijn> maybe :p
2023-05-02 16:54:35 +0200ddellacosta(~ddellacos@146.70.171.166) (Ping timeout: 248 seconds)
2023-05-02 16:54:44 +0200 <merijn> To get a real answer, inspect the bird entrails^H^H^H^H^H^H^H core
2023-05-02 16:55:09 +0200cheater(~Username@user/cheater)
2023-05-02 16:55:15 +0200 <ncf> i feared as much
2023-05-02 16:55:24 +0200 <merijn> Why?
2023-05-02 16:55:38 +0200 <ncf> i'm lazy
2023-05-02 16:55:51 +0200 <merijn> ncf: I meant more like "why would that even matter?"
2023-05-02 16:56:04 +0200 <merijn> That seems like an incredibly niche thing to worry about
2023-05-02 16:56:14 +0200 <ncf> just wondering if there's any reason to prefer one over the other beyond style
2023-05-02 16:56:22 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-05-02 16:56:26 +0200 <merijn> doubt it
2023-05-02 16:57:03 +0200 <geekosaur> I would be very surprised if it made a difference
2023-05-02 16:57:24 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 268 seconds)
2023-05-02 17:02:18 +0200rlj(~rlj@c-5eea62ba-74736162.cust.telenor.se) (Ping timeout: 245 seconds)
2023-05-02 17:04:04 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:bef2:f17a:dedf:ac57) (Quit: WeeChat 2.8)
2023-05-02 17:09:41 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 17:12:53 +0200 <monochrom> At Pareto equilibrium there is no difference. :)
2023-05-02 17:13:59 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 246 seconds)
2023-05-02 17:18:03 +0200xff0x_(~xff0x@fsa056e3ab.kytj202.ap.nuro.jp) (Ping timeout: 248 seconds)
2023-05-02 17:21:02 +0200Square(~Square4@user/square)
2023-05-02 17:27:49 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 17:33:49 +0200wiosna(~karangura@209.166.121.87) (Ping timeout: 276 seconds)
2023-05-02 17:34:49 +0200nick4(~nick@wsip-174-78-110-18.pn.at.cox.net)
2023-05-02 17:35:07 +0200gurkenglas(~gurkengla@dynamic-046-114-182-194.46.114.pool.telefonica.de) (Ping timeout: 276 seconds)
2023-05-02 17:35:54 +0200Square(~Square4@user/square) (Quit: Leaving)
2023-05-02 17:36:24 +0200Square(~Square4@user/square)
2023-05-02 17:36:36 +0200gurkenglas(~gurkengla@dynamic-046-114-183-223.46.114.pool.telefonica.de)
2023-05-02 17:45:37 +0200enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-05-02 17:49:49 +0200famubu(~julinuser@user/famubu)
2023-05-02 17:50:44 +0200econo(uid147250@user/econo)
2023-05-02 17:50:51 +0200 <famubu> Hi. In haskell-mode of emacs, is there a way to disable the red underlining that shows up when there are erros in the code? Ideally a way to toggle it on and off? It's quite annoying when one is trying to figure out the error. Does anyone know how to do this?
2023-05-02 17:54:22 +0200rlj(~rlj@194-218-34-180.customer.telia.com)
2023-05-02 17:54:41 +0200 <probie> Just the underlines, or the error checking entirely?
2023-05-02 18:02:56 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-05-02 18:06:33 +0200Sgeo(~Sgeo@user/sgeo)
2023-05-02 18:06:44 +0200machinedgod(~machinedg@198.53.218.113) (Ping timeout: 265 seconds)
2023-05-02 18:06:48 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 18:08:55 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-05-02 18:09:17 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Remote host closed the connection)
2023-05-02 18:11:24 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
2023-05-02 18:11:36 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 265 seconds)
2023-05-02 18:11:44 +0200ub(~Thunderbi@p200300ecdf15583fadacaf30e6b5a958.dip0.t-ipconnect.de)
2023-05-02 18:11:47 +0200ubert(~Thunderbi@p200300ecdf15588e8ba3eaebe9e1d757.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-05-02 18:11:48 +0200ubert1ubert
2023-05-02 18:13:16 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-05-02 18:15:42 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-05-02 18:17:52 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 18:22:43 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 265 seconds)
2023-05-02 18:32:59 +0200coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-05-02 18:36:36 +0200mbuf(~Shakthi@49.207.178.186) (Quit: Leaving)
2023-05-02 18:37:58 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 18:37:58 +0200stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-05-02 18:38:25 +0200stiell_(~stiell@gateway/tor-sasl/stiell)
2023-05-02 18:50:22 +0200acidjnk(~acidjnk@p200300d6e715c400492023c9075c5278.dip0.t-ipconnect.de)
2023-05-02 18:51:03 +0200ddellacosta(~ddellacos@143.244.47.86)
2023-05-02 19:00:21 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 19:03:30 +0200kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Ping timeout: 250 seconds)
2023-05-02 19:05:55 +0200 <Hecate> https://discourse.haskell.org/t/manual-qa-for-cabal-install/6225
2023-05-02 19:06:05 +0200Square(~Square4@user/square) (Ping timeout: 240 seconds)
2023-05-02 19:07:02 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 246 seconds)
2023-05-02 19:12:37 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 276 seconds)
2023-05-02 19:13:24 +0200 <sm> famubu: M-x customize-group haskell<TAB> and you'll
2023-05-02 19:13:24 +0200 <sm> probably find it
2023-05-02 19:21:08 +0200tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2023-05-02 19:26:15 +0200puke(~puke@user/puke) (Remote host closed the connection)
2023-05-02 19:26:21 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 19:26:40 +0200puke(~puke@user/puke)
2023-05-02 19:27:25 +0200marinelli(~weechat@gateway/tor-sasl/marinelli) (Remote host closed the connection)
2023-05-02 19:27:26 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-05-02 19:30:45 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2023-05-02 19:32:54 +0200kuribas(~user@2a02:1808:83:eb5c:7e9d:6d4d:1da8:cade)
2023-05-02 19:33:37 +0200cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.8)
2023-05-02 19:35:16 +0200kuribas(~user@2a02:1808:83:eb5c:7e9d:6d4d:1da8:cade) (Remote host closed the connection)
2023-05-02 19:36:03 +0200mikail(~mikail@2a02:c7c:609d:c900:4cef:c956:5d99:43ab)
2023-05-02 19:55:53 +0200johnjaye(~pi@072-181-052-090.res.spectrum.com) (Read error: Connection reset by peer)
2023-05-02 19:58:47 +0200eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-05-02 19:59:11 +0200johnjaye(~pi@072-181-052-090.res.spectrum.com)
2023-05-02 20:05:07 +0200puke(~puke@user/puke) (Quit: puke)
2023-05-02 20:07:06 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 20:11:12 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 248 seconds)
2023-05-02 20:11:19 +0200mikail(~mikail@2a02:c7c:609d:c900:4cef:c956:5d99:43ab) (Ping timeout: 256 seconds)
2023-05-02 20:12:17 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 20:12:48 +0200ray_(~ray@2405:201:680a:b174:ca64:ecc9:98b0:81d3)
2023-05-02 20:13:12 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 20:16:17 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Remote host closed the connection)
2023-05-02 20:16:57 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 20:17:11 +0200ub1(~Thunderbi@p548c9793.dip0.t-ipconnect.de)
2023-05-02 20:17:44 +0200ub(~Thunderbi@p200300ecdf15583fadacaf30e6b5a958.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-05-02 20:17:44 +0200polyphem(~polyphem@ip-109-43-49-185.web.vodafone.de)
2023-05-02 20:19:27 +0200ub1ub
2023-05-02 20:22:54 +0200 <polyphem> hi, i once read a funny quote about javaEnterpriseBoolFactory or something . If you know what i mean , do you have any pointers ?
2023-05-02 20:23:22 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Ping timeout: 268 seconds)
2023-05-02 20:26:01 +0200 <monochrom> In priv msg with lambdabot, try "@quote factory". Try multiple times because each time it randomly picks one.
2023-05-02 20:27:49 +0200wiosna(~karangura@209.166.121.87)
2023-05-02 20:27:57 +0200 <polyphem> monochrom: thank you , will try
2023-05-02 20:28:57 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-05-02 20:34:14 +0200wiosna(~karangura@209.166.121.87) (Ping timeout: 246 seconds)
2023-05-02 20:34:38 +0200hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com) (Remote host closed the connection)
2023-05-02 20:36:28 +0200hgolden(~hgolden@cpe-172-251-233-141.socal.res.rr.com)
2023-05-02 20:37:54 +0200yaroot_(~yaroot@p3099038-ipngn6001souka.saitama.ocn.ne.jp)
2023-05-02 20:38:38 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 20:39:16 +0200yaroot(~yaroot@2400:4052:ac0:d900:1cf4:2aff:fe51:c04c) (Ping timeout: 250 seconds)
2023-05-02 20:39:16 +0200yaroot_yaroot
2023-05-02 20:42:18 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-05-02 20:42:44 +0200ec(~ec@gateway/tor-sasl/ec)
2023-05-02 20:42:59 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Ping timeout: 246 seconds)
2023-05-02 20:44:14 +0200thegeekinside(~thegeekin@189.217.90.138) (Remote host closed the connection)
2023-05-02 20:46:48 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
2023-05-02 20:49:07 +0200 <polyphem> i think it was in a george wilson talk, he is so funny, can't recall which one
2023-05-02 20:50:21 +0200 <[exa]> polyphem: it might have been embedded in maven source code
2023-05-02 20:52:03 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de)
2023-05-02 20:52:49 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Remote host closed the connection)
2023-05-02 20:53:49 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 20:55:27 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 20:56:10 +0200thaumavorio(~thaumavor@thaumavor.io) (Quit: ZNC 1.8.2 - https://znc.in)
2023-05-02 20:57:19 +0200mikail(~mikail@2a02:c7c:609d:c900:4cef:c956:5d99:43ab)
2023-05-02 20:57:21 +0200thaumavorio(~thaumavor@thaumavor.io)
2023-05-02 20:57:47 +0200mikail(~mikail@2a02:c7c:609d:c900:4cef:c956:5d99:43ab) (Client Quit)
2023-05-02 21:02:27 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 21:02:38 +0200johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net)
2023-05-02 21:07:09 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 268 seconds)
2023-05-02 21:22:20 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Remote host closed the connection)
2023-05-02 21:27:36 +0200 <tomsmeding> polyphem: probably not what you're referring to, but it's related https://codegolf.stackexchange.com/questions/4838/most-complex-hello-world-program-you-can-justify
2023-05-02 21:29:09 +0200pavonia(~user@user/siracusa)
2023-05-02 21:38:36 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Quit: o/)
2023-05-02 21:39:23 +0200 <dminuoso> famubu: What red underlining are you referring to exactly?
2023-05-02 21:40:28 +0200 <dminuoso> haskell-mode neither has the ability to detect compilation errors, nor to hilight them
2023-05-02 21:41:20 +0200 <dminuoso> Are you perhaps talking about lsp-haskell + lsp-mode + flycheck?
2023-05-02 21:41:50 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Remote host closed the connection)
2023-05-02 21:42:02 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-05-02 21:42:26 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 21:43:04 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 21:46:21 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 21:46:25 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member)
2023-05-02 21:47:14 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net) (Ping timeout: 268 seconds)
2023-05-02 21:51:33 +0200tv1(~tv@user/tv) (Quit: derp)
2023-05-02 21:51:44 +0200Guest4243(~Guest42@ip5f5be7a8.dynamic.kabel-deutschland.de)
2023-05-02 21:51:47 +0200tv(~tv@user/tv)
2023-05-02 21:51:48 +0200ft(~ft@p4fc2a88b.dip0.t-ipconnect.de)
2023-05-02 21:52:45 +0200justsomeguy(~justsomeg@user/justsomeguy)
2023-05-02 21:54:28 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 276 seconds)
2023-05-02 21:55:26 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-05-02 21:57:44 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-05-02 22:00:02 +0200Sciencentistguy1(~sciencent@hacksoc/ordinary-member)
2023-05-02 22:01:04 +0200vulfe(~vulfe@75-28-176-196.lightspeed.evtnil.sbcglobal.net)
2023-05-02 22:02:12 +0200Guest45678(~Guest4567@p200300cf072e68ea6b29732cbdb21e80.dip0.t-ipconnect.de) (Quit: Client closed)
2023-05-02 22:02:39 +0200Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 268 seconds)
2023-05-02 22:02:39 +0200Sciencentistguy1Sciencentistguy
2023-05-02 22:13:53 +0200zeenk(~zeenk@2a02:2f04:a20f:5200::7fe)
2023-05-02 22:14:59 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 268 seconds)
2023-05-02 22:15:06 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-05-02 22:16:19 +0200trev(~trev@user/trev) (Quit: trev)
2023-05-02 22:16:21 +0200czy(~user@host-140-24.ilcub310.champaign.il.us.clients.pavlovmedia.net) (Remote host closed the connection)
2023-05-02 22:17:36 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 248 seconds)
2023-05-02 22:21:21 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-05-02 22:21:31 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-5d8c-8b3d-ea84-cebb.rev.sfr.net) (Remote host closed the connection)
2023-05-02 22:21:49 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-d153-c9b1-0894-c65f.rev.sfr.net)
2023-05-02 22:22:51 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345)
2023-05-02 22:27:15 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:a180:5f0a:ca2e:8345) (Ping timeout: 260 seconds)
2023-05-02 22:28:44 +0200johnjaye(~pi@072-181-052-090.res.spectrum.com) (Quit: WeeChat 4.0.0-dev)
2023-05-02 22:30:35 +0200tremon(~tremon@83.80.159.219)
2023-05-02 22:31:38 +0200nick4(~nick@wsip-174-78-110-18.pn.at.cox.net) (Ping timeout: 268 seconds)
2023-05-02 22:36:55 +0200Guest4243(~Guest42@ip5f5be7a8.dynamic.kabel-deutschland.de) (Quit: Connection closed)
2023-05-02 22:38:48 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-05-02 22:46:28 +0200chomwitt(~chomwitt@2a02:587:7a1d:9d00:1ac0:4dff:fedb:a3f1)
2023-05-02 22:51:53 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-d153-c9b1-0894-c65f.rev.sfr.net) (Remote host closed the connection)
2023-05-02 22:52:10 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-d153-c9b1-0894-c65f.rev.sfr.net)
2023-05-02 22:52:21 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-d153-c9b1-0894-c65f.rev.sfr.net) (Remote host closed the connection)
2023-05-02 22:55:59 +0200alexherbo2(~alexherbo@2a02-842a-8180-4601-d153-c9b1-0894-c65f.rev.sfr.net)
2023-05-02 22:57:02 +0200son0p(~ff@181.136.122.143)
2023-05-02 23:04:48 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Quit: WeeChat 3.8)
2023-05-02 23:06:36 +0200m5zs7k(aquares@web10.mydevil.net) (Ping timeout: 250 seconds)
2023-05-02 23:08:29 +0200m5zs7k(aquares@web10.mydevil.net)
2023-05-02 23:08:32 +0200jpds2(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2023-05-02 23:09:01 +0200jpds2(~jpds@gateway/tor-sasl/jpds)
2023-05-02 23:09:55 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-05-02 23:14:00 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl)
2023-05-02 23:14:07 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 23:18:20 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 246 seconds)
2023-05-02 23:21:35 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se) (Ping timeout: 268 seconds)
2023-05-02 23:27:18 +0200marinelli(~weechat@gateway/tor-sasl/marinelli)
2023-05-02 23:28:32 +0200waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-05-02 23:30:43 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-05-02 23:34:30 +0200michalz(~michalz@185.246.207.197) (Remote host closed the connection)
2023-05-02 23:36:56 +0200chomwitt(~chomwitt@2a02:587:7a1d:9d00:1ac0:4dff:fedb:a3f1) (Remote host closed the connection)
2023-05-02 23:39:39 +0200freeside(~mengwong@103.252.202.85)
2023-05-02 23:44:48 +0200freeside(~mengwong@103.252.202.85) (Ping timeout: 240 seconds)
2023-05-02 23:46:54 +0200gurkenglas(~gurkengla@dynamic-046-114-183-223.46.114.pool.telefonica.de) (Ping timeout: 250 seconds)
2023-05-02 23:47:29 +0200merijn(~merijn@c-001-001-003.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
2023-05-02 23:49:46 +0200emmanuelux(~emmanuelu@user/emmanuelux)