IRCBrowse

2023/05/02

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