IRCBrowse

2023/07/02

2023-07-02 00:03:38 +0200 <bratwurst> ok. i tried quitting my ghci session, running 'cabal install --lib', then running 'cabal v2-repl'. i did this twice, once loading "doc/examples/SlotMachine.hs" and once using
2023-07-02 00:04:00 +0200 <bratwurst> 'doc/examples/Main.hs'
2023-07-02 00:04:25 +0200 <geekosaur> did you tell it what to install?
2023-07-02 00:06:25 +0200 <bratwurst> says it wrote an sdist, resolving dependencies, which there are none, then up to date and exit
2023-07-02 00:07:08 +0200 <geekosaur> just `cabal install --lib` by itself won't do anything useful. I'd expect you to need to do `cabal install --lib reactive-banana` for that to be available to ghci. although if you're going to do that, I'd add `--package-env=.`
2023-07-02 00:07:59 +0200 <geekosaur> that way you don't pollute the global environment, which is what leads to messes once you start doing that with multiple packages that may have different dependencies
2023-07-02 00:12:51 +0200 <ddellacosta> hippoid: try adding exiftool to haskellDevTools on line 10?
2023-07-02 00:14:37 +0200 <ddellacosta> hippoid: oh nevermind, I misunderstood
2023-07-02 00:15:37 +0200 <hippoid> it's working fine in the dev env :>
2023-07-02 00:15:47 +0200 <ddellacosta> isn't it always lol
2023-07-02 00:18:01 +0200 <geekosaur> that's why modern dev is to wrap up the dev env in a docker container and ship it 😛
2023-07-02 00:19:24 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-07-02 00:20:00 +0200[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-07-02 00:20:30 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-07-02 00:20:36 +0200 <hippoid> that's why they promised me if i learned nix
2023-07-02 00:20:44 +0200 <hippoid> s/why/what
2023-07-02 00:22:00 +0200 <chromoblob> i have an idea which feels very cool, it is that the value that didn't fit in any patterns of a case expression is equal to the exception value that gets raised (possibly with some annotation about where it happened)
2023-07-02 00:22:43 +0200 <chromoblob> i think that this one and the undefined/error are the only two categories of exceptions
2023-07-02 00:23:59 +0200 <EvanR> I know I've seen at least one other category of exception, but yeah that would be cool when it made sense
2023-07-02 00:24:06 +0200 <chromoblob> you annotate by enclosing parts of code with functions that catch, change and rethrow
2023-07-02 00:24:17 +0200 <chromoblob> EvanR: which?
2023-07-02 00:24:38 +0200 <EvanR> there's an entire list in Control.Exception
2023-07-02 00:24:52 +0200 <EvanR> plus all the ones not really documented, i.e. in Network
2023-07-02 00:26:35 +0200 <EvanR> you can also create your own exception types or entire hierarchy of exception types
2023-07-02 00:30:21 +0200 <chromoblob> yeah, AsyncException seems to be other, but it is about the choice to not model possibility of execution made by language in some cases (in cases of memory shortage or killing a thread)
2023-07-02 00:30:37 +0200azimut_(~azimut@gateway/tor-sasl/azimut)
2023-07-02 00:30:40 +0200 <chromoblob> which i won't have (hopefully) in my language
2023-07-02 00:31:25 +0200 <EvanR> are you talking about checked exceptions, advertising the interaction of functions with exceptions in a way that a type checker understands
2023-07-02 00:31:51 +0200nick__(~nick@2600:100d:b15a:c23a:dcf3:b3ff:ae67:3ee3)
2023-07-02 00:31:52 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 240 seconds)
2023-07-02 00:31:58 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-07-02 00:34:24 +0200geranim0(~geranim0@modemcable182.140-177-173.mc.videotron.ca) (Remote host closed the connection)
2023-07-02 00:35:28 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 252 seconds)
2023-07-02 00:36:13 +0200 <chromoblob> ooh checked exceptions are cool
2023-07-02 00:38:26 +0200 <chromoblob> EvanR: no i mean the program will always know precisely when it will and will not run out of memory
2023-07-02 00:38:36 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 00:38:36 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 00:38:36 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 00:38:52 +0200 <EvanR> alright, I'm keeping up, I swear
2023-07-02 00:42:30 +0200fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-07-02 00:42:49 +0200phma(~phma@2001:5b0:211f:cfc8:7811:e29d:8e4:daa2) (Read error: Connection reset by peer)
2023-07-02 00:42:58 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 00:43:17 +0200phma(~phma@host-67-44-208-121.hnremote.net)
2023-07-02 00:50:30 +0200shailangsa(~shailangs@host86-186-196-224.range86-186.btcentralplus.com) (Remote host closed the connection)
2023-07-02 00:50:43 +0200alexherbo2(~alexherbo@127.244.204.77.rev.sfr.net)
2023-07-02 00:52:53 +0200pavonia(~user@user/siracusa)
2023-07-02 00:54:26 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-07-02 00:56:59 +0200[_](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 264 seconds)
2023-07-02 00:57:40 +0200phma(~phma@host-67-44-208-121.hnremote.net) (Ping timeout: 250 seconds)
2023-07-02 00:58:44 +0200phma(phma@2001:5b0:211f:cfc8:7811:e29d:8e4:daa2)
2023-07-02 01:00:38 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 01:01:43 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 01:04:38 +0200AkechiShiro(~licht@user/akechishiro) (Quit: WeeChat 3.8)
2023-07-02 01:05:17 +0200alexherbo2(~alexherbo@127.244.204.77.rev.sfr.net) (Remote host closed the connection)
2023-07-02 01:06:52 +0200gurkenglas(~gurkengla@dynamic-046-114-179-109.46.114.pool.telefonica.de) (Ping timeout: 240 seconds)
2023-07-02 01:07:42 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-07-02 01:10:01 +0200 <chromoblob> consumer error and producer error
2023-07-02 01:12:38 +0200connrs(~connrs@user/connrs) (Quit: ZNC 1.8.2 - https://znc.in)
2023-07-02 01:12:55 +0200connrs(~connrs@user/connrs)
2023-07-02 01:14:42 +0200Inst_(~Inst@c-76-101-10-131.hsd1.fl.comcast.net) (Ping timeout: 260 seconds)
2023-07-02 01:19:22 +0200azimut_(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-07-02 01:19:48 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-07-02 01:21:40 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 252 seconds)
2023-07-02 01:26:45 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-07-02 01:29:27 +0200 <EvanR> If you're designing the type system from scratch, go ahead and make it so the only errors are type errors
2023-07-02 01:29:30 +0200connrs(~connrs@user/connrs) (Ping timeout: 240 seconds)
2023-07-02 01:30:20 +0200 <EvanR> at least make sure there's a good reason to aim for the runtime errors that there are
2023-07-02 01:30:30 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 240 seconds)
2023-07-02 01:31:02 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-07-02 01:31:49 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-07-02 01:31:55 +0200connrs(~connrs@user/connrs)
2023-07-02 01:32:07 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 01:32:07 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 01:32:07 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 01:32:27 +0200 <EvanR> if you managed to stop unforeseen out of memory errors, keep going xD
2023-07-02 01:33:09 +0200shailangsa(~shailangs@host86-186-196-224.range86-186.btcentralplus.com)
2023-07-02 01:34:46 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca)
2023-07-02 01:39:57 +0200mauke_(~mauke@user/mauke)
2023-07-02 01:39:58 +0200actioninja6(~actioninj@user/actioninja)
2023-07-02 01:41:26 +0200actioninja(~actioninj@user/actioninja) (Ping timeout: 250 seconds)
2023-07-02 01:41:26 +0200actioninja6actioninja
2023-07-02 01:42:40 +0200dtman34(~dtman34@2601:447:d000:93c9:6f54:cf51:938d:ead5)
2023-07-02 01:43:00 +0200mauke(~mauke@user/mauke) (Ping timeout: 240 seconds)
2023-07-02 01:43:00 +0200mauke_mauke
2023-07-02 01:43:18 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-07-02 01:43:59 +0200sudden(~cat@user/sudden) (Ping timeout: 240 seconds)
2023-07-02 01:45:02 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca) (Ping timeout: 260 seconds)
2023-07-02 01:45:12 +0200sudden(~cat@user/sudden)
2023-07-02 01:45:18 +0200hiredman(~hiredman@frontier1.downey.family) (Remote host closed the connection)
2023-07-02 01:46:10 +0200 <chromoblob> EvanR: "make it so the only errors are type errors" that would make most real programs uncompileable into my language, so no
2023-07-02 01:48:26 +0200 <ski> i guess you could claim that failures (e.g. failure to get next character (file ended), failure to open file, &c.) are not errors
2023-07-02 01:48:57 +0200 <chromoblob> the *failure* of program to handle the *failure* is an error though
2023-07-02 01:49:39 +0200 <chromoblob> it is a consumer error
2023-07-02 01:50:39 +0200 <chromoblob> wait, you could turn all consumer error into producer errors by adding the case _ -> undefined
2023-07-02 01:51:13 +0200 <chromoblob> so even this distinction is blurry
2023-07-02 01:52:30 +0200 <chromoblob> and vice versa by replacing undefined by a hidden constructor
2023-07-02 01:52:49 +0200 <chromoblob> hmm, bottom is hidden constructor
2023-07-02 01:54:58 +0200 <chromoblob> could have total and non-total computation in same language by having NonTotal :: * -> *
2023-07-02 01:55:22 +0200nick__(~nick@2600:100d:b15a:c23a:dcf3:b3ff:ae67:3ee3) (Ping timeout: 258 seconds)
2023-07-02 01:56:41 +0200 <chromoblob> it is also a monad lol
2023-07-02 01:57:18 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-07-02 01:58:01 +0200 <chromoblob> new wonders every day
2023-07-02 02:00:05 +0200troydm(~troydm@user/troydm) (*.net *.split)
2023-07-02 02:00:05 +0200robertm(robertm@lattice.rojoma.com) (*.net *.split)
2023-07-02 02:00:05 +0200tabemann(~tabemann@2600:1700:7990:24e0:cd08:c5bb:9d2b:dbaa) (*.net *.split)
2023-07-02 02:00:05 +0200oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl) (*.net *.split)
2023-07-02 02:00:05 +0200leah2(~leah@vuxu.org) (*.net *.split)
2023-07-02 02:00:05 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (*.net *.split)
2023-07-02 02:00:05 +0200iphy(sid67735@id-67735.lymington.irccloud.com) (*.net *.split)
2023-07-02 02:00:05 +0200pieguy128_(~pieguy128@bras-base-mtrlpq5031w-grc-54-65-92-160-253.dsl.bell.ca) (*.net *.split)
2023-07-02 02:00:05 +0200mrmr(~mrmr@user/mrmr) (*.net *.split)
2023-07-02 02:00:05 +0200sunarch(~sunarch@user/sunarch) (*.net *.split)
2023-07-02 02:00:05 +0200ubert(~Thunderbi@p548c89d1.dip0.t-ipconnect.de) (*.net *.split)
2023-07-02 02:00:05 +0200Lears(~Leary]@user/Leary/x-0910699) (*.net *.split)
2023-07-02 02:00:05 +0200Hafydd(~Hafydd@user/hafydd) (*.net *.split)
2023-07-02 02:00:05 +0200Xe(~cadey@tailscale/xe) (*.net *.split)
2023-07-02 02:00:05 +0200drdo(~drdo@bl8-153-185.dsl.telepac.pt) (*.net *.split)
2023-07-02 02:00:05 +0200tomboy64(~tomboy64@user/tomboy64) (*.net *.split)
2023-07-02 02:00:05 +0200urdh(~urdh@user/urdh) (*.net *.split)
2023-07-02 02:00:05 +0200aku(~aku@65.108.245.241) (*.net *.split)
2023-07-02 02:00:05 +0200tomjaguarpaw(~tom@172-104-25-182.ip.linodeusercontent.com) (*.net *.split)
2023-07-02 02:00:05 +0200lexi-lambda(sid92601@hampstead.irccloud.com) (*.net *.split)
2023-07-02 02:00:05 +0200ryantrinkle(~ryantrink@204.2.90.61) (*.net *.split)
2023-07-02 02:00:05 +0200p3n(~p3n@217.198.124.246) (*.net *.split)
2023-07-02 02:00:05 +0200ralu1(~ralu@static.211.245.203.116.clients.your-server.de) (*.net *.split)
2023-07-02 02:00:05 +0200quintasan(~quassel@quintasan.pl) (*.net *.split)
2023-07-02 02:00:05 +0200mhatta(~mhatta@www21123ui.sakura.ne.jp) (*.net *.split)
2023-07-02 02:00:05 +0200forell(~forell@user/forell) (*.net *.split)
2023-07-02 02:00:05 +0200Putonlalla(~Putonlall@it-cyan.it.jyu.fi) (*.net *.split)
2023-07-02 02:00:05 +0200barrucadu(~barrucadu@carcosa.barrucadu.co.uk) (*.net *.split)
2023-07-02 02:00:05 +0200hnOsmium0001(~hnosm@user/hnOsmium0001) (*.net *.split)
2023-07-02 02:00:05 +0200Everything(~Everythin@static.208.206.21.65.clients.your-server.de) (*.net *.split)
2023-07-02 02:00:17 +0200tomjaguarpaw(~tom@172.104.25.182)
2023-07-02 02:00:20 +0200ralu1(~ralu@static.211.245.203.116.clients.your-server.de)
2023-07-02 02:00:25 +0200tabemann(~tabemann@2600:1700:7990:24e0:cd08:c5bb:9d2b:dbaa)
2023-07-02 02:00:25 +0200quintasan(~quassel@188.226.239.107)
2023-07-02 02:00:29 +0200troydm(~troydm@host-176-37-53-238.b025.la.net.ua)
2023-07-02 02:00:31 +0200aku(~aku@65.108.245.241)
2023-07-02 02:00:38 +0200Hafydd(~Hafydd@2001:41d0:305:2100::31aa)
2023-07-02 02:00:38 +0200tomboy64(~tomboy64@37.120.27.183)
2023-07-02 02:00:38 +0200robertm(robertm@lattice.rojoma.com)
2023-07-02 02:00:39 +0200leah2(~leah@vuxu.org)
2023-07-02 02:00:43 +0200Xe(~cadey@bras-base-orlnon0609w-grc-19-142-112-175-96.dsl.bell.ca)
2023-07-02 02:01:03 +0200troydm(~troydm@host-176-37-53-238.b025.la.net.ua) (Changing host)
2023-07-02 02:01:03 +0200troydm(~troydm@user/troydm)
2023-07-02 02:01:11 +0200tomboy64(~tomboy64@37.120.27.183) (Changing host)
2023-07-02 02:01:11 +0200tomboy64(~tomboy64@user/tomboy64)
2023-07-02 02:01:13 +0200Putonlalla(~Putonlall@it-cyan.it.jyu.fi)
2023-07-02 02:01:14 +0200Xe(~cadey@bras-base-orlnon0609w-grc-19-142-112-175-96.dsl.bell.ca) (Changing host)
2023-07-02 02:01:14 +0200Xe(~cadey@tailscale/xe)
2023-07-02 02:01:15 +0200lexi-lambda(sid92601@id-92601.hampstead.irccloud.com)
2023-07-02 02:01:16 +0200iphy(sid67735@id-67735.lymington.irccloud.com)
2023-07-02 02:01:17 +0200ryantrinkle(~ryantrink@204.2.90.61)
2023-07-02 02:01:53 +0200oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl)
2023-07-02 02:02:03 +0200califax(~califax@user/califx) (Remote host closed the connection)
2023-07-02 02:02:23 +0200pieguy128(~pieguy128@bras-base-mtrlpq5031w-grc-54-65-92-160-253.dsl.bell.ca)
2023-07-02 02:02:25 +0200mhatta(~mhatta@www21123ui.sakura.ne.jp)
2023-07-02 02:02:28 +0200p3n(~p3n@2a00:19a0:3:7c:0:d9c6:7cf6:1)
2023-07-02 02:02:31 +0200ubert(~Thunderbi@p200300ecdf0b57ae588ba3eb26214d5f.dip0.t-ipconnect.de)
2023-07-02 02:02:56 +0200 <ski> "bottom is hidden constructor" -- no
2023-07-02 02:03:28 +0200leah2(~leah@vuxu.org) (Client Quit)
2023-07-02 02:03:40 +0200leah2(~leah@vuxu.org)
2023-07-02 02:03:56 +0200hnOsmium0001(~hnosm@user/hnOsmium0001)
2023-07-02 02:03:57 +0200sunarch(~sunarch@user/sunarch)
2023-07-02 02:04:05 +0200 <ski> anyway, i was reminded of a distinction between errors and faults, where error means that there's a problem in the program, while fault means there's a problem in the language implementation (out-of-memory, other implementation limits exceeded, ..)
2023-07-02 02:04:30 +0200urdh(~urdh@user/urdh)
2023-07-02 02:05:14 +0200Everything(~Everythin@static.208.206.21.65.clients.your-server.de)
2023-07-02 02:05:25 +0200 <chromoblob> i believe that with a good computer and language design the set of faults could be reduced to empty
2023-07-02 02:06:24 +0200forell(~forell@user/forell)
2023-07-02 02:06:28 +0200 <geekosaur> doubt
2023-07-02 02:08:00 +0200 <geekosaur> in particular, out of memory will always be constrained by what else the computer is doing, and if you try to "solve" that by making a fixed container part of the RTS you will find that allowing that container to communicate with anything else brings back all the faults the container is supposed to prevent
2023-07-02 02:08:32 +0200acidjnk(~acidjnk@p200300d6e7072f917cbb145f44358b06.dip0.t-ipconnect.de) (Ping timeout: 245 seconds)
2023-07-02 02:08:36 +0200 <geekosaur> you may also find yourself having ana rgument with the halting problem
2023-07-02 02:08:58 +0200 <geekosaur> (it'll win)
2023-07-02 02:09:05 +0200 <chromoblob> failure to halt is not a fault
2023-07-02 02:09:58 +0200 <geekosaur> knowing precisely whether a program will OOM or not may (I have not checked this) reduce to having an oracle for program halting
2023-07-02 02:10:21 +0200barrucadu(~barrucadu@carcosa.barrucadu.co.uk)
2023-07-02 02:11:04 +0200 <geekosaur> note also that the halting problem doesn't make the distinction you want to, so may sneak in the back door of your design
2023-07-02 02:12:49 +0200 <chromoblob> "making a fixed container part of the RTS" please clarify, what does this mean?
2023-07-02 02:12:52 +0200califax(~califax@user/califx)
2023-07-02 02:13:12 +0200 <geekosaur> oh dear. and you think you have any chance at all of constraining OOM
2023-07-02 02:14:10 +0200 <geekosaur> either your program executes in a container (docker, xen, whatever) by itself with known memory constraints, or you have no knowledge of externally-caused lack of memory until it happens
2023-07-02 02:15:39 +0200 <chromoblob> why does allowing to communicate bring back the fauls?
2023-07-02 02:17:21 +0200 <chromoblob> "may reduce to having an oracle" i think you're wrong, just enumerate all states of the program until it exceeds bound, and the number of states is also limited by the bound
2023-07-02 02:17:42 +0200 <geekosaur> you can't know that bound unless you use a container as I said
2023-07-02 02:18:11 +0200 <geekosaur> otherwise (a) the OS sets the bound (b) dynamically based on its own needs and those of other programs on the system
2023-07-02 02:18:27 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-07-02 02:18:35 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 264 seconds)
2023-07-02 02:18:52 +0200 <geekosaur> and "its own needs" is why allowing holes in your container brings back indeterminacy
2023-07-02 02:19:20 +0200 <chromoblob> the OS and the program can agree on the bound beforehand
2023-07-02 02:19:30 +0200drdo(~drdo@bl8-153-185.dsl.telepac.pt)
2023-07-02 02:19:50 +0200 <chromoblob> it can vary over time
2023-07-02 02:20:16 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-07-02 02:20:20 +0200Guest14(~Guest14@c-71-202-12-4.hsd1.ca.comcast.net)
2023-07-02 02:20:24 +0200 <chromoblob> be dependent on input
2023-07-02 02:23:35 +0200 <geekosaur> glwt
2023-07-02 02:24:30 +0200 <chromoblob> the most precise bound is the ideal case, but people will do the best thing that is practical
2023-07-02 02:24:32 +0200lamnou[m](~lamnoumat@2001:470:69fc:105::3:7a7e)
2023-07-02 02:24:49 +0200 <chromoblob> go as bad as you want
2023-07-02 02:24:58 +0200 <geekosaur> "practical" here means not counting on the OS to play along with your language
2023-07-02 02:25:03 +0200jakky(sid360637@id-360637.lymington.irccloud.com)
2023-07-02 02:25:23 +0200 <chromoblob> well that precludes the good design doesn't it?
2023-07-02 02:25:41 +0200 <chromoblob> if the OS is stupider...
2023-07-02 02:25:56 +0200 <geekosaur> once you finish thinking this through, ask yourself why this has never been done before
2023-07-02 02:26:40 +0200 <geekosaur> "stupider" is not a constraint. "vendors are willing to put in the effort just for you" is a constraint
2023-07-02 02:27:07 +0200 <geekosaur> (this includes linus vs. a patch which touches practically every part of the kernel that allocates memory)
2023-07-02 02:27:35 +0200 <chromoblob> oh so by OS you really mean Linux.....
2023-07-02 02:27:49 +0200 <nyc> geekosaur: That sounds like a very broad sweep.
2023-07-02 02:27:54 +0200 <geekosaur> no, by OS I mean linux and *BSD are the only chances you have
2023-07-02 02:28:10 +0200 <geekosaur> because neither Apple nor Microsoft will see any profit in playing along with you
2023-07-02 02:28:10 +0200 <nyc> geekosaur: What was it changing memory allocation to do?
2023-07-02 02:28:28 +0200 <chromoblob> when did people start programming in dependent types? i think not ages ago
2023-07-02 02:28:34 +0200 <geekosaur> nyc: the claim is that the language can know whether any program will run out of memory or not, if the OS plays along
2023-07-02 02:29:32 +0200 <chromoblob> geekosaur: do you know that i'm making a processor architecture for real-time programs and a language for it where you can specify time constraints in the type system?
2023-07-02 02:29:37 +0200 <geekosaur> I am unconvinced even if you can get the OS to play along, and I think the chances of accomplishing that much are slim to none
2023-07-02 02:29:41 +0200 <chromoblob> same with memory
2023-07-02 02:30:05 +0200 <geekosaur> I think you'll still run into limits
2023-07-02 02:30:08 +0200 <nyc> geekosaur: Non-overcommit?
2023-07-02 02:30:13 +0200 <chromoblob> the chance of achieving *the best practical thing* is 100%.
2023-07-02 02:30:42 +0200 <chromoblob> excluding research and illness.
2023-07-02 02:31:13 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 02:32:01 +0200 <geekosaur> best possible background, ok. IF you also insist that only one program runs at a time, including the OS
2023-07-02 02:32:24 +0200 <chromoblob> which time
2023-07-02 02:32:27 +0200 <chromoblob> you can parallelize
2023-07-02 02:32:46 +0200 <nyc> I still haven't figured out how to read ticky ticky profiles.
2023-07-02 02:32:53 +0200 <geekosaur> uh, no
2023-07-02 02:33:36 +0200 <geekosaur> I mean, sure you can, but you just lost all possibility of constraining any resources because anything else running can choose to gobble them all up with no advance warning
2023-07-02 02:33:45 +0200 <geekosaur> unless you are not turning complete
2023-07-02 02:33:49 +0200 <geekosaur> *turing
2023-07-02 02:34:51 +0200 <geekosaur> as soon as you have general looping/recursion, you cannot determine resource usage beforehand and therefore can't coordinate it between instances
2023-07-02 02:35:07 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-07-02 02:36:05 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 02:37:14 +0200kosmikus[m](~andresloe@2001:470:69fc:105::95d) (Server closed connection)
2023-07-02 02:37:18 +0200 <nyc> I think the idea that kernels want to have is mostly that the kernel won't crash in a disorderly fashion instead of just delivering -ENOMEM errors.
2023-07-02 02:37:29 +0200kosmikus[m](~andresloe@2001:470:69fc:105::95d)
2023-07-02 02:42:18 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 02:43:41 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 02:44:16 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 250 seconds)
2023-07-02 02:47:59 +0200dibblego(~dibblego@116.255.1.157)
2023-07-02 02:47:59 +0200dibblego(~dibblego@116.255.1.157) (Changing host)
2023-07-02 02:48:00 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 02:54:26 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 02:54:50 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 02:56:13 +0200 <chromoblob> geekosaur: resource usage can't be determined only if it in principle is unbounded. the system is bounded by total memory and compute amount
2023-07-02 02:57:17 +0200 <chromoblob> unless you consider a galactic computer that expands more quickly than its programs grow
2023-07-02 02:57:35 +0200 <chromoblob> even then there may be models
2023-07-02 02:58:11 +0200[Leary](~Leary]@user/Leary/x-0910699)
2023-07-02 02:59:59 +0200sm[i](~smi]@plaintextaccounting/sm) (Ping timeout: 246 seconds)
2023-07-02 03:04:56 +0200 <chromoblob> for a given memory usage, set of states is finite, so for every memory usage can check if it will grow further
2023-07-02 03:06:46 +0200 <chromoblob> although simply enumerating all the states is not real
2023-07-02 03:06:58 +0200 <geekosaur> so you have disallowed general recursion?
2023-07-02 03:07:18 +0200 <chromoblob> but if the programmer writes code explicitly with bounds, we can easily go much further
2023-07-02 03:07:27 +0200 <chromoblob> geekosaur: no real computer is Turing-complete
2023-07-02 03:08:42 +0200 <geekosaur> but they require something bigger than the computer to determine that, so it's irrelevant in practice
2023-07-02 03:10:25 +0200 <geekosaur> more to the point, it has to be observed from outside. how do you plan to do that?
2023-07-02 03:10:45 +0200aforemny(~aforemny@2001:9e8:6cfc:6e00:63a1:e62a:573a:a005)
2023-07-02 03:11:02 +0200aforemny_(~aforemny@2001:9e8:6cec:3100:d473:753c:6494:4f21) (Ping timeout: 245 seconds)
2023-07-02 03:11:05 +0200 <chromoblob> i can't parse your two messages
2023-07-02 03:11:20 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-07-02 03:11:21 +0200 <chromoblob> "they", "it" - what
2023-07-02 03:13:19 +0200Inst(~Inst@2601:6c4:4081:2fc0:40cd:5042:4636:845b)
2023-07-02 03:13:20 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::a8c) (Ping timeout: 260 seconds)
2023-07-02 03:14:46 +0200 <geekosaur> "they" = "all real computers", reason being that each state's representation is too large to fit inside the computer so the computer cannot enumerate its own states. thus the state of each computer ("it") can only be observed from outside
2023-07-02 03:15:01 +0200 <geekosaur> which is the primary reason I brought up containers earlier, so there would be an outside
2023-07-02 03:15:44 +0200 <geekosaur> otherwise you must limit to finite states that fit within the computer and therefore can not support general recursion
2023-07-02 03:16:45 +0200 <geekosaur> but it's getting to ve nmy bedtime, if you must discover this the hard way then have fun
2023-07-02 03:17:27 +0200albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-07-02 03:19:06 +0200 <chromoblob> thank you for clarifying the problem
2023-07-02 03:20:39 +0200nek0(~nek0@2a01:4f8:222:2b41::12) (Quit: The Lounge - https://thelounge.chat)
2023-07-02 03:23:00 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 03:28:10 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-07-02 03:28:25 +0200mjt128(~user@2604:3d09:3e79:f200:fe0b:333e:2b63:efd2)
2023-07-02 03:29:40 +0200monix(~quassel@a85-138-255-115.cpe.netcabo.pt)
2023-07-02 03:30:34 +0200monixfesterdam
2023-07-02 03:31:02 +0200festerdam(~quassel@a85-138-255-115.cpe.netcabo.pt) (Client Quit)
2023-07-02 03:31:25 +0200festerdam(~quassel@a85-138-255-115.cpe.netcabo.pt)
2023-07-02 03:32:08 +0200festerdam(~quassel@a85-138-255-115.cpe.netcabo.pt) ()
2023-07-02 03:43:52 +0200dmenz(~dmenz@2804:14d:5cd4:85fb:176f:8705:81c:687a) (Ping timeout: 240 seconds)
2023-07-02 03:43:57 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 245 seconds)
2023-07-02 04:01:10 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 04:01:52 +0200smalltalkman(uid545680@id-545680.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-07-02 04:03:58 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-07-02 04:05:28 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::a8c)
2023-07-02 04:06:26 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 260 seconds)
2023-07-02 04:17:20 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 04:18:44 +0200finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-07-02 04:18:44 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-07-02 04:18:44 +0200finn_elijaFinnElija
2023-07-02 04:23:30 +0200td_(~td@i5387090D.versanet.de) (Ping timeout: 250 seconds)
2023-07-02 04:25:35 +0200td_(~td@i5387090A.versanet.de)
2023-07-02 04:28:31 +0200phma(phma@2001:5b0:211f:cfc8:7811:e29d:8e4:daa2) (Read error: Connection reset by peer)
2023-07-02 04:28:55 +0200phma(phma@2001:5b0:211f:cfc8:7811:e29d:8e4:daa2)
2023-07-02 04:33:18 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-07-02 04:35:23 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 04:40:59 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 04:46:11 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 264 seconds)
2023-07-02 04:51:40 +0200stonebridge(~stronebri@bcdcac82.skybroadband.com) (Quit: Connection error?!)
2023-07-02 04:52:13 +0200marvel83(~marvel83@bcdcac82.skybroadband.com)
2023-07-02 04:59:14 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-07-02 04:59:33 +0200 <monochrom> There are some questions known to be in EXPTIME. This also means exponentially many distinct states the best algorithm must go through. Therefore, an observer that keeps tabs on which states have been visited needs exponentially more space.
2023-07-02 05:00:43 +0200 <monochrom> To keep tabs on a 8GB-RAM computer requires 2^(8GB) space. I don't have that much space. Do you?
2023-07-02 05:01:16 +0200 <monochrom> To be sure, it still "qualifies" as "O(1)" space. >:D
2023-07-02 05:03:21 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Client Quit)
2023-07-02 05:04:10 +0200 <monochrom> And perhaps s/EXPTIME/EXPTIME-complete/
2023-07-02 05:06:24 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-07-02 05:08:27 +0200barzo(~hd@31.223.41.197)
2023-07-02 05:09:47 +0200chromoblob(~user@37.113.180.121)
2023-07-02 05:18:46 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 260 seconds)
2023-07-02 05:23:32 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 240 seconds)
2023-07-02 05:27:46 +0200trev(~trev@user/trev)
2023-07-02 05:31:27 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-07-02 05:31:27 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::a8c) (Ping timeout: 245 seconds)
2023-07-02 05:32:48 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 05:38:23 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-07-02 05:46:24 +0200aforemny_(~aforemny@2001:9e8:6ccc:3300:341b:150:2961:d57a)
2023-07-02 05:47:17 +0200aforemny(~aforemny@2001:9e8:6cfc:6e00:63a1:e62a:573a:a005) (Ping timeout: 245 seconds)
2023-07-02 06:09:14 +0200Clinton[m](~clintonme@2001:470:69fc:105::2:31d4) (Server closed connection)
2023-07-02 06:09:28 +0200Clinton[m](~clintonme@2001:470:69fc:105::2:31d4)
2023-07-02 06:13:14 +0200aerc[m](~aercmatri@2001:470:69fc:105::3:67b9) (Server closed connection)
2023-07-02 06:13:28 +0200aerc[m](~aercmatri@2001:470:69fc:105::3:67b9)
2023-07-02 06:25:27 +0200thegeekinside(~thegeekin@189.217.90.138)
2023-07-02 06:28:23 +0200thegeekinside(~thegeekin@189.217.90.138) (Read error: Connection reset by peer)
2023-07-02 06:37:26 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Quit: So long and thanks for all the fish)
2023-07-02 06:37:50 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 250 seconds)
2023-07-02 06:37:58 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 06:45:32 +0200notzmv(~zmv@user/notzmv)
2023-07-02 06:45:37 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 06:47:50 +0200Guest14(~Guest14@c-71-202-12-4.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-07-02 06:48:14 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net) (Ping timeout: 250 seconds)
2023-07-02 06:50:06 +0200xff0x(~xff0x@2405:6580:b080:900:722b:d772:7870:6a8e)
2023-07-02 06:51:42 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 250 seconds)
2023-07-02 07:01:01 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 07:01:47 +0200ddellacosta(~ddellacos@143.244.47.100) (Ping timeout: 264 seconds)
2023-07-02 07:03:33 +0200ddellacosta(~ddellacos@146.70.166.245)
2023-07-02 07:05:59 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 264 seconds)
2023-07-02 07:07:23 +0200ddellacosta(~ddellacos@146.70.166.245) (Client Quit)
2023-07-02 07:08:04 +0200jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2023-07-02 07:08:40 +0200jpds(~jpds@gateway/tor-sasl/jpds)
2023-07-02 07:10:38 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-07-02 07:11:57 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-07-02 07:17:10 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 07:17:33 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 07:35:14 +0200Las[m]1(~lasmatrix@2001:470:69fc:105::74e) (Server closed connection)
2023-07-02 07:35:29 +0200Las[m]1(~lasmatrix@2001:470:69fc:105::74e)
2023-07-02 07:36:19 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-07-02 07:43:37 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-07-02 07:44:16 +0200ec(~ec@gateway/tor-sasl/ec)
2023-07-02 07:48:44 +0200xff0x(~xff0x@2405:6580:b080:900:722b:d772:7870:6a8e) (Ping timeout: 240 seconds)
2023-07-02 07:49:08 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net)
2023-07-02 07:56:38 +0200 <mauke> in practice, all problems are O(1) because numbers are finite
2023-07-02 08:14:47 +0200mstksg(~jle`@cpe-23-240-75-236.socal.res.rr.com) (Ping timeout: 245 seconds)
2023-07-02 08:16:56 +0200mstksg(~jle`@cpe-23-240-75-236.socal.res.rr.com)
2023-07-02 08:17:42 +0200fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-07-02 08:19:31 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 08:20:02 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 08:26:57 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-07-02 08:29:40 +0200Inst_(~Inst@2601:6c4:4081:2fc0:4ce0:dbb4:3e84:48a2)
2023-07-02 08:32:12 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 08:33:07 +0200Inst(~Inst@2601:6c4:4081:2fc0:40cd:5042:4636:845b) (Ping timeout: 245 seconds)
2023-07-02 08:33:28 +0200gmg(~user@user/gehmehgeh)
2023-07-02 08:36:56 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 08:37:18 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 08:39:26 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-07-02 08:42:32 +0200dtman34(~dtman34@2601:447:d000:93c9:6f54:cf51:938d:ead5) (Ping timeout: 246 seconds)
2023-07-02 08:45:25 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 08:46:24 +0200dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net)
2023-07-02 08:49:31 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2023-07-02 08:52:41 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Read error: Connection reset by peer)
2023-07-02 08:55:49 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2023-07-02 08:55:57 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-07-02 08:56:38 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-07-02 08:58:12 +0200 <jade[m]> <monochrom> "To keep tabs on a 8GB-RAM..." <- just make a 256GB swap :P
2023-07-02 09:01:02 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2023-07-02 09:03:11 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 09:03:34 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 09:04:18 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Quit: So long and thanks for all the fish)
2023-07-02 09:07:05 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 09:11:52 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 245 seconds)
2023-07-02 09:12:25 +0200chromoblob(~user@37.113.180.121)
2023-07-02 09:15:01 +0200Feuermagier_(~Feuermagi@user/feuermagier)
2023-07-02 09:15:01 +0200FeuermagierGuest8860
2023-07-02 09:15:01 +0200Guest8860(~Feuermagi@user/feuermagier) (Killed (molybdenum.libera.chat (Nickname regained by services)))
2023-07-02 09:15:02 +0200Feuermagier_Feuermagier
2023-07-02 09:15:05 +0200notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2023-07-02 09:16:13 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 09:16:46 +0200chromoblob(~user@37.113.180.121) (Ping timeout: 260 seconds)
2023-07-02 09:20:53 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 246 seconds)
2023-07-02 09:24:25 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 240 seconds)
2023-07-02 09:26:42 +0200Techcable(~Techcable@user/Techcable)
2023-07-02 09:34:10 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 09:41:21 +0200titibandit(~titibandi@user/titibandit) (Read error: Connection reset by peer)
2023-07-02 09:42:08 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 09:42:26 +0200hisa3873(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net)
2023-07-02 09:43:38 +0200azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-07-02 09:44:20 +0200hisa387(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net) (Ping timeout: 240 seconds)
2023-07-02 09:44:20 +0200hisa3873hisa387
2023-07-02 09:47:17 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0)
2023-07-02 09:48:26 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:bd12:aba9:a757:ddbd) (Remote host closed the connection)
2023-07-02 09:49:47 +0200TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2023-07-02 09:56:57 +0200mjt128(~user@2604:3d09:3e79:f200:fe0b:333e:2b63:efd2) (Remote host closed the connection)
2023-07-02 09:58:10 +0200 <probie> If I have a cabal file that defines an internal library, but nothing depends on the internal library, will the internal library's dependencies still be built or will it just be completely ignored?
2023-07-02 10:04:36 +0200acidjnk(~acidjnk@p200300d6e7072f177cbb145f44358b06.dip0.t-ipconnect.de)
2023-07-02 10:05:11 +0200Pickchea(~private@user/pickchea)
2023-07-02 10:05:16 +0200 <arahael> probie: Why does it matter? (Just curious)
2023-07-02 10:11:01 +0200smalltalkman(uid545680@id-545680.hampstead.irccloud.com)
2023-07-02 10:11:14 +0200 <probie> because the internal library may not even have a satisfiable set of dependencies in the event that nothing depends on it. In the worst case I can stick a conditional in front of the internal library's dependencies so it simply doesn't have any dependencies in the event that nothing depends on it
2023-07-02 10:13:01 +0200 <probie> I'm currently away from my dev machine, so I unfortunately have a hundred questions going through my head, but without the ability to simply try it (for the next few hours, anyway)
2023-07-02 10:16:12 +0200barzo(~hd@31.223.41.197) (Quit: Leaving)
2023-07-02 10:18:22 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-07-02 10:19:32 +0200 <probie> what I was working on (and I guess, am still thinking about) is (ab)using backpack to solve my "typeclass dependency" problem - namely, that I don't want a mandatory dependency on a package like comonad to have comonads, but if I actually depend on comonad, I want my `Comonad` class to be the one from the comonad pacakge
2023-07-02 10:23:29 +0200 <arahael> Oh that's way too abstract for me right now but my thinking is that if there's a formal dependency on the package, it should get built. Whether it then remains in the application is another question.
2023-07-02 10:23:45 +0200 <arahael> If there's no dependency specified, however, then that's when I would ask "Why does it matter?"
2023-07-02 10:27:15 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 10:27:20 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-07-02 10:31:23 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 10:33:10 +0200econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-07-02 10:37:30 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 260 seconds)
2023-07-02 10:39:00 +0200werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-07-02 10:42:17 +0200infinity0(~infinity0@pwned.gg) (Ping timeout: 245 seconds)
2023-07-02 10:43:25 +0200infinity0(~infinity0@pwned.gg)
2023-07-02 10:48:56 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:bd12:aba9:a757:ddbd)
2023-07-02 10:52:30 +0200tackleton(~tackleton@user/tackleton) (Quit: Bouncer down)
2023-07-02 10:53:17 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:bd12:aba9:a757:ddbd) (Ping timeout: 246 seconds)
2023-07-02 11:04:03 +0200gurkenglas(~gurkengla@dynamic-046-114-181-031.46.114.pool.telefonica.de)
2023-07-02 11:05:24 +0200titibandit(~titibandi@user/titibandit) (Remote host closed the connection)
2023-07-02 11:11:00 +0200chromoblob(~user@37.113.180.121)
2023-07-02 11:12:11 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-07-02 11:15:58 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-07-02 11:22:45 +0200Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-07-02 11:24:30 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 260 seconds)
2023-07-02 11:24:31 +0200Lord_of_Life_Lord_of_Life
2023-07-02 11:30:57 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2023-07-02 11:37:02 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 11:40:01 +0200alexherbo2(~alexherbo@2a02-8440-2441-3d48-490c-814f-aeeb-9af8.rev.sfr.net)
2023-07-02 11:41:14 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 11:56:01 +0200ormaaaj(~ormaaj@user/ormaaj) (Remote host closed the connection)
2023-07-02 11:56:20 +0200Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-07-02 11:56:47 +0200ormaaaj(~ormaaj@user/ormaaj)
2023-07-02 11:56:49 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-07-02 11:57:33 +0200ormaaajormaaj
2023-07-02 12:00:59 +0200Cheery(~cheery@server-239-7.tentacle.cloud) (Quit: leaving)
2023-07-02 12:04:16 +0200xff0x_(~xff0x@2405:6580:b080:900:722b:d772:7870:6a8e)
2023-07-02 12:07:12 +0200xff0x(~xff0x@ai098135.d.east.v6connect.net) (Ping timeout: 240 seconds)
2023-07-02 12:09:17 +0200alexherbo2(~alexherbo@2a02-8440-2441-3d48-490c-814f-aeeb-9af8.rev.sfr.net) (Remote host closed the connection)
2023-07-02 12:12:52 +0200 <Axman6> Anyone know why ghcup wouldn't let me run the tui? I'm running (aarch64) ubuntu, with version 0.1.19.3
2023-07-02 12:13:47 +0200 <Axman6> the option doesn't show up in the help (and running ghcup tui just prints the help)
2023-07-02 12:26:37 +0200 <maerwald> Axman6: I'm fixing that right now
2023-07-02 12:26:41 +0200 <maerwald> will be another release
2023-07-02 12:26:52 +0200 <maerwald> wasn't aware we have so many linux aarch64 users, in fact
2023-07-02 12:27:17 +0200 <maerwald> binaries are already built, so will take half an hour
2023-07-02 12:27:22 +0200 <Axman6> maerwald: <3
2023-07-02 12:28:04 +0200 <Axman6> Well, I'm only one of them because I want to do some work on the aarch64 NCG... but I don't have any aarch64 machines so I'm using an EC2 instance
2023-07-02 12:28:49 +0200 <Axman6> what's stopping it from working there?
2023-07-02 12:29:20 +0200 <maerwald> issues with CI config and cabal versions
2023-07-02 12:35:18 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 12:35:41 +0200 <Axman6> Fair enough - well thank you for all the time you (and others) have put into it, I feel I owe y'all a beer or two
2023-07-02 12:36:59 +0200fweht(uid404746@id-404746.lymington.irccloud.com)
2023-07-02 12:39:27 +0200 <chromoblob> dumb question, are haskell-src and haskell-src-exts substantially different, apart from extension support?
2023-07-02 12:43:05 +0200 <chromoblob> hm. if i export a function that refers to a top-level variable defined in a certain module that is written by the user, would that be recursive modules? how hard are they to implement?
2023-07-02 12:43:10 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 12:44:01 +0200 <chromoblob> ok, user can just define my_function = my_general_function user's_parameter
2023-07-02 12:47:38 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-07-02 12:48:30 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-07-02 12:48:57 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-07-02 12:50:25 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0) (Remote host closed the connection)
2023-07-02 12:50:41 +0200 <chromoblob> ok i think i'll roll with haskell-src-exts, many are simple syntactical extensions that're good to have
2023-07-02 12:52:42 +0200dfordvm(~dfordivam@160.16.87.223.v6.sakura.ne.jp) (Server closed connection)
2023-07-02 12:53:10 +0200dfordvm(~dfordivam@160.16.87.223.v6.sakura.ne.jp)
2023-07-02 12:53:19 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-07-02 12:57:02 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 12:57:28 +0200 <maerwald> Axman6: should be done
2023-07-02 12:58:16 +0200 <Axman6> the fix, or ghcup should be done, so you're making it? :P
2023-07-02 12:58:33 +0200 <maerwald> Axman6: ghcup upgrade
2023-07-02 12:58:55 +0200 <Axman6> it sure is! what a legend, thanks maerwald
2023-07-02 13:01:09 +0200 <Axman6> so maybe you might know this, after installing ghc 9.6.2 on aarch64 linux, it seems like it might hav a broken installation, I get "Warning: include-dirs: /data/home/ubuntu/.ghcup/ghc/9.6.2/lib/ghc-9.6.2/lib/../lib/aarch64-linux-ghc-9.6.2/directory-1.3.8.1/include doesn't exist or isn't a directory"
2023-07-02 13:01:44 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 13:01:59 +0200 <maerwald> you get the warning where
2023-07-02 13:02:35 +0200 <Axman6> uh sorry, when running ghc-pkg check
2023-07-02 13:03:01 +0200 <maerwald> ghcup install ghc 9.6.2 --force
2023-07-02 13:04:01 +0200 <Axman6> thanks - trying now
2023-07-02 13:05:30 +0200 <maerwald> `ghcup tui` sometimes segfaults ... I have not found out what's going on there
2023-07-02 13:05:39 +0200 <maerwald> this must be due to brick
2023-07-02 13:05:48 +0200 <maerwald> and as such it can leave a partial installation... I guess
2023-07-02 13:07:15 +0200 <Axman6> hmm. This was after doing a ghcup nuke and then immediately installing 9.6.2 without the tui and it succeding
2023-07-02 13:08:03 +0200 <Axman6> yeah same warning after the --force install
2023-07-02 13:08:05 +0200mrmr(~mrmr@user/mrmr)
2023-07-02 13:09:01 +0200 <maerwald> yes I can reproduce
2023-07-02 13:09:07 +0200 <maerwald> looks like the bindist is busted then
2023-07-02 13:09:54 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0)
2023-07-02 13:10:17 +0200 <Axman6> well, I'm glad it's not me - I've had some weirds things happen on this machine because I tried to use an EBS snapshot from anoter ec2 instance, and that meant half my paths were wrong (because I'm dumb, not ghcup or anything else)
2023-07-02 13:10:35 +0200 <maerwald> Axman6: https://imgur.com/2SNWufx.png
2023-07-02 13:11:29 +0200 <Axman6> yeah that's what mine looks like - should I report it somewhere? (where? ghc gitlab?)
2023-07-02 13:11:47 +0200 <maerwald> yes, GHC gitlab
2023-07-02 13:12:08 +0200alexherbo2(~alexherbo@232.145.204.77.rev.sfr.net)
2023-07-02 13:17:37 +0200 <Axman6> maerwald: can you check 9.6.1 for me? that's broken for me too
2023-07-02 13:17:43 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 13:21:58 +0200 <maerwald> Axman6: yeah, same
2023-07-02 13:22:12 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2023-07-02 13:23:19 +0200 <Axman6> I'll check 9.4's too
2023-07-02 13:25:22 +0200tremon(~tremon@83.80.159.219) (Remote host closed the connection)
2023-07-02 13:26:31 +0200 <maerwald> 9.4 doesn't seem to have this warning
2023-07-02 13:26:40 +0200 <Axman6> yeah
2023-07-02 13:30:30 +0200nshepperd2(nshepperd@2600:3c03::f03c:92ff:fe28:92c9) (Quit: Ping timeout (120 seconds))
2023-07-02 13:30:43 +0200nshepperd2(nshepperd@2600:3c03::f03c:92ff:fe28:92c9)
2023-07-02 13:31:05 +0200landonf(landonf@mac68k.info) (Ping timeout: 260 seconds)
2023-07-02 13:31:45 +0200joeyh_(~joeyh@kitenet.net) (Quit: ZNC 1.8.2+deb3+b4 - https://znc.in)
2023-07-02 13:31:46 +0200arkeet(~arkeet@moriya.ca) (Quit: ZNC 1.8.2 - https://znc.in)
2023-07-02 13:31:55 +0200arkeet(arkeet@moriya.ca)
2023-07-02 13:31:56 +0200joeyh(~joeyh@kitenet.net)
2023-07-02 13:32:38 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-07-02 13:34:21 +0200infinity0(~infinity0@pwned.gg)
2023-07-02 13:34:32 +0200tolt(~weechat-h@li219-154.members.linode.com) (Ping timeout: 240 seconds)
2023-07-02 13:34:34 +0200 <Axman6> maerwald: https://gitlab.haskell.org/ghc/ghc/-/issues/23594
2023-07-02 13:35:39 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-07-02 13:35:48 +0200landonf(landonf@mac68k.info)
2023-07-02 13:35:53 +0200tolt(~weechat-h@173.255.209.154)
2023-07-02 13:36:31 +0200Pickchea(~private@user/pickchea)
2023-07-02 13:37:47 +0200infinity0(~infinity0@pwned.gg)
2023-07-02 13:41:14 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-07-02 13:42:44 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-07-02 13:43:56 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-07-02 13:44:26 +0200ec(~ec@gateway/tor-sasl/ec)
2023-07-02 13:46:50 +0200smalltalkman(uid545680@id-545680.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-07-02 13:50:14 +0200 <chromoblob> didn't know about the semicolons
2023-07-02 13:50:19 +0200 <chromoblob> > if True; then 2; else 3
2023-07-02 13:50:21 +0200 <lambdabot> 2
2023-07-02 13:50:28 +0200 <chromoblob> oh, it's for layout rules?
2023-07-02 13:50:49 +0200 <hpc> semicolon before "then"? what is this, bash? :D
2023-07-02 13:50:57 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-07-02 13:51:01 +0200 <hpc> yeah, it's for layout
2023-07-02 13:51:37 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-07-02 13:51:38 +0200 <hpc> {} delimits blocks, ; delimits newlines
2023-07-02 13:52:00 +0200 <Axman6> and everyone knows the go at the beginning of the line, not the end
2023-07-02 13:52:49 +0200 <hpc> of course, how else would you indent your code with semicolons
2023-07-02 13:53:36 +0200 <hpc> main = do {
2023-07-02 13:53:45 +0200 <hpc> ;;;;putStrLn "hello world";
2023-07-02 13:53:46 +0200 <hpc> }
2023-07-02 13:54:09 +0200 <Axman6> You genius, we'll never argue about tabs vs spaces again!
2023-07-02 13:54:14 +0200 <hpc> since haskell is whitespace-sensitive, it's best practice to make the whitespace visible
2023-07-02 13:54:38 +0200 <Axman6> the whitespace gets sad if you forget about it
2023-07-02 13:55:31 +0200 <Helle> oh, right, I wanted rainbow whitespace in vim for a while, guess I should actually write that
2023-07-02 13:55:58 +0200 <hpc> rainbowspace?
2023-07-02 13:56:33 +0200 <chromoblob> > (,) {}
2023-07-02 13:56:35 +0200 <lambdabot> (*Exception: <interactive>:3:1-6: Missing field in record construction
2023-07-02 13:56:58 +0200 <chromoblob> hpc: lol
2023-07-02 13:57:53 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-07-02 13:58:17 +0200 <Helle> hpc: leading white space being filled with rainbow colours (for every indent level) so deeply indented code gives you more of a clue how far it is indented (not so much a problem in Haskell, though sometimes)
2023-07-02 13:58:51 +0200 <hpc> heh, i have that problem with python a lot
2023-07-02 13:59:54 +0200 <chromoblob> hmm, according to standard, (,) {} shouldn'r really parse
2023-07-02 14:00:03 +0200 <chromoblob> but it's a fine extension lol
2023-07-02 14:00:30 +0200 <chromoblob> let b = b in (b, b, b, b, b) vs (,,,,) {}
2023-07-02 14:03:09 +0200 <chromoblob> hm, what's reason for x { f = e } to fail in the case x's constructor doesn't have f?
2023-07-02 14:03:32 +0200 <chromoblob> it may be useful to just omit the update for constructors that don't have the field
2023-07-02 14:04:24 +0200 <probie> It'd mean minor typos would be no-ops instead of throwing an error
2023-07-02 14:05:09 +0200 <chromoblob> could have some syntax that specifies whether you want errors or noops
2023-07-02 14:05:10 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0) (Ping timeout: 260 seconds)
2023-07-02 14:05:29 +0200 <chromoblob> something like x ~{f = e} or x !{f = e}
2023-07-02 14:06:14 +0200merijn(~merijn@86.86.29.250)
2023-07-02 14:10:41 +0200merijn(~merijn@86.86.29.250) (Ping timeout: 246 seconds)
2023-07-02 14:22:42 +0200ysh____(sid6017@id-6017.ilkley.irccloud.com) (Server closed connection)
2023-07-02 14:22:53 +0200ysh____(sid6017@id-6017.ilkley.irccloud.com)
2023-07-02 14:25:00 +0200 <chromoblob> i'm reading the Haskell 2010 report, 3.17.3 Formal Semantics of Pattern Matching
2023-07-02 14:25:25 +0200 <chromoblob> in rule (b), where do you get decls_i from?
2023-07-02 14:25:45 +0200 <chromoblob> (in PDF version it is on PDF page 52)
2023-07-02 14:27:41 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-07-02 14:29:27 +0200 <chromoblob> i'm blind, it is on both left and right side
2023-07-02 14:29:34 +0200 <chromoblob> never mind
2023-07-02 14:30:36 +0200Ranhir(~Ranhir@157.97.53.139) (Quit: KVIrc 5.0.0 Aria http://www.kvirc.net/)
2023-07-02 14:32:30 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 14:32:59 +0200 <chromoblob> > (\(,,) {} -> ()) (1,2,3)
2023-07-02 14:33:00 +0200 <lambdabot> ()
2023-07-02 14:34:15 +0200Ranhir(~Ranhir@157.97.53.139)
2023-07-02 14:36:25 +0200 <mauke> > (\case Just{} -> "J"; Nothing{} -> "N") (Just 42)
2023-07-02 14:36:27 +0200 <lambdabot> "J"
2023-07-02 14:37:36 +0200eugenrh(~eugenrh@2a01:4f9:c011:265::1) (Ping timeout: 260 seconds)
2023-07-02 14:41:35 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 14:42:17 +0200acidjnk(~acidjnk@p200300d6e7072f177cbb145f44358b06.dip0.t-ipconnect.de) (Ping timeout: 245 seconds)
2023-07-02 14:51:16 +0200ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-07-02 14:51:41 +0200ec(~ec@gateway/tor-sasl/ec)
2023-07-02 14:54:51 +0200hisa3877(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net)
2023-07-02 14:55:41 +0200 <pavonia> What is the purpose of the braces after Nothing?
2023-07-02 14:56:14 +0200 <Axman6> explicitly says not to name any of the fields of the no fields in the Nothing constructor
2023-07-02 14:56:25 +0200 <Axman6> there's no reason to have them there other than to see what they do
2023-07-02 14:57:14 +0200hisa387(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net) (Ping timeout: 246 seconds)
2023-07-02 14:57:14 +0200hisa3877hisa387
2023-07-02 14:57:22 +0200 <hpc> more generally, it's a way of saying "i don't care about the fields or even how many there are, just match the constructor"
2023-07-02 14:57:39 +0200 <hpc> good for types with lots and lots of fields
2023-07-02 14:58:13 +0200 <chromoblob> pavonia: so it works when you add or remove fields
2023-07-02 14:59:25 +0200 <pavonia> Yes, I know what it does for constructors with fiedls, but in this specific case it looked redundant
2023-07-02 14:59:49 +0200 <probie> Also just good when you want to match on the constructor, but nothing else, regardless of number of fields
2023-07-02 15:02:42 +0200acertain_(sid470584@id-470584.hampstead.irccloud.com) (Server closed connection)
2023-07-02 15:03:00 +0200acertain_(sid470584@id-470584.hampstead.irccloud.com)
2023-07-02 15:08:26 +0200xff0x_(~xff0x@2405:6580:b080:900:722b:d772:7870:6a8e) (Ping timeout: 246 seconds)
2023-07-02 15:08:49 +0200xff0x_(~xff0x@ai086045.d.east.v6connect.net)
2023-07-02 15:09:25 +0200 <chromoblob> i want to create a simple subset-of-Haskell -> JS transpiler without advanced optimizations that passes GC and optimization onto the JS engine. compiler must also be written in the subset. easiest way seems to be to rip out the parser, type checker and desugarer / translator to kernel out of an existing open source compiler. given that i want less optimization and more simplicity, which compiler do
2023-07-02 15:09:31 +0200 <chromoblob> you recommend for that?
2023-07-02 15:14:42 +0200yandere(sid467876@id-467876.ilkley.irccloud.com) (Server closed connection)
2023-07-02 15:14:51 +0200yandere(sid467876@id-467876.ilkley.irccloud.com)
2023-07-02 15:15:47 +0200 <probie> If you want laziness, I'd recommend targeting the g-machine and following SPJ and David Lester's tutorial for that (and relying on JS for GC). It's moderately easy to turn something Haskell-like into the core they describe, and turning g-machine code into JS is pretty easy
2023-07-02 15:16:35 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 15:19:03 +0200 <chromoblob> thank you
2023-07-02 15:27:36 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 15:30:04 +0200connrs(~connrs@user/connrs) (Quit: ZNC 1.8.2 - https://znc.in)
2023-07-02 15:30:54 +0200connrs(~connrs@user/connrs)
2023-07-02 15:32:20 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-07-02 15:48:42 +0200edmundnoble_(sid229620@id-229620.helmsley.irccloud.com) (Server closed connection)
2023-07-02 15:48:56 +0200edmundnoble_(sid229620@id-229620.helmsley.irccloud.com)
2023-07-02 15:57:15 +0200 <chromoblob> does code with NoMonomorphismRestriction still fail on ambiguous types?
2023-07-02 15:58:21 +0200[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-07-02 15:59:19 +0200 <chromoblob> @let f = (+)
2023-07-02 15:59:21 +0200 <lambdabot> Defined.
2023-07-02 15:59:33 +0200 <chromoblob> @type f
2023-07-02 15:59:34 +0200 <lambdabot> error:
2023-07-02 15:59:34 +0200 <lambdabot> Ambiguous occurrence ‘f’
2023-07-02 15:59:34 +0200 <lambdabot> It could refer to
2023-07-02 15:59:42 +0200 <chromoblob> wtf
2023-07-02 15:59:52 +0200 <chromoblob> @let fff = (+)
2023-07-02 15:59:54 +0200 <lambdabot> Defined.
2023-07-02 15:59:55 +0200 <chromoblob> @type f
2023-07-02 15:59:56 +0200 <lambdabot> error:
2023-07-02 15:59:56 +0200 <lambdabot> Ambiguous occurrence ‘f’
2023-07-02 15:59:56 +0200 <lambdabot> It could refer to
2023-07-02 15:59:59 +0200 <chromoblob> @type fff
2023-07-02 16:00:01 +0200 <lambdabot> Num a => a -> a -> a
2023-07-02 16:00:18 +0200 <chromoblob> @let (ff,gg) = ((+), (-))
2023-07-02 16:00:21 +0200 <lambdabot> Defined.
2023-07-02 16:00:22 +0200 <chromoblob> @type ff
2023-07-02 16:00:24 +0200 <lambdabot> Num a => a -> a -> a
2023-07-02 16:00:51 +0200 <chromoblob> @let [(nn,ss)] = reads "1x"
2023-07-02 16:00:52 +0200 <lambdabot> /sandbox/tmp/.L.hs:171:1: error:
2023-07-02 16:00:52 +0200 <lambdabot> • Ambiguous type variable ‘a0’
2023-07-02 16:00:52 +0200 <lambdabot> prevents the constraint ‘(Read a0)’ from being solved.
2023-07-02 16:00:57 +0200 <chromoblob> okay
2023-07-02 16:01:16 +0200bratwurst(~dfadsva@2604:3d09:207f:f650::a8c)
2023-07-02 16:05:03 +0200wootehfoot(~wootehfoo@user/wootehfoot)
2023-07-02 16:06:20 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-07-02 16:08:11 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-07-02 16:19:06 +0200ub(~Thunderbi@p200300ecdf0b57ea084964e545e9929f.dip0.t-ipconnect.de)
2023-07-02 16:19:24 +0200ubert(~Thunderbi@p200300ecdf0b57ae588ba3eb26214d5f.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-07-02 16:19:24 +0200ububert
2023-07-02 16:20:38 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 16:22:42 +0200Pent_(sid313808@id-313808.lymington.irccloud.com) (Server closed connection)
2023-07-02 16:23:05 +0200Pent_(sid313808@id-313808.lymington.irccloud.com)
2023-07-02 16:24:22 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 16:26:57 +0200wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2023-07-02 16:28:32 +0200titibandit(~titibandi@user/titibandit) (Ping timeout: 240 seconds)
2023-07-02 16:32:29 +0200nek0(~nek0@2a01:4f8:222:2b41::12)
2023-07-02 16:34:35 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 16:36:26 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-07-02 16:38:15 +0200teleprompter[m](~telepromp@2001:470:69fc:105::3:74ef) (K-Lined)
2023-07-02 16:38:30 +0200jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-07-02 16:39:04 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 252 seconds)
2023-07-02 16:47:36 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 16:57:38 +0200son0p(~ff@181.136.122.143)
2023-07-02 17:01:34 +0200titibandit(~titibandi@user/titibandit) (Ping timeout: 260 seconds)
2023-07-02 17:03:25 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 17:04:18 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 17:07:28 +0200nick__(~nick@98.186.208.255)
2023-07-02 17:09:12 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 250 seconds)
2023-07-02 17:09:37 +0200euandreh(~Thunderbi@189.6.18.7)
2023-07-02 17:13:18 +0200dmenz(~dmenz@2804:14d:5cd4:85fb:176f:8705:81c:687a)
2023-07-02 17:14:21 +0200euandreh(~Thunderbi@189.6.18.7) (Remote host closed the connection)
2023-07-02 17:17:40 +0200econo_(uid147250@id-147250.tinside.irccloud.com)
2023-07-02 17:20:13 +0200 <chromoblob> it seems like Haskell 2010 report doesn't actually give semantics for function application and lambda abstraction
2023-07-02 17:20:55 +0200 <chromoblob> so it has prerequisites, and doesn't even say where to learn about it
2023-07-02 17:21:08 +0200 <geekosaur> it actually does that a lot
2023-07-02 17:21:19 +0200infinity0(~infinity0@pwned.gg) (Remote host closed the connection)
2023-07-02 17:21:40 +0200 <geekosaur> a big one is in typechecking where it just assumes you know about Hindley-Milner
2023-07-02 17:22:39 +0200txaas(~txaas@user/jarlg)
2023-07-02 17:22:43 +0200alexherbo2(~alexherbo@232.145.204.77.rev.sfr.net) (Remote host closed the connection)
2023-07-02 17:23:26 +0200infinity0(~infinity0@pwned.gg)
2023-07-02 17:24:27 +0200 <geekosaur> (worse, iirc it assumes you know about H-M as modified for typeclasses)
2023-07-02 17:25:09 +0200 <chromoblob> does mentioning "Haskell uses a traditional Hindley-Milner polymorphic type system" automatically give the semantics for fn application and lambdas?
2023-07-02 17:25:33 +0200 <geekosaur> no, just for typechecking
2023-07-02 17:25:46 +0200 <chromoblob> then where does it specify the semantics?
2023-07-02 17:25:50 +0200 <ncf> don't you get that from saying "haskell is based on the lambda-calculus"?
2023-07-02 17:25:53 +0200 <geekosaur> you're looking for the lambda calculys
2023-07-02 17:26:21 +0200 <chromoblob> yeah C++ and Haskell's specifications are two extremes
2023-07-02 17:28:49 +0200mechap(~mechap@user/mechap) (Quit: WeeChat 4.0.0)
2023-07-02 17:29:10 +0200 <ncf> Âť Although the kernel is not formally specified, it is essentially a slightly sugared variant of the lambda calculus with a straightforward denotational semantics.
2023-07-02 17:33:32 +0200titibandit(~titibandi@user/titibandit) (Ping timeout: 240 seconds)
2023-07-02 17:36:38 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-07-02 17:39:49 +0200 <nyc> I'm still having trouble figuring out what those symbols are in the ticky ticky profiles.
2023-07-02 17:40:56 +0200 <nyc> Lines like this are what I'm trying to attribute:
2023-07-02 17:41:27 +0200 <nyc> 10384 0 0 2 .M go15{v s1LT0} (Foo.Bar.Snoo) (fun) in rbwV
2023-07-02 17:45:39 +0200smalltalkman(uid545680@id-545680.hampstead.irccloud.com)
2023-07-02 17:49:43 +0200euandreh(~Thunderbi@189.6.18.7)
2023-07-02 17:50:38 +0200nick__(~nick@98.186.208.255) (Ping timeout: 246 seconds)
2023-07-02 17:51:28 +0200 <bratwurst> i've had the greatest idea ever.
2023-07-02 17:52:00 +0200 <bratwurst> i was jumping around ghc source and realized i can generate a "trace" of the program by tracking how i was jumping around
2023-07-02 17:52:13 +0200Pickchea(~private@user/pickchea)
2023-07-02 17:52:32 +0200kimiamania6(~681cf57f@user/kimiamania) (Ping timeout: 250 seconds)
2023-07-02 17:52:54 +0200 <bratwurst> so that's what i'm going to work on today. learning elisp and making a mode that can track my jumps so i can use this log to generate a "picture" of whatever i'm looking at
2023-07-02 17:53:30 +0200 <EvanR> very iron man
2023-07-02 17:53:52 +0200 <EvanR> jarvis show me something
2023-07-02 17:54:28 +0200 <bratwurst> well what's a computer for if not to extend one's brain?
2023-07-02 17:55:15 +0200kimiamania6(~681cf57f@user/kimiamania)
2023-07-02 17:58:32 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 17:58:36 +0200sudden(~cat@user/sudden) (Ping timeout: 250 seconds)
2023-07-02 17:58:40 +0200 <monochrom> To replace one's brain.
2023-07-02 17:58:52 +0200 <juri_> to backup one's brain?
2023-07-02 17:59:19 +0200sudden(~cat@user/sudden)
2023-07-02 18:00:39 +0200 <geekosaur> <cynic> no, IRC/matrix/reddit/etc. is to replace one's brain </cynic>
2023-07-02 18:01:18 +0200 <EvanR> internet hive mind
2023-07-02 18:01:53 +0200 <monochrom> OK, correction: To replace everyone's brain. :)
2023-07-02 18:03:00 +0200machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Remote host closed the connection)
2023-07-02 18:03:59 +0200Las[m]1(~lasmatrix@2001:470:69fc:105::74e) (Remote host closed the connection)
2023-07-02 18:05:03 +0200banner(~banner@114-129-185-30.ip4.superloop.au) (Remote host closed the connection)
2023-07-02 18:06:25 +0200banner(~banner@114-129-185-30.ip4.superloop.au)
2023-07-02 18:07:01 +0200pavonia(~user@user/siracusa) (Quit: Bye!)
2023-07-02 18:09:57 +0200nick__(~nick@98.186.210.65)
2023-07-02 18:10:18 +0200freeside(~mengwong@103.252.202.189) (Ping timeout: 250 seconds)
2023-07-02 18:14:22 +0200nick__(~nick@98.186.210.65) (Ping timeout: 260 seconds)
2023-07-02 18:16:36 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-07-02 18:22:55 +0200freeside(~mengwong@103.252.202.189)
2023-07-02 18:27:17 +0200 <bratwurst> monochrom: indeed. that is my goal in life. to create a small shell scrip
2023-07-02 18:27:24 +0200 <bratwurst> that replicates
2023-07-02 18:27:38 +0200 <bratwurst> and infects everyone, leading to logic in the world
2023-07-02 18:29:14 +0200 <maerwald> logic?
2023-07-02 18:29:53 +0200 <EvanR> make sure the script isn't written in haskell, whose logic is deeply flawed
2023-07-02 18:30:12 +0200Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-07-02 18:31:38 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 18:33:28 +0200azimut(~azimut@gateway/tor-sasl/azimut)
2023-07-02 18:34:42 +0200SrPx(sid108780@id-108780.uxbridge.irccloud.com) (Server closed connection)
2023-07-02 18:35:23 +0200SrPx(sid108780@id-108780.uxbridge.irccloud.com)
2023-07-02 18:37:47 +0200tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-07-02 18:40:34 +0200 <monochrom> Oh as if shell script logic isn't :)
2023-07-02 18:43:37 +0200titibandit(~titibandi@user/titibandit)
2023-07-02 18:43:45 +0200 <hpc> shell script is untyped, so it has no logic
2023-07-02 18:43:58 +0200 <hpc> haskell's logic is merely flawed, and therefore much better
2023-07-02 18:43:58 +0200 <maerwald> that makes no sense
2023-07-02 18:44:11 +0200 <monochrom> You can switch attention to its runtime logic.
2023-07-02 18:44:42 +0200NiKaN(sid385034@id-385034.helmsley.irccloud.com) (Server closed connection)
2023-07-02 18:44:45 +0200 <hpc> runtime details sounds like -offtopic talk :P
2023-07-02 18:44:55 +0200 <monochrom> Alternatively you change "no type" to "one type, only one type".
2023-07-02 18:45:17 +0200 <monochrom> Indeed, that would be the string type. :)
2023-07-02 18:45:21 +0200NiKaN(sid385034@id-385034.helmsley.irccloud.com)
2023-07-02 18:47:42 +0200euandreh(~Thunderbi@189.6.18.7) (Ping timeout: 245 seconds)
2023-07-02 18:47:44 +0200 <ncf> stringly typed
2023-07-02 18:47:54 +0200 <monochrom> :)
2023-07-02 18:48:55 +0200 <Franciman> lol
2023-07-02 18:51:14 +0200jaror[m](~jaror@2001:470:69fc:105::265) (Server closed connection)
2023-07-02 18:51:30 +0200jaror[m](~jaror@2001:470:69fc:105::265)
2023-07-02 18:53:38 +0200Buggys(Buggys@Buggy.shelltalk.net) (Ping timeout: 246 seconds)
2023-07-02 18:55:35 +0200euandreh(~Thunderbi@189.6.18.7)
2023-07-02 18:55:45 +0200Igloo(~ian@matrix.chaos.earth.li) (Ping timeout: 240 seconds)
2023-07-02 18:59:38 +0200freeside(~mengwong@103.252.202.189) (Ping timeout: 260 seconds)
2023-07-02 18:59:41 +0200Inst__(~Inst@2601:6c4:4081:2fc0:4ce0:dbb4:3e84:48a2)
2023-07-02 19:01:52 +0200Buggys(Buggys@shelltalk.net)
2023-07-02 19:02:35 +0200Inst_(~Inst@2601:6c4:4081:2fc0:4ce0:dbb4:3e84:48a2) (Ping timeout: 246 seconds)
2023-07-02 19:04:02 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 250 seconds)
2023-07-02 19:07:27 +0200 <dolio> The original lambda calculus for logic was untyped. Of course, that didn't work out.
2023-07-02 19:08:02 +0200eggplantade(~Eggplanta@2600:1700:38c5:d800:bd12:aba9:a757:ddbd)
2023-07-02 19:08:51 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-07-02 19:10:57 +0200 <bratwurst> maerwald: i see logic as successive approximations of the real world. reducing everything till i have a nice formal system
2023-07-02 19:11:08 +0200 <maerwald> that sounds boring
2023-07-02 19:11:35 +0200 <maerwald> there's no point in logic if there is no goal
2023-07-02 19:11:37 +0200 <EvanR> logics are tools, use the right tool for the job
2023-07-02 19:11:39 +0200 <bratwurst> it's how i know i know things
2023-07-02 19:12:11 +0200 <bratwurst> there's no point to anything. logic just leads to pretty patterns
2023-07-02 19:12:19 +0200 <bratwurst> i like prettiness
2023-07-02 19:12:33 +0200 <maerwald> buy a cute cat?
2023-07-02 19:12:36 +0200 <bratwurst> everything must be tidy. you will be organized
2023-07-02 19:12:43 +0200 <monochrom> I thought you meant refining your formal system until it shows no difference from the real world. I mean, you wrote "successive approximations".
2023-07-02 19:13:00 +0200 <bratwurst> the world is infinite and my models finite
2023-07-02 19:13:02 +0200 <geekosaur> doesn't gĂśdel have the last laugh there?
2023-07-02 19:13:42 +0200 <monochrom> And the first laugh too.
2023-07-02 19:14:52 +0200 <Rembane> Law of the excluded laugh?
2023-07-02 19:15:19 +0200 <monochrom> No, GĂśdel has the first laugh. I think Turing has the 2nd and last laugh. And if Turing did not work on adding oracles and the arithmetic hierarchy, there might have been infinitely more laughs from other people.
2023-07-02 19:15:56 +0200 <mauke> https://en.wikipedia.org/wiki/Billion_laughs_attack
2023-07-02 19:16:39 +0200 <monochrom> That oddly sounds like a thing in Chinese kung-fu fiction. :)
2023-07-02 19:17:07 +0200 <maerwald> can you just stop laughing? It's really loud
2023-07-02 19:17:11 +0200 <hpc> lol
2023-07-02 19:17:17 +0200 <monochrom> You know, seven-point heart explode techique (from Kill Bill vol 2), so why not also billiion laughs attack.
2023-07-02 19:18:18 +0200 <mauke> from there we get batman (the killing joke) and monty python
2023-07-02 19:19:01 +0200 <EvanR> 10,000 peony blossom hand
2023-07-02 19:19:57 +0200 <maerwald> what's new in haskell? oh... aeson broke half the ecosystem
2023-07-02 19:20:03 +0200 <maerwald> streamly too
2023-07-02 19:20:17 +0200 <maerwald> I don't feel like updating my packages anymore
2023-07-02 19:20:50 +0200 <EvanR> maybe the universe is infinite but you have a finite amount of information in a given schwarzschild radius
2023-07-02 19:21:05 +0200 <monochrom> I'm in the other half because I wrote "aeson < 2.2" and I also use cabal freeze.
2023-07-02 19:22:02 +0200 <monochrom> But yeah I should check whether I need changes to use 2.2
2023-07-02 19:22:10 +0200 <hpc> EvanR: there's an amusing physical lower bound on big-O that uses thata property :D
2023-07-02 19:22:42 +0200 <monochrom> Wait, lower bound on big-O? Is that a minimax thing?
2023-07-02 19:23:14 +0200 <hpc> because of the speed of light, as you have more memory most of it ends up farther away from you
2023-07-02 19:23:24 +0200 <hpc> so accessing it takes longer, preventing you from achieving O(n)
2023-07-02 19:23:51 +0200 <monochrom> "Is that a space leak?" butterfly man meme :)
2023-07-02 19:24:01 +0200 <hpc> or i think O(1)?
2023-07-02 19:24:19 +0200 <hpc> i need to go find the actual math again
2023-07-02 19:24:52 +0200RedNifre2RedNifre
2023-07-02 19:25:41 +0200 <bratwurst> as i've been reading about frp i've been having ideas
2023-07-02 19:25:42 +0200 <monochrom> I should be getting at least Ί(1) because I can keep one unit of storage close to me.
2023-07-02 19:26:19 +0200 <bratwurst> one way i want to think about it is as a resource that gets used up.
2023-07-02 19:26:21 +0200 <monochrom> It is keeping unlimited storage close to me that is unsustainable because too much stuff within a fixed distance => black hole
2023-07-02 19:26:21 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 19:26:47 +0200 <bratwurst> so instead of time you have a counter that gets decremented every time you take a step
2023-07-02 19:26:54 +0200 <nyc> Can a single OPTIONS_GHC pragma take more than one option or do they need to be added to other OPTIONS_GHC pragmas on different lines?
2023-07-02 19:27:01 +0200 <monochrom> And then yeah even Θ(n) becomes difficult because most of it has to be far far away.
2023-07-02 19:27:09 +0200 <hpc> one of my professors once said moore's law implies P=NP
2023-07-02 19:27:24 +0200 <maerwald> nyc: https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/pragmas.html
2023-07-02 19:27:27 +0200 <monochrom> Hell, P=EXPTIME.
2023-07-02 19:27:27 +0200 <EvanR> bratwurst, that's the weirdest version of FRP I've heard yet
2023-07-02 19:27:39 +0200 <maerwald> nyc: it says *flags* (plural)
2023-07-02 19:27:41 +0200 <hpc> the P algorithm for anything NP is... wait for enough doublings that the problem takes an hour, then buy a new computer and use the naive algorithm
2023-07-02 19:27:50 +0200 <monochrom> Yeah, that.
2023-07-02 19:28:29 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 246 seconds)
2023-07-02 19:28:48 +0200 <EvanR> bratwurst, before the term was diluted to all hell, FRP involved a continuous time rather than steps
2023-07-02 19:29:11 +0200 <monochrom> I also put multiple extensions on one single LANGUAGE pragma. I also make it lowercase "language".
2023-07-02 19:29:19 +0200 <bratwurst> EvanR: yeah i want to think in terms of my program being a sequence
2023-07-02 19:29:49 +0200 <EvanR> that's certainly a more traditional route to go
2023-07-02 19:29:50 +0200 <bratwurst> EvanR: will you help me articulate my ideas more so i know what concrete thing to use?
2023-07-02 19:29:52 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 19:30:34 +0200 <bratwurst> i've been having an idea and i'm just not sure where it fits in with existing stuff
2023-07-02 19:30:43 +0200 <bratwurst> i see my program as an unfold
2023-07-02 19:30:58 +0200 <monochrom> "This solution fills a much-needed gap."
2023-07-02 19:31:01 +0200 <EvanR> you might be thinking of a discrete dynamical system. A set of states S, a starting state, and a function on S which moves from some state to the next state. By iterating your function on the start state you create an orbit, a sequence
2023-07-02 19:31:13 +0200 <EvanR> :t iterate
2023-07-02 19:31:16 +0200 <lambdabot> (a -> a) -> a -> [a]
2023-07-02 19:32:08 +0200 <monochrom> I support sticking to continuous time too.
2023-07-02 19:32:31 +0200 <monochrom> Actually I support dense time.
2023-07-02 19:32:36 +0200 <mauke> ... and then he plancked all over them
2023-07-02 19:32:46 +0200 <monochrom> heh
2023-07-02 19:33:32 +0200 <bratwurst> monochrom: i like the idea of my discrete system being somehow compatible with a continuous system
2023-07-02 19:33:46 +0200 <bratwurst> i have no need for continuous time in my app
2023-07-02 19:34:04 +0200 <bratwurst> so i'm not trying to argue my approach is best
2023-07-02 19:34:12 +0200 <monochrom> Well, I think even Elliot himself needed only density, not full-blown continuity.
2023-07-02 19:34:40 +0200 <EvanR> consider the idea of a functor from Time to a space consisting of your program states and paths between states. Then discrete time and continuous time both fit that picture
2023-07-02 19:34:42 +0200 <bratwurst> density is when for every two you can get another between correct?
2023-07-02 19:35:19 +0200 <EvanR> assuming your target space supports what you want
2023-07-02 19:35:21 +0200 <monochrom> Between every two events of different times, it is permitted to have yet another event between them = density. We only ever need that.
2023-07-02 19:35:44 +0200 <mauke> sounds rational
2023-07-02 19:35:45 +0200 <EvanR> you probably don't even need that xD
2023-07-02 19:35:53 +0200 <monochrom> Yeah, we just need the rationals.
2023-07-02 19:36:09 +0200 <EvanR> pacman needs rationals and square root of 2
2023-07-02 19:36:23 +0200 <monochrom> Full-blown continuous time means you can also do epsilon-delta proofs, which I haven't seen needed.
2023-07-02 19:36:25 +0200 <EvanR> in case you are going on different axes
2023-07-02 19:36:39 +0200 <monochrom> For example, Zeno paradoxes.
2023-07-02 19:36:46 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 19:36:46 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 19:37:13 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0)
2023-07-02 19:38:01 +0200 <nyc> Are the choices for names of fresh local symbols in the core & STG generated using time of day or similar?
2023-07-02 19:38:17 +0200 <maerwald> phase of the moon
2023-07-02 19:38:37 +0200 <maerwald> also different during the year of the chicken
2023-07-02 19:39:46 +0200 <monochrom> I conjecture hash of your file.
2023-07-02 19:40:29 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-07-02 19:40:49 +0200 <hpc> the symbol names are tuned per-person to subliminally make you write more haskell code :D
2023-07-02 19:43:01 +0200 <monochrom> My conjecture fails.
2023-07-02 19:45:21 +0200 <hpc> if only there was some way to discover the exact algorithm it uses... :P
2023-07-02 19:45:50 +0200 <bratwurst> i think i want to redo reactive-banana
2023-07-02 19:46:12 +0200 <nyc> hpc: It's not obvious to me from the ghc source.
2023-07-02 19:46:15 +0200 <bratwurst> i have no doubt what i do will be crappy but i feel there is something wrong conceptually with rb
2023-07-02 19:46:16 +0200 <EvanR> that reflex got away with only requiring time have an Ord instance says it's more about the time functorial nature of your simulation than the detailed topology of time
2023-07-02 19:46:23 +0200 <monochrom> Um frankly performing 5 black-box experiments on this is still easier and more fun than digging through GHC source. :)
2023-07-02 19:46:48 +0200 <monochrom> Perhaps I should have joined biology after all...
2023-07-02 19:46:53 +0200 <bratwurst> by wrong i mean "not right for me"
2023-07-02 19:47:05 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 19:47:06 +0200 <monochrom> (I had higher biology marks than math marks in school.)
2023-07-02 19:47:08 +0200__monty__(~toonn@user/toonn)
2023-07-02 19:47:10 +0200 <geekosaur> have you looked at other FRP systems such as Yampa?
2023-07-02 19:47:33 +0200 <bratwurst> i want my app to be a producer of a sequence of abstract events which are then interpreted
2023-07-02 19:47:53 +0200 <bratwurst> so my app has no concept of sequence
2023-07-02 19:48:05 +0200 <hackyhacker> Hello how do I use a pure function in do notation?
2023-07-02 19:48:05 +0200 <hackyhacker> like how do I do this: https://paste.tomsmeding.com/5evBl0gy
2023-07-02 19:48:06 +0200 <bratwurst> er, no i said that wrong. hold pu
2023-07-02 19:48:21 +0200 <hpc> hackyhacker: let b = process a
2023-07-02 19:48:33 +0200 <hackyhacker> oh ok thanks
2023-07-02 19:49:06 +0200 <int-e> :t readLn
2023-07-02 19:49:07 +0200 <lambdabot> Read a => IO a
2023-07-02 19:49:19 +0200 <int-e> (it has no argument)
2023-07-02 19:49:36 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 19:49:42 +0200 <hpc> ah, that too
2023-07-02 19:50:15 +0200 <chromoblob> probie: (about subset-of-HS to JS transpiler) should i reuse GHC's STG generator or should i implement G-machine myself? i don't want to squeeze all performance, and i want a smaller transpiler
2023-07-02 19:50:16 +0200 <EvanR> bratwurst, bacon, flapjacks, and many other knock offs are all about events. Probably shouldn't have jumped on the FRP jargonwagon
2023-07-02 19:50:27 +0200 <hpc> hackyhacker: there's some other nice way you can tighten up that code too, like b <- process <$> readLn
2023-07-02 19:51:03 +0200 <hpc> :t (<$>)
2023-07-02 19:51:04 +0200 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-07-02 19:51:17 +0200 <bratwurst> EVanR: thank you for the pointers. you're right i think i want to find libraries with a different approach
2023-07-02 19:51:17 +0200 <hackyhacker> :t fmap
2023-07-02 19:51:19 +0200 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-07-02 19:51:31 +0200 <hackyhacker> is it the same?
2023-07-02 19:51:33 +0200 <hpc> yep
2023-07-02 19:51:34 +0200 <ski> yes
2023-07-02 19:51:41 +0200 <hackyhacker> ah ok thanks
2023-07-02 19:51:45 +0200 <hpc> @src (<$>)
2023-07-02 19:51:45 +0200 <lambdabot> f <$> a = fmap f a
2023-07-02 19:51:47 +0200 <hackyhacker> very helpful to noobies here
2023-07-02 19:51:57 +0200 <chromoblob> and it cannot be not same because of its polymorphic type
2023-07-02 19:52:37 +0200 <EvanR> heh, there's only one function with that type?
2023-07-02 19:52:47 +0200 <EvanR> in fmap we trust
2023-07-02 19:52:55 +0200 <ski> @type undefined `asTypeOf` fmap
2023-07-02 19:52:56 +0200 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-07-02 19:52:58 +0200 <hpc> only one lawful function
2023-07-02 19:53:14 +0200 <EvanR> only one function mentionable in polite company
2023-07-02 19:53:21 +0200 <hpc> bottom inhabits every type, and you can do other yucky stuff like unsafeCoerce (my favorite function)
2023-07-02 19:54:34 +0200 <bratwurst> EvanR: what is flapjacks? a search for "haskell flapjacks" doesn't reveal it
2023-07-02 19:54:46 +0200 <EvanR> those were javascript based
2023-07-02 19:54:58 +0200 <EvanR> but there were some haskell versions floating around
2023-07-02 19:55:04 +0200 <EvanR> sodium?
2023-07-02 19:55:25 +0200 <geekosaur> wouldn't event based ones mostly be free monads?
2023-07-02 19:56:13 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 19:56:13 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 19:57:22 +0200 <EvanR> more recent hotness in this area is bearriver which is based on monadic stream functions
2023-07-02 20:00:10 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 20:00:40 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 20:00:42 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 20:00:42 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 20:01:19 +0200acidjnk(~acidjnk@p200300d6e7072f17393f0c042d41b426.dip0.t-ipconnect.de)
2023-07-02 20:02:01 +0200Igloo(~ian@matrix.chaos.earth.li)
2023-07-02 20:03:52 +0200 <nyc> It looks like Unique does something akin to unsafePerformIO...
2023-07-02 20:06:42 +0200severen[m](~severenmt@2001:470:69fc:105::2:9932) (Server closed connection)
2023-07-02 20:06:56 +0200severen[m](~severenmt@2001:470:69fc:105::2:9932)
2023-07-02 20:07:06 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 20:08:07 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 20:10:32 +0200driib(~driib@vmi931078.contaboserver.net) (Quit: The Lounge - https://thelounge.chat)
2023-07-02 20:16:04 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 20:16:04 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 20:17:07 +0200 <nyc> I can't find where it gets the initial value from by default exactly, but I see a -dinitial-unique flag.
2023-07-02 20:19:06 +0200 <bratwurst> thinking about frp i've realized something. there is a fundamental action. there is only so much stuff. the fundamental action is a transformer of stuff to stuff
2023-07-02 20:19:46 +0200 <bratwurst> so my first primitive is a transformer of some type a
2023-07-02 20:20:44 +0200 <bratwurst> i have a "poller". it's an IO action that collects events
2023-07-02 20:21:27 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-07-02 20:21:38 +0200 <bratwurst> i also introduce "concurrency". i will have a list of actions that describes what they touch
2023-07-02 20:21:49 +0200 <bratwurst> ie, shared variables
2023-07-02 20:22:03 +0200 <int-e> nyc: the defaults are in compiler/GHC/Driver/DynFlags.hs; the command line flags are defined in compiler/GHC/Driver/Session.hs and there's a call to `initUniqSupply` in ghc/Main.hs
2023-07-02 20:22:10 +0200gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-07-02 20:22:41 +0200 <bratwurst> i can reuse portions of rb to implement this
2023-07-02 20:22:59 +0200 <int-e> . o O ( distributed computing? )
2023-07-02 20:23:02 +0200int-eruns
2023-07-02 20:23:52 +0200 <bratwurst> int-e: my brain is trying to understand dependent types, proving memory safety, concurrency, now reactive-banana and frp
2023-07-02 20:24:18 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 20:24:21 +0200 <int-e> well, don't forget to breathe
2023-07-02 20:24:22 +0200 <bratwurst> i'm simultaneously trying to understand very general things while trying to make things happen with what i have
2023-07-02 20:24:38 +0200 <bratwurst> int-e: top notch advice
2023-07-02 20:24:48 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 20:31:53 +0200 <glguy> I'm working on good test coverage for my package and I debating between some nonsense sets to get coverage of GHC derived typeclasses or accepting that those things don't need tests and I'm not getting a high percentage :-S
2023-07-02 20:31:56 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 20:33:09 +0200 <glguy> Like I have a feeling I'm not going to be adding anything when I verify that the Read instance is solid :)
2023-07-02 20:33:30 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-07-02 20:33:42 +0200 <ncf> don't let the numbers control you
2023-07-02 20:34:32 +0200 <glguy> But the number is right there on Hackage now :)
2023-07-02 20:35:19 +0200 <[exa]> 100% looks too nice
2023-07-02 20:36:44 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 20:37:43 +0200emmanuelux(~emmanuelu@user/emmanuelux)
2023-07-02 20:39:09 +0200Pickchea(~private@user/pickchea)
2023-07-02 20:40:21 +0200driib(~driib@vmi931078.contaboserver.net)
2023-07-02 20:47:11 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca)
2023-07-02 20:47:54 +0200Midjak(~Midjak@82.66.147.146)
2023-07-02 20:48:25 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 240 seconds)
2023-07-02 20:50:22 +0200 <monochrom> I wonder if adding a test for `reads "" == []` improves the percentage without doing real work. >:)
2023-07-02 20:54:50 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 20:54:50 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 20:54:50 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 20:56:46 +0200 <chromoblob> genSym.c
2023-07-02 20:57:01 +0200 <monochrom> Wait, it's in C??!!!
2023-07-02 20:57:11 +0200 <chromoblob> yeah my thought
2023-07-02 20:57:16 +0200 <monochrom> heh
2023-07-02 20:57:22 +0200 <nyc> chromoblob: -dinitial-unique=0 for deterministic builds?
2023-07-02 20:57:27 +0200 <dolio> I don't know what coverage it's tracking, but don't you usually have to go down every branch? So you need a bunch of those trivial tests.
2023-07-02 20:57:27 +0200 <chromoblob> it seems that it's for performance
2023-07-02 20:58:54 +0200 <dolio> I think that's what hpc tracks, at least.
2023-07-02 20:59:27 +0200 <monochrom> :(
2023-07-02 20:59:29 +0200Sgeo(~Sgeo@user/sgeo)
2023-07-02 20:59:36 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-07-02 20:59:37 +0200 <nyc> chromoblob: Can you figure out how the uniqueness generator initialises the uniqueness counter?
2023-07-02 20:59:44 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 250 seconds)
2023-07-02 21:00:11 +0200 <monochrom> Then again I managed to think up one branch that no one else thinks of. :) #confirmationbias
2023-07-02 21:00:19 +0200 <nyc> chromoblob: I was able to track down the case whre -dinitial-unique= got passed, but couldn't find what happened otherwise.
2023-07-02 21:01:33 +0200 <chromoblob> well there's a line "HsInt ghc_unique_counter = 0;
2023-07-02 21:01:34 +0200 <chromoblob> "
2023-07-02 21:01:44 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-07-02 21:01:55 +0200 <chromoblob> note the default value
2023-07-02 21:02:17 +0200 <nyc> chromoblob: initUniqSupply has a deep call chain.
2023-07-02 21:02:29 +0200jocke-l(jocke-l@a.x0.is) (Quit: WeeChat 3.0)
2023-07-02 21:03:48 +0200jocke-l(jocke-l@a.x0.is)
2023-07-02 21:04:48 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 21:04:49 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 21:04:49 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 21:05:06 +0200 <nyc> Or something else; I guess that's just doing two pokes.
2023-07-02 21:05:07 +0200 <glguy> I figured out how to put haddock comments on a haddock generated parser. Haddock doesn't generate type-signatures for the parsers, so you can write one in the code section at the bottom of the file and put a haddock comment on that and GHC will deal with the fact that the file is in an unusual order.
2023-07-02 21:05:26 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca) (Ping timeout: 246 seconds)
2023-07-02 21:05:50 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-07-02 21:07:20 +0200 <chromoblob> i can't find initGenSym
2023-07-02 21:08:37 +0200 <chromoblob> ok it was in older ver
2023-07-02 21:09:26 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 246 seconds)
2023-07-02 21:10:23 +0200euandreh(~Thunderbi@189.6.18.7) (Remote host closed the connection)
2023-07-02 21:10:47 +0200nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-07-02 21:11:42 +0200 <chromoblob> nyc: this shows initUniqSupply only twice https://gitlab.haskell.org/search?search=initUniqSupply&nav_source=navbar&project_id=1&group_id=2&…
2023-07-02 21:11:50 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 21:11:50 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 21:11:57 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-07-02 21:12:06 +0200 <chromoblob> 1st is definition, 2nd is the only call
2023-07-02 21:12:18 +0200 <nyc> chromoblob: I was thinking of something close to the top of the call chain instead of that.
2023-07-02 21:12:42 +0200isomorpheme[m](~isomorphe@2001:470:69fc:105::3:731a) (Server closed connection)
2023-07-02 21:12:57 +0200isomorpheme[m](~isomorphe@2001:470:69fc:105::3:731a)
2023-07-02 21:13:32 +0200waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-07-02 21:14:06 +0200 <EvanR> genSym is funny
2023-07-02 21:14:46 +0200 <EvanR> generating unique values efficiently and composably should have been in the awkward squad
2023-07-02 21:14:46 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 21:14:46 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 21:14:46 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 21:15:11 +0200 <EvanR> instead we use unsafePerformIO
2023-07-02 21:17:51 +0200 <nyc> There is some kind of indeterminacy here but I can't find where it happens.
2023-07-02 21:19:26 +0200dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 246 seconds)
2023-07-02 21:19:58 +0200doveinedia
2023-07-02 21:20:54 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca)
2023-07-02 21:21:04 +0200 <chromoblob> ahhh can't jump to a definition in Gitlab....
2023-07-02 21:23:18 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au)
2023-07-02 21:23:18 +0200dibblego(~dibblego@116-255-1-157.ip4.superloop.au) (Changing host)
2023-07-02 21:23:18 +0200dibblego(~dibblego@haskell/developer/dibblego)
2023-07-02 21:25:04 +0200reach(~reach@bras-base-toroon2643w-grc-19-74-12-129-40.dsl.bell.ca) (Read error: Connection reset by peer)
2023-07-02 21:27:33 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 21:31:04 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 21:31:23 +0200 <nyc> I'm trying to do -dinitial-unique=0 in lieu of tracking down the source of the non-determinism.
2023-07-02 21:33:00 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 21:33:00 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 21:34:38 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-07-02 21:34:39 +0200 <chromoblob> "The compiler itself is written entirely in Haskell" LIES
2023-07-02 21:35:10 +0200coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-07-02 21:35:44 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 21:36:44 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 21:38:29 +0200 <EvanR> it's ok because C is a purely functional language
2023-07-02 21:39:31 +0200 <chromoblob> :D
2023-07-02 21:45:05 +0200hisa387(~hisa38@104-181-102-238.lightspeed.wepbfl.sbcglobal.net) (Ping timeout: 240 seconds)
2023-07-02 21:56:44 +0200notzmv(~zmv@user/notzmv)
2023-07-02 21:57:56 +0200kimiamania6(~681cf57f@user/kimiamania) (Ping timeout: 240 seconds)
2023-07-02 21:59:51 +0200kimiamania6(~681cf57f@user/kimiamania)
2023-07-02 22:00:32 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 22:02:07 +0200trev(~trev@user/trev) (Quit: trev)
2023-07-02 22:04:25 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:04:25 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:05:17 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 246 seconds)
2023-07-02 22:08:38 +0200_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-07-02 22:09:17 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 22:09:46 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 22:11:20 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:11:21 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:14:29 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 22:14:58 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 22:15:27 +0200 <hackyhacker> Is this in the standard library? ```count x = length . filter (==x)```
2023-07-02 22:15:49 +0200 <hackyhacker> eg: count 'l' "Hello" => 2
2023-07-02 22:18:46 +0200 <dolio> Don't think so.
2023-07-02 22:19:27 +0200 <Rembane> I think the definition is short enough that it never has been added.
2023-07-02 22:19:36 +0200 <dolio> Right.
2023-07-02 22:19:36 +0200 <geekosaur> something something Fairbairn threshold
2023-07-02 22:20:57 +0200 <geekosaur> also most of the times I've wanted something like that I was counting constructors so wanted a pattern match instead of `==`
2023-07-02 22:24:30 +0200 <hpc> there's a wonderful irony in how strangely difficult it just was to find the definition of "fairbairn threshold"
2023-07-02 22:25:21 +0200 <EvanR> :t sum (fmap f) -- where f maps things to 0 or 1
2023-07-02 22:25:22 +0200 <lambdabot> error:
2023-07-02 22:25:22 +0200 <lambdabot> Ambiguous occurrence ‘f’
2023-07-02 22:25:22 +0200 <lambdabot> It could refer to
2023-07-02 22:25:33 +0200 <EvanR> :t sum . fmap -- where f maps things to 0 or 1
2023-07-02 22:25:34 +0200 <lambdabot> (Foldable ((->) (f a)), Num (f b), Functor f) => (a -> b) -> f b
2023-07-02 22:25:48 +0200 <EvanR> oof
2023-07-02 22:26:11 +0200 <EvanR> :t \f -> sum . fmap f
2023-07-02 22:26:12 +0200 <lambdabot> (Foldable t, Num c, Functor t) => (a -> c) -> t a -> c
2023-07-02 22:27:28 +0200 <Rembane> EvanR: I love the APL vibes of that solution
2023-07-02 22:27:56 +0200 <jade[m]> I need to get into APL again
2023-07-02 22:28:11 +0200 <jade[m]> it's not as clean as haskell, but has a certain beauty to it still, imo
2023-07-02 22:29:02 +0200 <ncf> hot take: traverse, foldMap and all the other yoneda'd combinators fall below the fairbairn threshold
2023-07-02 22:29:47 +0200dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2023-07-02 22:29:51 +0200 <Rembane> ncf: Which function could they all be implemented in terms of?
2023-07-02 22:29:59 +0200 <ncf> fmap
2023-07-02 22:30:28 +0200 <Rembane> Cool.
2023-07-02 22:30:53 +0200 <ncf> traverse f = sequence . fmap f; foldMap f = fold . fmap f
2023-07-02 22:31:01 +0200 <glguy> about half the advent of code problems needed a counting function https://github.com/glguy/advent/blob/main/common/src/Advent/Prelude.hs#L35-L41
2023-07-02 22:31:11 +0200michalz(~michalz@185.246.207.200)
2023-07-02 22:33:06 +0200fendor(~fendor@2a02:8388:1640:be00:821b:25b5:c8f3:73a0) (Remote host closed the connection)
2023-07-02 22:33:41 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Quit: Bye!)
2023-07-02 22:34:16 +0200 <EvanR> stealing that
2023-07-02 22:34:34 +0200dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net)
2023-07-02 22:34:35 +0200ddellacosta(~ddellacos@143.244.47.100)
2023-07-02 22:35:01 +0200bontaq(~user@ool-45779b84.dyn.optonline.net)
2023-07-02 22:36:09 +0200 <jade[m]> I wondered whether you could have a functor instance based off of `Foldable` and `Monoid` along the lines of `fmap f = foldr ((<>) . f) mempty`, but im pretty sure the laws don't follow from that definition
2023-07-02 22:36:53 +0200 <glguy> some functors are foldable
2023-07-02 22:36:55 +0200 <glguy> ant not
2023-07-02 22:37:02 +0200 <glguy> are. not. :-o
2023-07-02 22:37:18 +0200 <Rembane> That is true, ants are generally not foldable.
2023-07-02 22:37:50 +0200 <Rembane> Out of curiosity, what's a counterexample?
2023-07-02 22:38:08 +0200 <jade[m]> that's what I was asking for
2023-07-02 22:38:09 +0200 <ski> of foldable ants ?
2023-07-02 22:38:13 +0200 <glguy> functions
2023-07-02 22:38:24 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:38:24 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:38:58 +0200 <dolio> F a = (a -> Integer) -> Integer
2023-07-02 22:39:01 +0200 <ski> well, `Yoneda f' is generally not `Foldable'
2023-07-02 22:39:32 +0200dipper(~dipper@117.61.125.236) (Ping timeout: 240 seconds)
2023-07-02 22:40:28 +0200 <ncf> Integer -> a
2023-07-02 22:42:11 +0200 <jade[m]> yeah but I meant that if a structure is both a monoid and a foldable you could use the above definition to build a functor instance
2023-07-02 22:42:24 +0200 <jade[m]> which I don't think works in general
2023-07-02 22:43:05 +0200dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2023-07-02 22:43:30 +0200 <glguy> Data.Map's Map is Foldable and Monoid and wouldn't work like that
2023-07-02 22:44:01 +0200 <glguy> Foldable forgets too much
2023-07-02 22:44:10 +0200 <jade[m]> that's what I was looking for, thanks!!
2023-07-02 22:44:12 +0200 <ncf> i think [] is pretty much the only one that would?
2023-07-02 22:44:47 +0200 <jade[m]> I think maybe too (?)
2023-07-02 22:45:55 +0200 <nyc> Okay, -dinitial-unique=0 didn't help make the build more deterministic.
2023-07-02 22:46:14 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 22:47:05 +0200 <nyc> Or at least things that appear to be randomly-generated in the ticky ticky profile don't show up in the final STG.
2023-07-02 22:47:14 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 22:47:23 +0200dtman34(~dtman34@2601:447:d000:93c9:6f54:cf51:938d:ead5)
2023-07-02 22:48:29 +0200 <ncf> yeah, maybe something like "subfunctors of the free monoid functor"
2023-07-02 22:48:39 +0200orcus-(~orcus@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:48:39 +0200dispater-(~dispater@81.78.253.214) (Remote host closed the connection)
2023-07-02 22:49:36 +0200 <ncf> you basically need to have foldMap pure = id
2023-07-02 22:49:37 +0200remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-07-02 22:50:09 +0200 <jade[m]> is pure here used informally?
2023-07-02 22:50:25 +0200 <jade[m]> because we never had an applicative, right?
2023-07-02 22:51:01 +0200 <ncf> yeah just referring to a pointed endofunctor with pure :: a -> f a, not necessarily an Applicative
2023-07-02 22:51:05 +0200 <nyc> 10078 0 0 2 .M go15{v s1MSI} (Foo.Bar.Snoo) (fun) in rbz1 has nothing to correlate it with in the final STG.
2023-07-02 22:52:24 +0200dispater-(~dispater@81.78.253.214)
2023-07-02 22:53:54 +0200L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-07-02 22:53:55 +0200orcus-(~orcus@81.78.253.214)
2023-07-02 22:57:43 +0200takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-07-02 22:58:37 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-07-02 23:01:05 +0200bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-07-02 23:01:18 +0200jumper149(~jumper149@base.felixspringer.xyz)
2023-07-02 23:05:59 +0200dtman34(~dtman34@2601:447:d000:93c9:6f54:cf51:938d:ead5) (Ping timeout: 264 seconds)
2023-07-02 23:07:48 +0200caryhartline(~caryhartl@168.182.58.169)
2023-07-02 23:08:44 +0200dtman34(~dtman34@2601:447:d000:93c9:6f54:cf51:938d:ead5)
2023-07-02 23:11:51 +0200Lycurgus(~juan@user/Lycurgus)
2023-07-02 23:24:02 +0200titibandit(~titibandi@user/titibandit) (Ping timeout: 250 seconds)
2023-07-02 23:25:05 +0200 <Inst__> curious, how bad an idea is variadic typeclasses for Haskell/
2023-07-02 23:25:12 +0200 <Inst__> I guess it's been discussed / considered before
2023-07-02 23:26:10 +0200 <jade[m]> how would that work?
2023-07-02 23:26:35 +0200 <jade[m]> I'm having a hard time imagining what it'd look like
2023-07-02 23:28:17 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2023-07-02 23:29:08 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Ping timeout: 240 seconds)
2023-07-02 23:29:21 +0200 <EvanR> how would variadic anything work, everything is of the form _ -> _
2023-07-02 23:29:44 +0200misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 252 seconds)
2023-07-02 23:30:09 +0200 <EvanR> maybe Inst__ wants the Printf class xD
2023-07-02 23:31:56 +0200 <Inst__> thanks for being merry :)
2023-07-02 23:32:01 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-07-02 23:32:17 +0200 <Inst__> the only real problem with Haskell, syntactically speaking, is that you don't even have opt-in natural variadic functions
2023-07-02 23:32:22 +0200 <Inst__> iirc, printf is exploiting undefined
2023-07-02 23:33:15 +0200 <ski> ?
2023-07-02 23:33:17 +0200 <Inst__> there's various workarounds, like [myType] or [MyType], unnatural variadic typeclasses, and default records
2023-07-02 23:33:48 +0200 <Inst__> the printf module has an undefined in the typeclass
2023-07-02 23:33:49 +0200Inst__Inst
2023-07-02 23:33:54 +0200jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 3.8)
2023-07-02 23:34:27 +0200 <EvanR> wat
2023-07-02 23:34:29 +0200 <ski> what do you mean by "printf is exploiting undefined" ?
2023-07-02 23:34:58 +0200 <jade[m]> I didn't even know that printf existed - the implementation seems ... oddly magical?
2023-07-02 23:35:13 +0200 <Inst> https://hackage.haskell.org/package/base-4.18.0.0/docs/src/Text.Printf.html#PrintfType
2023-07-02 23:35:35 +0200 <Inst> i recall printf has some kind of bottom in it
2023-07-02 23:35:39 +0200 <jade[m]> yeah I looked at that and I don't get it
2023-07-02 23:35:51 +0200j4cc3b(~jeffreybe@2601:98a:4200:4515:bc01:8d38:6200:7aef)
2023-07-02 23:36:01 +0200 <EvanR> Inst, the only use of undefined in that file is as a proxy
2023-07-02 23:36:38 +0200 <glguy> There's nothing exploitative about what printf does. And using undefined as a proxy is easily replaced with using Proxy, but that technique was a layer addition
2023-07-02 23:37:12 +0200merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 240 seconds)
2023-07-02 23:37:34 +0200 <dolio> I don't think Proxy was around when that module was written.
2023-07-02 23:37:47 +0200 <Inst> me neither, maybe an earlier version of printf was using undefined?
2023-07-02 23:37:57 +0200 <dolio> And it hasn't been updated presumably because no one really cares about Printf.
2023-07-02 23:38:18 +0200 <Inst> i really wish we had easier variadic functions, though, that's the only sore point in Haskell syntax
2023-07-02 23:38:46 +0200 <jade[m]> I never really got the need for variadic functions
2023-07-02 23:39:08 +0200 <jade[m]> besides printf it seems like you can always model it with a list?
2023-07-02 23:39:24 +0200 <jade[m]> I mean that'd work for printf too, more or less
2023-07-02 23:41:14 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-07-02 23:42:02 +0200L29Ah(~L29Ah@wikipedia/L29Ah)
2023-07-02 23:42:10 +0200FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-07-02 23:44:28 +0200shiraeeshi(~shiraeesh@46.42.244.46)
2023-07-02 23:44:50 +0200 <chromoblob> what's the language for .y extension?
2023-07-02 23:45:01 +0200 <monochrom> Would it be yacc?
2023-07-02 23:45:14 +0200 <monochrom> Either that or happy.
2023-07-02 23:45:22 +0200coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-07-02 23:46:22 +0200 <Hecate> chromoblob: the happy parser generator program
2023-07-02 23:47:41 +0200 <chromoblob> thanx
2023-07-02 23:49:58 +0200cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 240 seconds)
2023-07-02 23:52:17 +0200cafkafk(~cafkafk@fsf/member/cafkafk)
2023-07-02 23:55:26 +0200 <Inst> jade[m], tbh, variadic procedures are more useful than variadic functions
2023-07-02 23:55:27 +0200 <Inst> :)
2023-07-02 23:55:52 +0200 <Inst> i'd be happy if we had variadic functions restricted to monads
2023-07-02 23:56:39 +0200 <Inst> the average user who "enjoys" variadic functions is working on a scripting level
2023-07-02 23:56:56 +0200 <Inst> there, variadic functions are useful for being able to keep a single function and just overload the arguments
2023-07-02 23:57:28 +0200 <Inst> when you're actually doing business logic, variadic functions are likely more trouble than they're worth for the havoc they do to the type checker
2023-07-02 23:59:35 +0200gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-07-02 23:59:47 +0200 <chromoblob> is there a way to completely exclude functionality of language features and individual optimizations from GHC so that the functionality doesn't appear in compiled version?