IRCBrowse

2023/11/28

2023-11-28 00:08:55 +0100Jackneill(~Jackneill@20014C4E1E120500DDDE9742A0209DC5.dsl.pool.telekom.hu) (Ping timeout: 276 seconds)
2023-11-28 00:10:49 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 00:14:15 +0100Square(~Square@user/square)
2023-11-28 00:14:28 +0100 <madariaga> hi. I created a project with cabal init and added a new executable in some file, put module Main where at the top and wrote a main function. The thing builds and runs but inside neovim, with haskell-tools, I get a diagnostics message saying "Loading the module [...]/day01.hs failed ... It may not be listed in your .cabal file!". Any idea what is up with this? For what it's worth: if I open the "default" app/Main.hs cabal creates there is no
2023-11-28 00:14:28 +0100 <madariaga> diagnostic.
2023-11-28 00:14:35 +0100 <madariaga> sorry for the wall of text.
2023-11-28 00:16:42 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-28 00:16:54 +0100 <glguy> madariaga: Did you add an executable section to your .cabal file after creating the new executable?
2023-11-28 00:17:06 +0100 <madariaga> one more thing I did that may be causing this issue: I split build-depends, hs-source-dir and default-language into a common stanza which I then imported into the executable section
2023-11-28 00:17:30 +0100 <madariaga> glguy: yes. Actually I did this following your advent of code structure lol
2023-11-28 00:17:38 +0100 <glguy> It'll be easier to see what you did if you'll paste the .cabal file on a pastebin
2023-11-28 00:17:41 +0100 <glguy> ?pastebin
2023-11-28 00:17:41 +0100 <lambdabot> Unknown command, try @list
2023-11-28 00:17:51 +0100 <glguy> like https://paste.tomsmeding.com
2023-11-28 00:17:59 +0100 <madariaga> one sec
2023-11-28 00:22:10 +0100 <madariaga> glguy: https://paste.tomsmeding.com/Kw3naVHo
2023-11-28 00:22:24 +0100 <c_wraith> sharing hs-source-dir between multiple components sounds... risky
2023-11-28 00:23:01 +0100 <c_wraith> well, not like at risk of things breaking, necessarily, but a lot of unnecessary recompilation
2023-11-28 00:23:43 +0100 <madariaga> i just want to dump all the advent of code days solutions in the same directory and create one executable for each
2023-11-28 00:25:56 +0100 <monochrom> It should not be difficult to test the hypothesis "does this common stanza cause the neovim error?".
2023-11-28 00:26:14 +0100 <monochrom> I don't use neovim so I am not going to be the one testing it.
2023-11-28 00:26:21 +0100 <madariaga> true. Let me see
2023-11-28 00:27:06 +0100nek0(~nek0@2a01:4f8:222:2b41::12) (Quit: The Lounge - https://thelounge.chat)
2023-11-28 00:29:36 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-28 00:29:49 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com)
2023-11-28 00:30:54 +0100 <madariaga> yep it is. Without the common stanza, everything is fine. Furthermore, with the common stanza but bringing hs-source-dirs into hte executable section, the diagnostic goes away but code lenses stop working.
2023-11-28 00:31:27 +0100 <Axman6> does haskell-tools use hls?
2023-11-28 00:31:59 +0100 <madariaga> yes.
2023-11-28 00:32:22 +0100 <madariaga> checkhealth for it shows OK, version 2.4.0.0 running.
2023-11-28 00:33:17 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-28 00:33:20 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 00:33:34 +0100 <glguy> madariaga: the way I have the project structured works with hls on my computer for whatever that's worth
2023-11-28 00:33:39 +0100 <glguy> I don't use neovim , though
2023-11-28 00:34:21 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Remote host closed the connection)
2023-11-28 00:34:35 +0100 <madariaga> yeah I'm assuming this is an issue with neovim or with haskell-tools. Thanks for checking
2023-11-28 00:34:41 +0100 <glguy> c_wraith: the hs-source-dir sharing ends up not mattering because none of the executables import each other
2023-11-28 00:35:13 +0100 <glguy> and there's a separate library for shared code between executables
2023-11-28 00:35:40 +0100 <c_wraith> that will work in an AOC context, sure. :)
2023-11-28 00:36:15 +0100 <monochrom> "day01.hs" and other chatters strongly suggest an AOC context. :)
2023-11-28 00:37:38 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-11-28 00:40:30 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Remote host closed the connection)
2023-11-28 00:41:00 +0100 <Axman6> madariaga: is your hls up to date too?
2023-11-28 00:41:14 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-11-28 00:41:29 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935) (Client Quit)
2023-11-28 00:41:34 +0100 <madariaga> as far as ghcup shows, yes. 2.4.0.0 is the highest version it shows
2023-11-28 00:42:02 +0100 <Axman6> you might want to look at the config options in https://haskell-language-server.readthedocs.io/en/latest/configuration.html too
2023-11-28 00:42:09 +0100 <madariaga> i went down from ghc 9.8.1 to 9.4.7 in case that caused issues but it's the same.
2023-11-28 00:43:38 +0100 <madariaga> ah that could work, having an explicit config file. Thanks
2023-11-28 00:43:41 +0100John_Ivan(~John_Ivan@user/john-ivan/x-1515935)
2023-11-28 00:43:57 +0100 <glguy> Using ghc-9.4.7, vim, coc, and hls things open for me with editor integration
2023-11-28 00:44:54 +0100 <glguy> so you should be able to test that your editor is configured correctly opening my repository
2023-11-28 00:46:34 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-11-28 00:46:49 +0100 <madariaga> thanks. I'll try using the native lsp client in neovim
2023-11-28 00:47:05 +0100srk-(~sorki@user/srk)
2023-11-28 00:47:51 +0100nek0(~nek0@2a01:4f8:222:2b41::12)
2023-11-28 00:50:07 +0100srk(~sorki@user/srk) (Ping timeout: 255 seconds)
2023-11-28 00:50:07 +0100srk-srk
2023-11-28 00:54:19 +0100andreas303(andreas303@is.drunk.and.ready-to.party) (Ping timeout: 256 seconds)
2023-11-28 01:02:13 +0100chomwitt(~chomwitt@2a02:587:7a24:bc00:1ac0:4dff:fedb:a3f1) (Ping timeout: 268 seconds)
2023-11-28 01:02:57 +0100srk-(~sorki@user/srk)
2023-11-28 01:05:52 +0100srk(~sorki@user/srk) (Ping timeout: 255 seconds)
2023-11-28 01:05:53 +0100srk-srk
2023-11-28 01:11:02 +0100srk-(~sorki@user/srk)
2023-11-28 01:12:25 +0100srk|(~sorki@user/srk)
2023-11-28 01:12:52 +0100andreas303(andreas303@is.drunk.and.ready-to.party)
2023-11-28 01:13:56 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 268 seconds)
2023-11-28 01:15:10 +0100srk(~sorki@user/srk) (Ping timeout: 268 seconds)
2023-11-28 01:15:37 +0100srk|srk
2023-11-28 01:16:02 +0100srk-(~sorki@user/srk) (Ping timeout: 260 seconds)
2023-11-28 01:17:25 +0100jargon(~jargon@184.101.176.143)
2023-11-28 01:18:56 +0100madariaga(~madariaga@user/madariaga) (Quit: madariaga)
2023-11-28 01:22:32 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-11-28 01:25:01 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 01:26:14 +0100madariaga(~madariaga@user/madariaga) (Client Quit)
2023-11-28 01:27:22 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 01:36:01 +0100ridcully(~ridcully@p57b5294c.dip0.t-ipconnect.de) (Ping timeout: 276 seconds)
2023-11-28 01:39:47 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 01:39:59 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 01:41:10 +0100 <madariaga> alright, by writing a hie.yaml file and specifying each executable in cradle -> cabal HLS everything works
2023-11-28 01:42:01 +0100 <madariaga> thanks for your help everyone.
2023-11-28 01:43:52 +0100madariaga(~madariaga@user/madariaga) (Client Quit)
2023-11-28 01:45:19 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 260 seconds)
2023-11-28 01:50:30 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 01:51:40 +0100L29Ah(~L29Ah@wikipedia/L29Ah) (Ping timeout: 255 seconds)
2023-11-28 01:53:22 +0100tabemann(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net) (Remote host closed the connection)
2023-11-28 01:53:24 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Ping timeout: 268 seconds)
2023-11-28 01:55:46 +0100ridcully(~ridcully@p57b52dae.dip0.t-ipconnect.de)
2023-11-28 01:56:10 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 260 seconds)
2023-11-28 01:57:13 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 01:59:26 +0100notzmv(~zmv@user/notzmv)
2023-11-28 02:01:59 +0100mikess(~sam@user/mikess)
2023-11-28 02:02:05 +0100mikess(~sam@user/mikess) (Client Quit)
2023-11-28 02:02:32 +0100mikess(~sam@user/mikess)
2023-11-28 02:03:58 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 276 seconds)
2023-11-28 02:06:12 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net)
2023-11-28 02:07:51 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 02:08:13 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 02:10:39 +0100sadmax(~user@64.130.91.66)
2023-11-28 02:15:14 +0100caryhartline(~caryhartl@168.182.58.169)
2023-11-28 02:15:57 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-11-28 02:18:16 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 276 seconds)
2023-11-28 02:18:41 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-11-28 02:24:45 +0100fweht(uid404746@id-404746.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 02:29:26 +0100TonyStone(~TonyStone@cpe-74-76-57-186.nycap.res.rr.com) (Quit: Leaving)
2023-11-28 02:29:41 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 02:35:19 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 02:38:14 +0100tabemann(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net)
2023-11-28 02:42:05 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Ping timeout: 252 seconds)
2023-11-28 02:44:08 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-28 02:44:08 +0100ChanServ+v haskellbridge
2023-11-28 02:44:08 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Read error: Connection reset by peer)
2023-11-28 02:44:29 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-28 02:44:29 +0100ChanServ+v haskellbridge
2023-11-28 02:44:29 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Read error: Connection reset by peer)
2023-11-28 02:44:51 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-28 02:44:51 +0100ChanServ+v haskellbridge
2023-11-28 02:46:40 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Ping timeout: 255 seconds)
2023-11-28 02:47:04 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 02:49:13 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-28 02:49:55 +0100TMA(tma@twin.jikos.cz) (Ping timeout: 256 seconds)
2023-11-28 02:50:45 +0100TMA(tma@twin.jikos.cz)
2023-11-28 02:50:56 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net)
2023-11-28 02:53:22 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 276 seconds)
2023-11-28 02:59:21 +0100ubert1(~Thunderbi@91.141.52.8.wireless.dyn.drei.com)
2023-11-28 02:59:23 +0100ubert(~Thunderbi@77.119.173.120.wireless.dyn.drei.com) (Ping timeout: 268 seconds)
2023-11-28 02:59:23 +0100ubert1ubert
2023-11-28 03:00:04 +0100sadmax(~user@64.130.91.66) (Ping timeout: 255 seconds)
2023-11-28 03:01:58 +0100analoq(~yashi@user/dies) (Ping timeout: 260 seconds)
2023-11-28 03:03:46 +0100analoq(~yashi@user/dies)
2023-11-28 03:04:22 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 03:09:11 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 03:16:02 +0100xff0x(~xff0x@2405:6580:b080:900:f6fc:7981:2e92:1c0b) (Ping timeout: 268 seconds)
2023-11-28 03:16:49 +0100analoq(~yashi@user/dies) (Ping timeout: 255 seconds)
2023-11-28 03:17:06 +0100madariaga(~madariaga@user/madariaga) (Quit: madariaga)
2023-11-28 03:17:27 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 03:20:58 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 03:23:57 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-11-28 03:25:46 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 260 seconds)
2023-11-28 03:31:25 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 03:38:14 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 268 seconds)
2023-11-28 03:40:51 +0100 <iqubic> is Haskell2020 a thing now? Can I put that into my cabal file?
2023-11-28 03:43:32 +0100analoq(~yashi@user/dies)
2023-11-28 03:46:39 +0100caef^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2023-11-28 03:50:04 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 03:53:15 +0100 <geekosaur> Haskell2020 is not but GHC2020 is
2023-11-28 03:55:37 +0100newsham(~newsham@2603-800c-2c01-6825-6daa-0948-9100-d431.res6.spectrum.com)
2023-11-28 03:55:47 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 264 seconds)
2023-11-28 03:57:08 +0100 <newsham> lets say I have parsed the untyped lambda calculus, and then type checked it so that every term has a (value level) type annotation on it.  Does haskell have any tools suitable for constructing a typed lambda calculus from each term where the term's types have type level annotations on them? ie. dependent types based on the value level types?
2023-11-28 03:57:13 +0100 <geekosaur> and yes, you can specify it as the language
2023-11-28 03:58:41 +0100 <newsham> like `instance ... where func TInt expr = Constructor expr :: Int`
2023-11-28 03:59:30 +0100 <newsham> err `:: Expr Int`
2023-11-28 04:02:49 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-11-28 04:04:13 +0100 <jackdk> GADTs?
2023-11-28 04:04:32 +0100JeremyB99(~JeremyB99@208.64.173.6)
2023-11-28 04:05:02 +0100not_reserved(~not_reser@45.144.113.233)
2023-11-28 04:07:10 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 04:07:13 +0100td_(~td@i53870917.versanet.de) (Ping timeout: 268 seconds)
2023-11-28 04:07:24 +0100not_reserved(~not_reser@45.144.113.233) (Client Quit)
2023-11-28 04:07:38 +0100not_reserved(~not_reser@45.144.113.233)
2023-11-28 04:07:57 +0100 <EvanR> GADTs
2023-11-28 04:08:35 +0100td_(~td@i5387092B.versanet.de)
2023-11-28 04:09:40 +0100 <newsham> i thought that might be part of the answer, but can you be more concrete?
2023-11-28 04:11:20 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2023-11-28 04:11:39 +0100Feuermagier(~Feuermagi@user/feuermagier)
2023-11-28 04:11:56 +0100 <newsham> ie. `data MyNum = MyNum Typ Val`.  `data Typ = MyInt | MyInteger`.   `data TypedNum a = TypedNum val`. How can I write a func `f MyNum MyInt x = TypedNum x :: TypedNum Int` and `f MyNum MyInteger x = TypedNum x :: TypedNum Integer` ?
2023-11-28 04:12:48 +0100 <newsham> er.. thats not all correct, but I think you can understand the question?
2023-11-28 04:13:13 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 04:16:33 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-28 04:17:38 +0100matthewmosior(~matthewmo@096-059-082-099.res.spectrum.com)
2023-11-28 04:19:16 +0100matthewmosior(~matthewmo@096-059-082-099.res.spectrum.com) (Client Quit)
2023-11-28 04:19:49 +0100 <newsham> concretely here: https://play.haskell.org/saved/iCGAWVXU
2023-11-28 04:21:07 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:c5ae:90af:10b1:51fe) (Remote host closed the connection)
2023-11-28 04:21:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:c5ae:90af:10b1:51fe)
2023-11-28 04:21:43 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 268 seconds)
2023-11-28 04:21:52 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com) (Remote host closed the connection)
2023-11-28 04:23:43 +0100rosco(~rosco@175.136.157.149)
2023-11-28 04:24:49 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 04:25:07 +0100edr(~edr@user/edr) (Quit: Leaving)
2023-11-28 04:26:39 +0100madariaga(~madariaga@user/madariaga) (Quit: madariaga)
2023-11-28 04:26:54 +0100hgolden(~hgolden@2603-8000-9d00-3ed1-dd4f-298a-9c49-a0ed.res6.spectrum.com)
2023-11-28 04:29:45 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 04:30:39 +0100madariaga(~madariaga@user/madariaga) (Client Quit)
2023-11-28 04:32:04 +0100 <jackdk> https://en.wikipedia.org/wiki/Generalized_algebraic_data_type#Higher-order_abstract_syntax has a Haskell example. The `Lift` constructor tracks the type of the primitive that it wraps, and then the other constructors use the types of the arguments to influence the type of the result
2023-11-28 04:32:15 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 04:33:12 +0100 <EvanR> how do you plan the index the GADT by the value of the term, when the term may have unknowns in it
2023-11-28 04:33:24 +0100 <EvanR> e.g. the x within \x -> x
2023-11-28 04:33:45 +0100madariaga(~madariaga@user/madariaga) (Client Quit)
2023-11-28 04:33:50 +0100 <jackdk> it doesn't, it indexes it by the type of the term?
2023-11-28 04:33:58 +0100 <EvanR> newsham, was trying to do both
2023-11-28 04:34:49 +0100madariaga(~madariaga@user/madariaga)
2023-11-28 04:35:04 +0100 <EvanR> usually you settle for just tracking the type
2023-11-28 04:35:27 +0100 <jackdk> then you probably have to make your value-level type annotation into a singleton type
2023-11-28 04:36:27 +0100 <jackdk> and/or set up a corresponding singleton type - I never really got my head around the singletons library but despite jle's series starting at https://blog.jle.im/entry/introduction-to-singletons-1.html is excellent
2023-11-28 04:36:31 +0100 <newsham> not sure thats viable if this isnt viable.. because at first untyped LC would be parsed as untyped, then types would be computed.  so I'd still need a way to change types dynamically.
2023-11-28 04:36:55 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 04:37:22 +0100 <EvanR> you could apply "parse, don't validate" here and do the type checking during the parsing. If it can't type check, it can't parse
2023-11-28 04:38:01 +0100 <EvanR> correct by construction
2023-11-28 04:38:13 +0100 <newsham> actually started down that road first.. got bogged down.  but might return to that.
2023-11-28 04:38:36 +0100 <EvanR> you can always take a well typed term and extract an untyped lambda term
2023-11-28 04:38:58 +0100 <newsham> cool except its not what i want. heh.  can do thing i dont want, but not thing i want.
2023-11-28 04:39:06 +0100madariaga(~madariaga@user/madariaga) (Ping timeout: 245 seconds)
2023-11-28 04:39:41 +0100 <newsham> I guess the question in my mind still is "is there a way to dynamically convert a value to a type in haskell with extensions", and I'm guessing the answer is "no".
2023-11-28 04:39:54 +0100 <newsham> because type checking is something happening at compile time.
2023-11-28 04:40:26 +0100 <[Leary]> Parse text into an untyped representation, then parse the untyped representation into a typed one.
2023-11-28 04:40:36 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 04:41:03 +0100 <newsham> but parsing into a typed rep means I have to know the resulting type ahead of time, no?
2023-11-28 04:41:27 +0100 <newsham> ie: "parse typedParser "..." :: TExpr (Int -> Int)`
2023-11-28 04:43:34 +0100 <[Leary]> The result type can be hidden by an existential or passed to a polymorphic continuation that doesn't need to know it.
2023-11-28 04:43:57 +0100 <jackdk> Given `TExpr a` where `a` is a tyvar of some kind, you could parse to `Some TExpr` where `data Some where Some :: f a -> Some f`
2023-11-28 04:44:25 +0100 <jackdk> And if you had a singleton that you could pattern-match on, you could recover `a` at runtime
2023-11-28 04:44:38 +0100 <jackdk> (I'm speaking a little loosely)
2023-11-28 04:44:51 +0100 <iqubic> Is there anywhere I can go to learn about what language extensions GHC2020 enables by default?
2023-11-28 04:45:13 +0100 <newsham> time to leanr singletons to understand better
2023-11-28 04:45:47 +0100 <EvanR> iqubic, probably google for GHC2020
2023-11-28 04:46:23 +0100 <[Leary]> I'd skip the middle man and just ask the GHC User's Guide directly.
2023-11-28 04:46:29 +0100 <jackdk> iqubic: GHC User's Guide
2023-11-28 04:46:33 +0100 <jackdk> [Leary]: snap
2023-11-28 04:46:41 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 268 seconds)
2023-11-28 04:46:47 +0100 <jackdk> iqubic: https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/control.html#extension-GHC2021
2023-11-28 04:47:42 +0100 <iqubic> Why is lambdacase not default yet?
2023-11-28 04:48:22 +0100 <jackdk> Because it's not in a Haskell report
2023-11-28 04:48:25 +0100 <EvanR> google for GHC's user guide xD
2023-11-28 04:48:41 +0100 <EvanR> then search within the user guide using internal search
2023-11-28 04:48:45 +0100 <jackdk> Also https://discourse.haskell.org/t/ghc2024-community-input/8168 is soliciting input for the GHC2024 language set
2023-11-28 04:49:10 +0100 <EvanR> iqubic, skips the middleman and gets irc to produce URLs
2023-11-28 04:49:10 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2023-11-28 04:55:15 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-28 04:55:15 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-28 04:55:15 +0100finn_elijaFinnElija
2023-11-28 04:56:11 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04)
2023-11-28 04:56:28 +0100 <jackdk> newsham: https://play.haskell.org/saved/qEqZMAGk if you pattern-match on the `SType` in a `Some Expr`, the type checker will add constraints to `a` based on what type the variable must be (e.g., if you match a `STUnk`, it will know that `a ~ 'TUnk`
2023-11-28 04:57:58 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-11-28 04:58:08 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 05:01:04 +0100 <iqubic> Evan, I am not a smart lady.
2023-11-28 05:01:47 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net) (Ping timeout: 264 seconds)
2023-11-28 05:03:26 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net)
2023-11-28 05:05:48 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 268 seconds)
2023-11-28 05:10:40 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-11-28 05:10:46 +0100 <newsham> i think i get the idea. matching on some value level type witness lets you get from values to types.
2023-11-28 05:11:36 +0100 <newsham> still trying to process how I would use this, and in particular, how it will work with an infinite set of types (ie `Fun a b` where `a` or `b` could also be `Fun`)
2023-11-28 05:11:58 +0100 <newsham> i'll play around with the idea.  its neat.
2023-11-28 05:16:59 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 05:18:46 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-28 05:23:16 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 05:24:13 +0100derpyxdhs(~Thunderbi@user/derpyxdhs)
2023-11-28 05:34:58 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 05:36:23 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-11-28 05:36:26 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 05:40:00 +0100derpyxdhs(~Thunderbi@user/derpyxdhs) (Quit: derpyxdhs)
2023-11-28 05:40:37 +0100mikess(~sam@user/mikess) (Quit: leaving)
2023-11-28 05:40:58 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 05:52:19 +0100trev(~trev@user/trev)
2023-11-28 05:52:37 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 05:54:44 +0100aforemny_(~aforemny@i59F516E0.versanet.de)
2023-11-28 05:55:40 +0100aforemny(~aforemny@2001:9e8:6cc7:1300:96d5:106c:58e4:1727) (Ping timeout: 255 seconds)
2023-11-28 05:56:04 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-28 05:58:32 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 252 seconds)
2023-11-28 06:00:49 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-28 06:01:34 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-11-28 06:01:47 +0100Square2(~Square4@user/square)
2023-11-28 06:03:30 +0100Square(~Square@user/square) (Ping timeout: 260 seconds)
2023-11-28 06:10:16 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 06:16:03 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 06:20:18 +0100bilegeek(~bilegeek@2600:1008:b04f:8b1a:c952:a856:d7cb:e2d0)
2023-11-28 06:27:18 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-11-28 06:27:39 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 06:36:35 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 06:37:16 +0100 <hammond> http://repetae.net/computer/jhc/
2023-11-28 06:37:18 +0100 <hammond> yeah?
2023-11-28 06:37:21 +0100 <hammond> or no?
2023-11-28 06:46:43 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 276 seconds)
2023-11-28 06:47:12 +0100euleritian(~euleritia@dynamic-046-114-205-072.46.114.pool.telefonica.de)
2023-11-28 06:48:36 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 06:49:23 +0100rosco(~rosco@175.136.157.149) (Quit: Lost terminal)
2023-11-28 06:51:21 +0100euleritian(~euleritia@dynamic-046-114-205-072.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-28 06:51:38 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-28 06:52:35 +0100chomwitt(~chomwitt@2a02:587:7a24:bc00:1ac0:4dff:fedb:a3f1)
2023-11-28 06:54:25 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 260 seconds)
2023-11-28 06:56:44 +0100newsham(~newsham@2603-800c-2c01-6825-6daa-0948-9100-d431.res6.spectrum.com) (Quit: Client closed)
2023-11-28 07:03:43 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-11-28 07:06:15 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 07:11:55 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 268 seconds)
2023-11-28 07:12:02 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Max SendQ exceeded)
2023-11-28 07:12:29 +0100euleritian(~euleritia@dynamic-046-114-205-072.46.114.pool.telefonica.de)
2023-11-28 07:13:09 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 07:17:56 +0100tertek(~tertek@user/tertek) (Remote host closed the connection)
2023-11-28 07:18:17 +0100tertek(~tertek@user/tertek)
2023-11-28 07:19:34 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 07:30:15 +0100 <EvanR> hammond, hell yeah
2023-11-28 07:30:29 +0100 <EvanR> try jhc and tell me how it goes
2023-11-28 07:31:17 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 07:33:47 +0100 <hammond> lol
2023-11-28 07:37:22 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 07:38:18 +0100 <hammond> ssrly though i was looking at this. https://www.reddit.com/r/haskell/comments/bcdq65/initial_hacking_of_ghc_for_gcc_linktime/
2023-11-28 07:38:36 +0100 <hammond> maybe it is old though idk. it did make me wonder.
2023-11-28 07:39:15 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-11-28 07:48:35 +0100analoq(~yashi@user/dies) (Ping timeout: 264 seconds)
2023-11-28 07:48:58 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 07:50:05 +0100analoq(~yashi@user/dies)
2023-11-28 07:50:20 +0100gmg(~user@user/gehmehgeh)
2023-11-28 07:52:58 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-11-28 07:53:57 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-28 07:54:49 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 07:56:51 +0100smalltalkman(uid545680@id-545680.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 07:58:28 +0100thegeekinside(~thegeekin@189.180.53.210) (Ping timeout: 268 seconds)
2023-11-28 08:01:59 +0100acidjnk(~acidjnk@p200300d6e72b9317058012a22410a419.dip0.t-ipconnect.de)
2023-11-28 08:05:25 +0100smalltalkman(uid545680@id-545680.hampstead.irccloud.com)
2023-11-28 08:06:54 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 08:08:34 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 260 seconds)
2023-11-28 08:12:38 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 252 seconds)
2023-11-28 08:16:54 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-28 08:19:37 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-11-28 08:23:44 +0100lhpitn(~tn@mail.lebenshilfe-pi.de) (Read error: Connection reset by peer)
2023-11-28 08:24:17 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 08:32:01 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 276 seconds)
2023-11-28 08:33:31 +0100rosco(~rosco@175.136.157.149)
2023-11-28 08:33:32 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 252 seconds)
2023-11-28 08:35:56 +0100kenran(~user@user/kenran)
2023-11-28 08:39:50 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2023-11-28 08:42:31 +0100qqq(~qqq@92.43.167.61) (Ping timeout: 260 seconds)
2023-11-28 08:43:21 +0100euleritian(~euleritia@dynamic-046-114-205-072.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-28 08:43:39 +0100euleritian(~euleritia@77.22.252.56)
2023-11-28 08:43:52 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 08:47:14 +0100qqq(~qqq@92.43.167.61)
2023-11-28 08:47:32 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-11-28 08:48:25 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 268 seconds)
2023-11-28 08:49:41 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 260 seconds)
2023-11-28 08:50:50 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 08:53:17 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-11-28 08:53:48 +0100kenran(~user@user/kenran)
2023-11-28 08:55:31 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-28 08:56:26 +0100kenran`(~user@user/kenran)
2023-11-28 08:56:34 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 255 seconds)
2023-11-28 08:57:24 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-11-28 08:58:23 +0100kenran(~user@user/kenran) (Ping timeout: 252 seconds)
2023-11-28 09:01:50 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 09:07:38 +0100arahael_(~arahael@1.145.96.183)
2023-11-28 09:10:03 +0100rosco(~rosco@175.136.157.149) (Ping timeout: 260 seconds)
2023-11-28 09:10:09 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 256 seconds)
2023-11-28 09:11:12 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 256 seconds)
2023-11-28 09:12:00 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 09:16:10 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-28 09:16:23 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2023-11-28 09:16:36 +0100rosco(~rosco@175.136.158.171)
2023-11-28 09:18:20 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 268 seconds)
2023-11-28 09:19:01 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 09:21:06 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-11-28 09:21:48 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 09:27:53 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 268 seconds)
2023-11-28 09:30:24 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-28 09:31:04 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 09:41:16 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 246 seconds)
2023-11-28 09:42:55 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-28 09:51:00 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 09:51:06 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 09:54:16 +0100JeremyB99(~JeremyB99@208.64.173.6) (Ping timeout: 256 seconds)
2023-11-28 09:54:16 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-28 09:56:36 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it) (Ping timeout: 245 seconds)
2023-11-28 09:58:32 +0100pandry(~Pandry@93-41-34-64.ip79.fastwebnet.it)
2023-11-28 10:01:09 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2023-11-28 10:06:02 +0100masterbuilder(~quassel@user/masterbuilder) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2023-11-28 10:06:43 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-11-28 10:09:50 +0100dhil(~dhil@2001:8e0:2014:3100:8523:26aa:23b6:e435)
2023-11-28 10:10:16 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-28 10:11:04 +0100CiaoSen(~Jura@2a05:5800:291:5500:2a3a:4dff:fe84:dbd5)
2023-11-28 10:12:39 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 10:13:58 +0100JeremyB99(~JeremyB99@208.64.173.6)
2023-11-28 10:16:08 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 10:17:28 +0100danza(~francesco@151.35.232.56)
2023-11-28 10:18:54 +0100cfricke(~cfricke@user/cfricke)
2023-11-28 10:19:20 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-11-28 10:21:45 +0100bilegeek(~bilegeek@2600:1008:b04f:8b1a:c952:a856:d7cb:e2d0) (Quit: Leaving)
2023-11-28 10:21:49 +0100misterfish(~misterfis@87.215.131.102)
2023-11-28 10:22:11 +0100akegalj(~akegalj@89-172-89-238.adsl.net.t-com.hr)
2023-11-28 10:28:39 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-11-28 10:29:51 +0100danza(~francesco@151.35.232.56) (Ping timeout: 260 seconds)
2023-11-28 10:36:49 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-28 10:37:11 +0100not_reserved(~not_reser@45.144.113.233) (Quit: Client closed)
2023-11-28 10:37:28 +0100chele(~chele@user/chele)
2023-11-28 10:38:38 +0100danse-nr3(~danse@151.19.224.252)
2023-11-28 10:45:31 +0100zetef(~quassel@2a02:2f00:5201:4b00:19c:1be6:f517:649f)
2023-11-28 10:47:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:c5ae:90af:10b1:51fe) (Remote host closed the connection)
2023-11-28 10:50:39 +0100zetef(~quassel@2a02:2f00:5201:4b00:19c:1be6:f517:649f) (Remote host closed the connection)
2023-11-28 10:51:25 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a)
2023-11-28 10:52:17 +0100potato44(uid421314@id-421314.lymington.irccloud.com)
2023-11-28 10:55:11 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a) (Client Quit)
2023-11-28 10:56:41 +0100arahael_(~arahael@1.145.96.183) (Read error: Connection reset by peer)
2023-11-28 10:57:08 +0100Lycurgus(~georg@li1192-118.members.linode.com)
2023-11-28 10:57:08 +0100Lycurgus(~georg@li1192-118.members.linode.com) (Changing host)
2023-11-28 10:57:08 +0100Lycurgus(~georg@user/Lycurgus)
2023-11-28 10:57:21 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a)
2023-11-28 10:57:29 +0100Lycurgus(~georg@user/Lycurgus) (Client Quit)
2023-11-28 10:58:19 +0100 <bwe> I wonder the site's name that had multiple times framework in its uri. it basically explained starting from vanilla code how framework on top of framework rendered themselves useless. do you know it by any chance?
2023-11-28 10:59:30 +0100 <danse-nr3> no but it sounds funny
2023-11-28 11:01:39 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 11:01:51 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:05:50 +0100 <danse-nr3> not a problem in haskell though? Which frameworks would you put on top of each other? (maybe conduit on top of transformers)
2023-11-28 11:06:45 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 256 seconds)
2023-11-28 11:07:11 +0100 <tomsmeding> you can probably pile data types a-la-carte with some additional type-indexing on top of servant
2023-11-28 11:07:21 +0100 <tomsmeding> and no one will bat an eye
2023-11-28 11:07:30 +0100 <tomsmeding> our frameworks look different :p
2023-11-28 11:07:46 +0100 <bwe> I've got it: https://factoryfactoryfactory.net
2023-11-28 11:10:19 +0100 <danse-nr3> hmm but factory and framework are very different concepts...
2023-11-28 11:10:42 +0100Jackneill(~Jackneill@20014C4E1E120500906E1D747CFD14BF.dsl.pool.telekom.hu)
2023-11-28 11:11:05 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-11-28 11:11:51 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds)
2023-11-28 11:12:01 +0100arahael__(~arahael@1.145.68.95)
2023-11-28 11:12:30 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 11:13:05 +0100 <_d0t> ohai! Is there a way to find where an instance in scope was declared? I have a piece of code with overlapping instances and one of them seems imported transitively from god knows where.
2023-11-28 11:14:03 +0100Lord_of_Life_Lord_of_Life
2023-11-28 11:15:00 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:16:42 +0100luna(~luna@fedora/bittin)
2023-11-28 11:21:14 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 11:22:12 +0100luna(~luna@fedora/bittin) ()
2023-11-28 11:23:36 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 11:23:48 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:25:48 +0100 <danse-nr3> not sure, i guess i would rely on the error from the compiler to track that up, but maybe someone knows of a way using the language server
2023-11-28 11:26:22 +0100rosco(~rosco@175.136.158.171) (Client Quit)
2023-11-28 11:27:00 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:27:31 +0100rosco(~rosco@175.136.158.171) (Client Quit)
2023-11-28 11:28:39 +0100arahael__(~arahael@1.145.68.95) (Read error: Connection reset by peer)
2023-11-28 11:32:58 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 11:35:32 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:40:21 +0100rosco(~rosco@175.136.158.171) (Client Quit)
2023-11-28 11:40:34 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:42:02 +0100rosco(~rosco@175.136.158.171) (Client Quit)
2023-11-28 11:46:20 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:47:01 +0100gensyst(~gensyst@user/gensyst)
2023-11-28 11:50:16 +0100 <gensyst> About the hxt (XML parsing) library: How can I wrap existing XmlTree into a brand-new document?
2023-11-28 11:51:56 +0100 <gensyst> Somehow, transform XmlTree into this behemoth IOSLA (XIOState ()) XmlTree (NTree XNode)
2023-11-28 11:53:27 +0100 <gensyst> My goal is to first grab all XmlTrees of certain name, then later in the codebase, work on those individually.
2023-11-28 11:53:30 +0100 <gensyst> Modularity.
2023-11-28 11:53:36 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 11:53:53 +0100 <gensyst> I hope this is possible with hxt. I hope I don't have to do everything all at once in the same runX
2023-11-28 11:54:32 +0100rosco(~rosco@175.136.158.171)
2023-11-28 11:55:16 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 268 seconds)
2023-11-28 11:58:35 +0100 <danse-nr3> can't check that lib right now, but if something is missing from its doc you can always open an issue about it
2023-11-28 11:59:39 +0100 <gensyst> The thing is, with readString or readDocument I can turn a string or FilePath into that behemoth I mentioned.
2023-11-28 11:59:55 +0100 <gensyst> I just don't see a way to turn XmlTree into that behemoth
2023-11-28 12:00:11 +0100 <gensyst> Maybe this is by design
2023-11-28 12:00:18 +0100 <gensyst> (controlled side effects etc)
2023-11-28 12:00:26 +0100 <gensyst> ?
2023-11-28 12:00:49 +0100qqq(~qqq@92.43.167.61) (Ping timeout: 268 seconds)
2023-11-28 12:02:17 +0100qqq(~qqq@92.43.167.73)
2023-11-28 12:02:40 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz) (Ping timeout: 268 seconds)
2023-11-28 12:03:50 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2023-11-28 12:04:33 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 12:05:38 +0100xff0x(~xff0x@ai096045.d.east.v6connect.net)
2023-11-28 12:05:40 +0100oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl)
2023-11-28 12:06:01 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a) (Ping timeout: 255 seconds)
2023-11-28 12:06:59 +0100AlienCipher(~AlienCiph@113.164.176.43)
2023-11-28 12:07:22 +0100AlienCipher(~AlienCiph@113.164.176.43) (Client Quit)
2023-11-28 12:09:15 +0100remedan(~remedan@ip-94-112-0-18.bb.vodafone.cz)
2023-11-28 12:10:31 +0100CiaoSen(~Jura@2a05:5800:291:5500:2a3a:4dff:fe84:dbd5) (Ping timeout: 255 seconds)
2023-11-28 12:18:06 +0100akegalj(~akegalj@89-172-89-238.adsl.net.t-com.hr) (Quit: leaving)
2023-11-28 12:22:51 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2023-11-28 12:23:15 +0100biberu(~biberu@user/biberu)
2023-11-28 12:25:39 +0100qqq(~qqq@92.43.167.73) (Ping timeout: 256 seconds)
2023-11-28 12:26:39 +0100qqq(~qqq@92.43.167.73)
2023-11-28 12:27:15 +0100not_reserved(~not_reser@45.144.113.236)
2023-11-28 12:28:37 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Ping timeout: 276 seconds)
2023-11-28 12:29:31 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 12:29:48 +0100foul_owl(~kerry@174-21-66-189.tukw.qwest.net) (Ping timeout: 268 seconds)
2023-11-28 12:39:29 +0100aplainzetakind(~aplainzet@146.70.171.174)
2023-11-28 12:42:41 +0100foul_owl(~kerry@185.219.141.160)
2023-11-28 12:46:44 +0100__monty__(~toonn@user/toonn)
2023-11-28 12:51:56 +0100Xyloes(~wyx@2400:dd01:103a:1012:5923:33ce:7857:fc04) (Quit: Konversation terminated!)
2023-11-28 12:56:07 +0100qqq(~qqq@92.43.167.73) (Ping timeout: 256 seconds)
2023-11-28 12:58:01 +0100qqq(~qqq@92.43.167.61)
2023-11-28 13:02:55 +0100JeremyB99(~JeremyB99@208.64.173.6) (Ping timeout: 260 seconds)
2023-11-28 13:03:21 +0100JeremyB99(~JeremyB99@208.64.173.6)
2023-11-28 13:04:03 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2023-11-28 13:04:26 +0100 <srk> glguy: was hacking on Haskell and IRC as well past two days https://github.com/sorki/ircbridge
2023-11-28 13:04:35 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-28 13:04:42 +0100gensystt(~gensyst@user/gensyst)
2023-11-28 13:07:25 +0100JeremyB99(~JeremyB99@208.64.173.6) (Ping timeout: 245 seconds)
2023-11-28 13:07:35 +0100gensyst(~gensyst@user/gensyst) (Ping timeout: 260 seconds)
2023-11-28 13:08:01 +0100 <danse-nr3> quite productive for a couple of days ;)
2023-11-28 13:10:09 +0100applecat(~applecat@116.204.144.46)
2023-11-28 13:10:53 +0100 <srk> danse-nr3: I've built it 3 years ago, haven't touched it since then (but it was working quite well since then), now it's pretty much done. there are features I can add but there's not much to remove so it's perfect
2023-11-28 13:13:12 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-11-28 13:13:17 +0100Square3(~Square4@user/square)
2023-11-28 13:13:17 +0100Square3(~Square4@user/square) (Remote host closed the connection)
2023-11-28 13:13:44 +0100danse-nr3(~danse@151.19.224.252) (Ping timeout: 256 seconds)
2023-11-28 13:14:08 +0100Square2(~Square4@user/square) (Ping timeout: 252 seconds)
2023-11-28 13:14:43 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 13:16:37 +0100migas9(~migas@static.140.65.63.178.clients.your-server.de) (Quit: The Lounge - https://thelounge.github.io)
2023-11-28 13:17:29 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-28 13:18:17 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 13:18:40 +0100migas9(~migas@static.140.65.63.178.clients.your-server.de)
2023-11-28 13:19:44 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Quit: WeeChat 4.1.1)
2023-11-28 13:20:46 +0100aplainzetakind(~aplainzet@146.70.171.174) (Quit: Client closed)
2023-11-28 13:22:53 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-28 13:27:31 +0100 <Unicorn_Princess> two monks were walking across a bridge
2023-11-28 13:27:59 +0100 <Unicorn_Princess> and the junior monk said to his teacher "what is the monad nature?"
2023-11-28 13:28:10 +0100 <Unicorn_Princess> and the other monk picked him up and threw him in the water
2023-11-28 13:29:07 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 13:29:07 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 256 seconds)
2023-11-28 13:34:57 +0100 <ncf> lol
2023-11-28 13:35:20 +0100 <ncf> you sure he didn't say "μ!" ?
2023-11-28 13:38:08 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 13:38:10 +0100danse-nr3(~danse@151.19.224.252)
2023-11-28 13:38:23 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 264 seconds)
2023-11-28 13:38:48 +0100 <ski> μ : M ∘ M ⟶ M
2023-11-28 13:39:55 +0100 <gensystt> About the hxt (XML parsing) library: How can I wrap existing XmlTree into a brand-new document?
2023-11-28 13:39:56 +0100 <gensystt> Somehow, transform XmlTree into this behemoth IOSLA (XIOState ()) XmlTree (NTree XNode)
2023-11-28 13:39:56 +0100 <gensystt> My goal is modularity: first grab all XmlTrees of certain name, then later work on those individually.
2023-11-28 13:39:56 +0100 <gensystt> I hope this is possible with hxt. I hope I don't have to do everything all at once in the same runX. The thing is, with readString or readDocument I can turn a string or FilePath into that behemoth I mentioned.
2023-11-28 13:39:56 +0100 <gensystt> I just don't see a way to turn XmlTree into that behemoth.
2023-11-28 13:40:40 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-11-28 13:41:57 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 13:42:07 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 13:43:07 +0100 <danse-nr3> i am pretty sure most people have read this already the first time, although i understand that the channel looks more active now
2023-11-28 13:43:07 +0100rosco(~rosco@175.136.158.171)
2023-11-28 13:47:12 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 13:49:05 +0100CiaoSen(~Jura@2a05:5800:291:5500:2a3a:4dff:fe84:dbd5)
2023-11-28 13:51:30 +0100tremon(~tremon@83.80.159.219)
2023-11-28 13:52:34 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 13:59:04 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 13:59:05 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 14:00:30 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-28 14:01:41 +0100 <gensystt> I figured it out
2023-11-28 14:02:07 +0100 <gensystt> I just have to wrap the XmlTree into a constA (the constant arrow, I suppose)
2023-11-28 14:02:18 +0100 <gensystt> that the arrow way of doing "pure" or "return" it seems
2023-11-28 14:03:57 +0100 <danse-nr3> oh i see then the problem was the arrow interface
2023-11-28 14:06:28 +0100applecat(~applecat@116.204.144.46) (Ping timeout: 250 seconds)
2023-11-28 14:09:19 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 14:09:24 +0100poscat(~poscat@user/poscat) (Quit: Bye)
2023-11-28 14:12:13 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 14:14:10 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-11-28 14:14:52 +0100poscat(~poscat@user/poscat)
2023-11-28 14:15:22 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 14:17:37 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 14:20:45 +0100_d0t(~{-d0t-}@user/-d0t-/x-7915216) (Ping timeout: 245 seconds)
2023-11-28 14:20:49 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 14:25:33 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 14:27:14 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 14:28:01 +0100_d0t(~{-d0t-}@user/-d0t-/x-7915216)
2023-11-28 14:33:23 +0100mikess(~sam@user/mikess)
2023-11-28 14:35:43 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 14:35:48 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 14:41:10 +0100danse-nr3(~danse@151.19.224.252) (Ping timeout: 255 seconds)
2023-11-28 14:42:27 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 14:42:30 +0100danse-nr3(~danse@151.37.249.255)
2023-11-28 14:45:38 +0100danse-nr3(~danse@151.37.249.255) (Remote host closed the connection)
2023-11-28 14:45:48 +0100edr(~edr@user/edr)
2023-11-28 14:46:23 +0100danse-nr3(~danse@151.37.249.255)
2023-11-28 14:49:24 +0100kenran`(~user@user/kenran) (Remote host closed the connection)
2023-11-28 14:57:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 14:58:11 +0100 <EvanR> the intersection of XML and Arrow sounds unlikely as hell, I like it
2023-11-28 14:59:04 +0100 <danse-nr3> haha how so? Arrow is a very generic abstraction
2023-11-28 15:00:54 +0100 <EvanR> I've also heard that it is unnecessarily specific
2023-11-28 15:01:40 +0100 <danse-nr3> to be fair arrows confuse me a bit. I have heard of them as a great abstraction, but when i try to study the basics of it they look just like tuples
2023-11-28 15:02:15 +0100 <danse-nr3> pairs, to be precise
2023-11-28 15:02:35 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-11-28 15:03:09 +0100 <EvanR> the example I default to is the string diagram-ish diagrams for e.g. yampa programs
2023-11-28 15:03:24 +0100thegeekinside(~thegeekin@189.180.53.210)
2023-11-28 15:03:25 +0100 <EvanR> https://wiki.haskell.org/Yampa
2023-11-28 15:04:08 +0100mikess(~sam@user/mikess) (Quit: leaving)
2023-11-28 15:04:44 +0100 <danse-nr3> yeah i see how primitives on top of pairs can be helpful for the case of those diagrams. They are still pairs though
2023-11-28 15:05:19 +0100mikess(~sam@user/mikess)
2023-11-28 15:06:36 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:07:02 +0100 <EvanR> :thonk:
2023-11-28 15:07:24 +0100 <EvanR> how is arr f a pair
2023-11-28 15:08:12 +0100thegeekinside(~thegeekin@189.180.53.210) (Ping timeout: 256 seconds)
2023-11-28 15:08:42 +0100 <Unicorn_Princess> the "tutorial introduction" linked from https://wiki.haskell.org/Arrow is 56 pages :|
2023-11-28 15:09:00 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:09:43 +0100 <EvanR> :t fst
2023-11-28 15:09:44 +0100 <danse-nr3> `arr` is not a pair, but all the rest you can do with it seems to be use it on a pair
2023-11-28 15:09:44 +0100 <lambdabot> (a, b) -> a
2023-11-28 15:09:48 +0100 <EvanR> :t first
2023-11-28 15:09:49 +0100 <lambdabot> Arrow a => a b c -> a (b, d) (c, d)
2023-11-28 15:09:52 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:10:47 +0100 <EvanR> pairs have both parameters in positive position, while the humble function arrow has one positive one negative
2023-11-28 15:11:26 +0100 <danse-nr3> :t arr
2023-11-28 15:11:27 +0100 <lambdabot> Arrow a => (b -> c) -> a b c
2023-11-28 15:13:39 +0100 <ski> the main problem with arrows is `arr'
2023-11-28 15:14:03 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:14:22 +0100 <Unicorn_Princess> pfft, landlubbers
2023-11-28 15:14:34 +0100 <ski> @arr
2023-11-28 15:14:34 +0100 <lambdabot> Aye Aye Cap'n
2023-11-28 15:17:42 +0100mikess(~sam@user/mikess) (Quit: leaving)
2023-11-28 15:17:58 +0100danse-nr3(~danse@151.37.249.255) (Read error: Connection reset by peer)
2023-11-28 15:18:32 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:18:36 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:18:56 +0100thegeekinside(~thegeekin@189.180.53.210)
2023-11-28 15:22:02 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:23:34 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-11-28 15:23:57 +0100komikat(~akshitkr@218.185.248.66)
2023-11-28 15:25:08 +0100 <komikat> what would you guys recommend for a haskell setup with emacs
2023-11-28 15:25:09 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:25:56 +0100 <komikat> been using lsp but not sure if something like merlin (ocaml) exists for haskell
2023-11-28 15:26:35 +0100 <exarkun> komikat: haskell-mode, lsp-mode, lsp-ui, lsp-haskell, a nix flake to install haskell-language-server, and envrc-mode to tie emacs to the flake env
2023-11-28 15:26:58 +0100 <exarkun> and a lot of patience
2023-11-28 15:27:09 +0100 <komikat> of course
2023-11-28 15:27:09 +0100 <EvanR> there's a joke what's a pirates favorite programming language. R? No, C be me true love. Coincidentally, early notation for A ⟶ B in early logic looks like A Ↄ B
2023-11-28 15:27:14 +0100 <exarkun> lsp-treemacs too
2023-11-28 15:28:14 +0100danse-nr3(~danse@151.37.249.255)
2023-11-28 15:28:21 +0100 <komikat> thanks!
2023-11-28 15:28:31 +0100 <ski> or ⌜A ⊃ B⌝
2023-11-28 15:29:57 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:30:10 +0100 <EvanR> I guess it was easier to turn their C slug upside down
2023-11-28 15:31:09 +0100 <Unicorn_Princess> komikat, and just restart emacs if the haskell lsp/server break, which they will, frequently
2023-11-28 15:31:25 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:31:30 +0100 <komikat> is there a way to avoid the lsp altogether?
2023-11-28 15:31:38 +0100 <komikat> and still get decent editing support
2023-11-28 15:32:04 +0100 <Unicorn_Princess> i don't know it, but tree-sitter probably
2023-11-28 15:32:08 +0100 <komikat> dont really want much, a lint and some autocomplete
2023-11-28 15:32:36 +0100 <exarkun> you get dumb autocomplete more or less for free
2023-11-28 15:32:49 +0100 <exarkun> and you can just run hlint with flycheck or something if you want
2023-11-28 15:33:06 +0100 <exarkun> it falls a long way short of what lsp can do
2023-11-28 15:33:20 +0100 <EvanR> control N in vim, autocompletes xD
2023-11-28 15:34:13 +0100 <danse-nr3> that is why they were referring to as "dumb autocomplete"
2023-11-28 15:34:30 +0100skinever bothered trying out the LSP support, so far
2023-11-28 15:34:54 +0100 <EvanR> if it's dumb and works then it's not dumb :tm:
2023-11-28 15:35:18 +0100 <danse-nr3> the `lsp` packages are awful but there is a stabler alternative with less feature, although its name now escapes my memory...
2023-11-28 15:35:33 +0100 <ski> `M-/' does reasonable autocomplete, for me, most of the time
2023-11-28 15:35:49 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 276 seconds)
2023-11-28 15:36:23 +0100 <exarkun> danse-nr3: An emacs alternative for talking to a language server?
2023-11-28 15:36:30 +0100 <ski> there's apparently something called eglot, which is supposedly more integrated and playing along better with Emacs
2023-11-28 15:36:33 +0100 <danse-nr3> yeah
2023-11-28 15:37:11 +0100 <exarkun> Huh interesting
2023-11-28 15:37:17 +0100alp_(~alp@2001:861:e3d6:8f80:6a02:be3b:357f:fb3)
2023-11-28 15:37:35 +0100 <danse-nr3> yeah maybe that was eglot
2023-11-28 15:37:47 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:37:58 +0100 <srk> I was wondering today if I should try to revive my emacs haskell lsp setup. still not sure it's worth it
2023-11-28 15:38:52 +0100 <srk> *if
2023-11-28 15:39:19 +0100komikat(~akshitkr@218.185.248.66) (Ping timeout: 256 seconds)
2023-11-28 15:39:37 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 15:39:42 +0100 <srk> is there a way to make emacs as fast/responsive like vim? :D
2023-11-28 15:40:03 +0100 <exarkun> running lsp-haskell definitely does not help with responsiveness.
2023-11-28 15:40:13 +0100 <srk> exactly
2023-11-28 15:40:45 +0100 <srk> I need my editor as responsive as FPS games :D
2023-11-28 15:40:50 +0100 <ski> maybe you could ask #emacs
2023-11-28 15:40:56 +0100 <exarkun> it's a trade-off! you can have 5 keystrokes per second or you can have 1 keystroke per second that is 5 times more meaningful.
2023-11-28 15:41:21 +0100 <srk> started with spacemacs, way too bloated. switched to doom-emacs, much better. still using it daily due to org mode, sometimes with dhall
2023-11-28 15:41:37 +0100 <srk> considering rolling my own config as I sort-of know what I want now
2023-11-28 15:41:39 +0100 <Unicorn_Princess> yeah spacemacs was too laggy for me too
2023-11-28 15:41:43 +0100 <srk> but my daily driver is still vim + ghcid
2023-11-28 15:42:02 +0100 <Unicorn_Princess> plus getting help was harder, since you've got all the complexity of spacemacs to deal with on top of emacs
2023-11-28 15:42:11 +0100 <srk> this
2023-11-28 15:42:13 +0100 <Unicorn_Princess> which is already a tower of babel unto itself
2023-11-28 15:42:35 +0100skinever tried any "kit"
2023-11-28 15:43:07 +0100 <srk> easier for emacs noobs like me who also need evil
2023-11-28 15:43:43 +0100 <srk> doom bindings are not bad at all, I can switch between vim and doom pretty quickly
2023-11-28 15:43:53 +0100 <ski> #emacs is usually pretty approachable, though
2023-11-28 15:44:13 +0100 <srk> ty, will lurk :)
2023-11-28 15:44:43 +0100 <ski> (not implying you should take the conversation elsewhere. it's fine to talk about it here, as well)
2023-11-28 15:45:44 +0100 <srk> cool. I've already dumped all my emacs thoughts anyway I think hehe
2023-11-28 15:46:13 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 276 seconds)
2023-11-28 15:46:31 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 255 seconds)
2023-11-28 15:47:18 +0100 <Unicorn_Princess> the spacemacs way of bringing up a hierarchical key menu on pressing space is really good tho, and i pretty much copied it for my own emacs setup
2023-11-28 15:47:19 +0100 <srk> recently I've made multi-package ghcid (loads every single component of multi package repo) but I don't know what to do next with it. is ndmitchell approachable too? :D
2023-11-28 15:47:41 +0100 <Unicorn_Princess> cuz learning a special set of keybindings for each package is insane
2023-11-28 15:47:43 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 15:48:21 +0100 <srk> Unicorn_Princess: yep, I've liked that a lot
2023-11-28 15:49:04 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-28 15:49:49 +0100rosco(~rosco@175.136.158.171) (Quit: Lost terminal)
2023-11-28 15:51:22 +0100 <ski> hm, haven't seen ndm around in a long time, in here
2023-11-28 15:52:32 +0100 <ski> (if preflex was still around, i'd ask them for how long ago)
2023-11-28 15:55:54 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-11-28 15:56:51 +0100 <danse-nr3> was preflex a bot or just a person with a long memory?
2023-11-28 15:57:17 +0100 <EvanR> what happened to preflex
2023-11-28 15:58:59 +0100komikat(~akshitkr@218.185.248.66)
2023-11-28 15:59:00 +0100 <srk> ski: cool, didn't know he used to hang around. will shoot him an email
2023-11-28 16:00:01 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 255 seconds)
2023-11-28 16:00:14 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de)
2023-11-28 16:00:39 +0100kenran(~user@user/kenran)
2023-11-28 16:02:15 +0100 <EvanR> in the video linked on the yampa wiki page "causal commutative arrows and their optimization" his slide says arrow is a generalization of monad...
2023-11-28 16:03:06 +0100 <EvanR> assuming ArrowApply, the generalization is the other way around right
2023-11-28 16:03:18 +0100 <danse-nr3> apparently functions on pairs are a generalization of monads then
2023-11-28 16:03:56 +0100 <EvanR> still not seeing this pairs thing
2023-11-28 16:04:06 +0100gensystt(~gensyst@user/gensyst) (Quit: Leaving)
2023-11-28 16:04:29 +0100 <danse-nr3> i guess because one element is the monadic result, the other is the monadic side effect, but one can swap their roles so it is a generalization
2023-11-28 16:04:58 +0100 <ski> danse-nr3 : a bot
2023-11-28 16:05:06 +0100 <ski> iirc, ran by mmorrow
2023-11-28 16:05:30 +0100 <ski> (who's also disappeared)
2023-11-28 16:06:08 +0100 <ski> "functions on pairs" ?
2023-11-28 16:07:54 +0100 <danse-nr3> that is what arrows look like to me
2023-11-28 16:08:01 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 16:08:16 +0100Inst(~Inst@120.244.192.187)
2023-11-28 16:08:27 +0100 <ski> (and TheHunter,andersca,augustss,SyntaxNinja,quicksilver,hpaste,esap,Pseudonym,..)
2023-11-28 16:08:30 +0100 <Inst> it's understandable to try to talk someone out of joining the army, right?
2023-11-28 16:08:31 +0100 <ski> what do you mean ?
2023-11-28 16:08:36 +0100 <Inst> actually, #haskell-offtopic
2023-11-28 16:09:10 +0100 <ski> where does the pairs come into the picture ?
2023-11-28 16:09:16 +0100 <ski> talking about `first' ?
2023-11-28 16:09:31 +0100 <Inst> wait, can i ask you a personal question, ski?
2023-11-28 16:09:33 +0100 <Inst> regarding your ip?
2023-11-28 16:09:41 +0100 <danse-nr3> yes but also &&&, just the basic interface seems to be about that
2023-11-28 16:09:58 +0100 <Inst> hi danse-nr3, sorry i've been gone for a long time
2023-11-28 16:10:10 +0100 <Inst> last 2, and likely 3 weeks, will be eaten up by a personal issue
2023-11-28 16:10:10 +0100 <danse-nr3> hi Inst, no worries
2023-11-28 16:11:27 +0100 <Inst> ski? :(
2023-11-28 16:11:50 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 16:12:40 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-28 16:13:34 +0100 <ski> danse-nr3 : yea, those parts are about categorical products (or rather, something a bit weaker than those)
2023-11-28 16:14:05 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 16:15:18 +0100mrmr15533(~mrmr@user/mrmr) (Ping timeout: 260 seconds)
2023-11-28 16:18:34 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 260 seconds)
2023-11-28 16:22:29 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 16:24:19 +0100 <danse-nr3> komikat, i forgot to mention `hasktags` with M-.
2023-11-28 16:24:29 +0100 <danse-nr3> very stable and quick way to jump to definitions
2023-11-28 16:25:06 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 16:25:22 +0100CiaoSen(~Jura@2a05:5800:291:5500:2a3a:4dff:fe84:dbd5) (Ping timeout: 268 seconds)
2023-11-28 16:27:55 +0100mrmr15533(~mrmr@user/mrmr)
2023-11-28 16:28:17 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 16:28:45 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 16:33:02 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 16:33:58 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 16:35:53 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 16:36:16 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 276 seconds)
2023-11-28 16:38:57 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 16:46:39 +0100alp_(~alp@2001:861:e3d6:8f80:6a02:be3b:357f:fb3) (Ping timeout: 268 seconds)
2023-11-28 16:47:40 +0100stackdroid18(14094@de1.hashbang.sh)
2023-11-28 16:49:28 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Remote host closed the connection)
2023-11-28 16:50:05 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-11-28 16:50:27 +0100 <bwe> which monad transformer video can you recommend?
2023-11-28 16:51:49 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 16:51:58 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-28 16:53:05 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 16:55:16 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 16:55:43 +0100qqq(~qqq@92.43.167.61) (Quit: leaving)
2023-11-28 16:56:19 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-28 17:00:02 +0100seeg123456(~seeg12345@64.176.64.83) (Remote host closed the connection)
2023-11-28 17:01:40 +0100 <danse-nr3> i recommend studying by reading, although it is so old-millenium
2023-11-28 17:01:45 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 17:02:36 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 17:02:47 +0100 <hc> What's modern today? writing?
2023-11-28 17:02:50 +0100 <hc> ;p
2023-11-28 17:03:06 +0100 <Inst> Youtube.
2023-11-28 17:03:48 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 17:05:29 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 17:07:22 +0100 <c_wraith> Honestly, monad transformers are a topic most easily learned by writing or modifying code that uses them. And in fact, they're easier to "understand" than monads. I was successfully maintaining code using monad transformers well before I was comfortable with monads.
2023-11-28 17:08:43 +0100 <kaol> It's all about flattening pyramids. Pave the earth.
2023-11-28 17:08:45 +0100stackdroid18(14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!)
2023-11-28 17:09:49 +0100alp_(~alp@2001:861:e3d6:8f80:d1dc:7d30:db10:a74e)
2023-11-28 17:09:57 +0100 <danse-nr3> that is very counterintuitive c_wraith
2023-11-28 17:10:31 +0100 <c_wraith> :t lift
2023-11-28 17:10:33 +0100 <lambdabot> (MonadTrans t, Monad m) => m a -> t m a
2023-11-28 17:10:50 +0100 <c_wraith> :t (>>=)
2023-11-28 17:10:51 +0100 <lambdabot> Monad m => m a -> (a -> m b) -> m b
2023-11-28 17:11:00 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds)
2023-11-28 17:11:05 +0100 <c_wraith> One of those is easier than the other
2023-11-28 17:11:09 +0100 <geekosaur> the whole point of monad transformers is they're treated as black boxes
2023-11-28 17:11:20 +0100 <danse-nr3> i have read that there are two main approaches, mtl and transformers if i recall correctly. Which one is `lift` from?
2023-11-28 17:11:32 +0100 <c_wraith> that's incorrect
2023-11-28 17:11:43 +0100 <c_wraith> lift is from both
2023-11-28 17:11:54 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-28 17:12:03 +0100 <c_wraith> and it's the same definition, because transformers is a dependency of mtl
2023-11-28 17:12:11 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-28 17:12:36 +0100 <danse-nr3> probably i recall wrong then. See, reading does not work... had to watch a video instead!
2023-11-28 17:13:01 +0100 <geekosaur> there's a lot of misinformation out there whichever route you choose
2023-11-28 17:13:29 +0100Alleria(~JohnGalt@user/alleria) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-11-28 17:13:42 +0100sb23(~sb23@66.159.217.159)
2023-11-28 17:14:58 +0100 <c_wraith> as a generic concept, monad transformers are just "use lift when it makes the types right". That's something that's pretty easy to grasp.
2023-11-28 17:15:43 +0100 <c_wraith> All the tricky stuff (I'm looking at you, ContT) is not part of the generic concept
2023-11-28 17:16:17 +0100 <yushyin> danse-nr3: mtl and transformers library have a long (intertwined) history, depending on what sources, you will read some pretty outdated stuff sometimes
2023-11-28 17:16:51 +0100 <c_wraith> eh. transformers was created so that mtl and monads-tf could share most of their definitions
2023-11-28 17:16:59 +0100 <c_wraith> monads-tf has basically been forgotten
2023-11-28 17:17:20 +0100 <c_wraith> but every since transformers was created, it's been a dependency of mtl
2023-11-28 17:17:29 +0100 <c_wraith> *ever since
2023-11-28 17:18:30 +0100 <c_wraith> it's the fact that monads-tf was forgotten that makes so many people complicate history. Without it, it's really hard to understand why both transformers and mtl exist
2023-11-28 17:19:21 +0100 <danse-nr3> sheesh, looking through chrome history is awful. Who needs history, anyways? I found a post i liked a lot: https://www.williamyaoh.com/posts/2023-06-10-monad-transformers-101.html bwe
2023-11-28 17:19:48 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-28 17:20:05 +0100 <danse-nr3> it is there where "mtl-style and transformers-style" are mentioned
2023-11-28 17:20:10 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4) (Quit: WeeChat 4.1.1)
2023-11-28 17:20:56 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-28 17:21:03 +0100 <geekosaur> some people do use transformers directly, yes.
2023-11-28 17:21:14 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de)
2023-11-28 17:21:15 +0100 <geekosaur> the problem with that is it'll let you build illegal transformers. mtl won't
2023-11-28 17:21:50 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 17:22:15 +0100 <kaol> I'd expect some people using mtl end up using only a subset that could be done with just transformers.
2023-11-28 17:22:49 +0100 <c_wraith> honestly, I don't like mtl much because effects aren't commutative.
2023-11-28 17:23:14 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-28 17:23:52 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-28 17:23:56 +0100 <c_wraith> anything that encourages writing types which are ambiguous even though the code itself only works correctly one way... that's weakening type safety.
2023-11-28 17:25:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 268 seconds)
2023-11-28 17:25:41 +0100 <c_wraith> the mtl-ish answer to that is that if you need a pair of effects such that the lack of commutativity matters, you should create a new class that encapsulates that requirement. At which point I wonder what the point is...
2023-11-28 17:28:14 +0100Alleria(~JohnGalt@user/alleria)
2023-11-28 17:28:15 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 245 seconds)
2023-11-28 17:29:06 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-28 17:30:33 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 4.0.5)
2023-11-28 17:32:34 +0100 <bwe> geekosaur: so, I'd use mtl, correct?
2023-11-28 17:32:45 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 17:35:19 +0100shapr(~user@2600:1700:c640:3100:7dfc:b197:b7f3:90c3)
2023-11-28 17:36:04 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 17:36:11 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 17:36:49 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-11-28 17:40:12 +0100 <geekosaur> I don't know. I'd use mtl, others prefer effect systems but iirc those let you build illegal combinations of effects with no type errors
2023-11-28 17:41:04 +0100 <bwe> geekosaur: alright; you've mentioned a lot of misinformation around; which information would you point me to specifically?
2023-11-28 17:42:17 +0100kenran(~user@user/kenran) (Remote host closed the connection)
2023-11-28 17:45:53 +0100 <geekosaur> sadly I have more pointers to bad stuff than good
2023-11-28 17:46:12 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 17:46:13 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 17:49:13 +0100 <bwe> hm, so blacklist approach, huh?
2023-11-28 17:49:18 +0100 <EvanR> time to run the garbage collector on your pointers!
2023-11-28 17:50:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Remote host closed the connection)
2023-11-28 17:51:14 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 17:54:05 +0100sb23(~sb23@66.159.217.159) (Quit: Client closed)
2023-11-28 17:55:12 +0100 <bwe> geekosaur: what about chapter 7 of http://www.cs.nott.ac.uk/~pszgmh/monparsing.pdf ?
2023-11-28 17:56:31 +0100 <Unicorn_Princess> effect systems as in algebraic effects?
2023-11-28 17:56:45 +0100 <ski> or more generally, i suppose
2023-11-28 17:57:20 +0100 <ski> (as in, a type system tracking effects as well. often relatively fine-grained)
2023-11-28 17:57:53 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-11-28 17:58:02 +0100 <ski> (e.g. the effect of reading mutable `x' could be different from the effect of reading mutable `y', in the inference rules)
2023-11-28 17:59:32 +0100 <geekosaur> bwe, that has the problem that it's Gopfer (which admittedly ws one of the inspirations for Haskell); I don't think it supported transformers as a general library, although it shows the basics of that
2023-11-28 17:59:38 +0100 <geekosaur> *Gofer
2023-11-28 17:59:51 +0100 <geekosaur> Unicorn_Princess, yes
2023-11-28 18:00:42 +0100 <ski> "don't like mtl much because effects aren't commutative" -- using ordered logic for the relevant constraints would be interesting
2023-11-28 18:00:42 +0100HasEvil(~HasEvil@5.151.177.140)
2023-11-28 18:00:52 +0100skihas been reading about ordered logic, recently
2023-11-28 18:01:00 +0100 <geekosaur> the problem there is that monads don't really comprise an algebra
2023-11-28 18:01:09 +0100 <geekosaur> Cont/COntT breaks a lot of stuff, for example
2023-11-28 18:01:16 +0100 <geekosaur> *ContT
2023-11-28 18:01:17 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 240 seconds)
2023-11-28 18:01:24 +0100josh203(~josh203@freifunk-gw.bsa1-cpe1.syseleven.net)
2023-11-28 18:01:35 +0100 <ski> still, `ConT' is also where a lot of fun and useful power can be had
2023-11-28 18:01:35 +0100danse-nr3(~danse@151.37.249.255) (Ping timeout: 260 seconds)
2023-11-28 18:01:52 +0100 <EvanR> one does not simply compose monads
2023-11-28 18:02:15 +0100 <ski> (e.g. an unbounded stack of `ContT's, with `IO' at the bottom)
2023-11-28 18:02:21 +0100 <HasEvil> hi, I am new to haskell and trying to unpack a maybe. Can't seem to do it.
2023-11-28 18:02:39 +0100 <EvanR> use pattern matching
2023-11-28 18:02:41 +0100 <ski> HasEvil : what have you tried so far ?
2023-11-28 18:02:47 +0100 <ski> @where paste
2023-11-28 18:02:47 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2023-11-28 18:02:49 +0100 <HasEvil> fromMaybe
2023-11-28 18:02:56 +0100 <EvanR> or that
2023-11-28 18:03:02 +0100 <ski> @type fromMaybe
2023-11-28 18:03:03 +0100 <lambdabot> a -> Maybe a -> a
2023-11-28 18:03:05 +0100 <ski> @type maybe
2023-11-28 18:03:06 +0100 <lambdabot> b -> (a -> b) -> Maybe a -> b
2023-11-28 18:03:11 +0100 <Unicorn_Princess> finally something i understand
2023-11-28 18:03:44 +0100chomwitt(~chomwitt@2a02:587:7a24:bc00:1ac0:4dff:fedb:a3f1) (Ping timeout: 268 seconds)
2023-11-28 18:03:46 +0100 <ski> `fromMaybe' is for when you want to supply a default. `maybe' is more general (is equivalent to pattern-match), allows you to transform the value, if there was one, and otherwise provide a default result
2023-11-28 18:03:47 +0100 <HasEvil> EvanR I was wondering if you could do withouth that
2023-11-28 18:04:00 +0100 <Unicorn_Princess> HasEvil, what would you like to do, exactly?
2023-11-28 18:04:11 +0100 <EvanR> the `maybe' function does anything pattern matching could do with a Maybe
2023-11-28 18:04:19 +0100 <EvanR> sometimes it's more convenient
2023-11-28 18:04:23 +0100 <ski> @src fromMaybe
2023-11-28 18:04:23 +0100 <lambdabot> fromMaybe d Nothing = d
2023-11-28 18:04:24 +0100 <lambdabot> fromMaybe _ (Just v) = v
2023-11-28 18:04:26 +0100 <ski> @src maybe
2023-11-28 18:04:26 +0100 <lambdabot> maybe n _ Nothing = n
2023-11-28 18:04:26 +0100 <lambdabot> maybe _ f (Just x) = f x
2023-11-28 18:04:33 +0100 <ski> both of these are defined, via pattern-matching
2023-11-28 18:04:37 +0100 <HasEvil> https://paste.tomsmeding.com/rjwTrqm1
2023-11-28 18:04:38 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-28 18:05:15 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:05:18 +0100 <HasEvil> Ok, so I have a function. that return a maybe. And I want to print it
2023-11-28 18:05:28 +0100 <ski> HasEvil> :t unicodeByName
2023-11-28 18:05:35 +0100 <HasEvil> Actually it returs a Maybe String
2023-11-28 18:05:48 +0100 <EvanR> % print (Just "Hello World")
2023-11-28 18:05:48 +0100 <yahb2> Just "Hello World"
2023-11-28 18:06:01 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-11-28 18:06:19 +0100 <ski> Nothing -> putStrLn "[ERROR] Can't find unicode. Sorry" ++ sad
2023-11-28 18:06:21 +0100 <ski> ought to be
2023-11-28 18:06:29 +0100 <ski> Nothing -> putStrLn ("[ERROR] Can't find unicode. Sorry " ++ sad)
2023-11-28 18:06:38 +0100 <HasEvil> k
2023-11-28 18:06:53 +0100AlexNoo_(~AlexNoo@178.34.151.29)
2023-11-28 18:07:14 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 18:07:50 +0100 <HasEvil> k, thx ski
2023-11-28 18:08:02 +0100 <ski> (although i'd s/sad/happy/,s/:\(/:\)/,s/Sorry/Fortunately/)
2023-11-28 18:08:11 +0100 <HasEvil> but why it would work. I am confussed now
2023-11-28 18:08:15 +0100 <ski> all clear ?
2023-11-28 18:08:45 +0100 <HasEvil> yeah, it compiled. Just needed the paran
2023-11-28 18:08:58 +0100 <ski> btw, instead of `hSetBuffering stdout NoBuffering', you could try `hFlush stdout', after the `putStr' invocation
2023-11-28 18:09:03 +0100AlexZenon(~alzenon@178.34.163.165) (Ping timeout: 256 seconds)
2023-11-28 18:09:12 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Remote host closed the connection)
2023-11-28 18:09:19 +0100 <HasEvil> ski I know. I was just lazy
2023-11-28 18:09:48 +0100 <ski> (also, the brackets around `unicodeByName input' are redundant .. and you can replace the second `let' with ` ' (three spaces))
2023-11-28 18:10:02 +0100 <ski> (and yea .. the `_ <- 's aren't necessary)
2023-11-28 18:10:28 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 18:10:32 +0100josh203(~josh203@freifunk-gw.bsa1-cpe1.syseleven.net) (Remote host closed the connection)
2023-11-28 18:11:04 +0100 <geekosaur> as to why you need the parentheses, function application is higher precedence than anything else so what you originally wrote was read as (putStrLn "[ERROR] Can't find unicode. Sorry") ++ sad
2023-11-28 18:11:10 +0100AlexNoo(~AlexNoo@178.34.163.165) (Ping timeout: 276 seconds)
2023-11-28 18:11:19 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2023-11-28 18:12:09 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:12:53 +0100 <HasEvil> thx geekosaur
2023-11-28 18:12:54 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 18:14:19 +0100 <HasEvil> What if I want to do `let m = ("Hello, " ++ unicodeByName "smile")`
2023-11-28 18:15:03 +0100 <ski> that's fine
2023-11-28 18:15:14 +0100 <ski> well, ok. not with the `Maybe' in the way
2023-11-28 18:15:31 +0100 <ski> do you want to get rid of the `Maybe' here, or keep it around ?
2023-11-28 18:15:40 +0100 <ski> if the former, you can do
2023-11-28 18:16:12 +0100 <ski> m = maybe ":(" ("Hello, " ++) (unicodeByName "smile")
2023-11-28 18:16:14 +0100 <ski> if the latter
2023-11-28 18:16:26 +0100 <ski> m = fmap ("Hello, " ++) (unicodeByName "smile")
2023-11-28 18:16:29 +0100 <ski> which is the same as
2023-11-28 18:16:31 +0100 <HasEvil> k, so maybe can unpack maybe
2023-11-28 18:16:32 +0100 <HasEvil> ??
2023-11-28 18:16:37 +0100 <ski> m = ("Hello, " ++) <$> unicodeByName "smile"
2023-11-28 18:16:41 +0100 <ski> yes
2023-11-28 18:16:55 +0100 <ski> the first of these is equivalent to
2023-11-28 18:16:56 +0100 <HasEvil> k ,thx
2023-11-28 18:17:04 +0100 <ski> m = case unicodeByName "smile" of
2023-11-28 18:17:11 +0100 <ski> Nothing -> ":("
2023-11-28 18:17:16 +0100 <Unicorn_Princess> i don't like the 'maybe' function. it mixes defaulting and functor functionality, and seems just confusing
2023-11-28 18:17:25 +0100 <ski> Just s -> "Hello, " ++ s
2023-11-28 18:17:51 +0100 <ski> `maybe' is just the catamorphism on `Maybe'. just like `either' is the one for `Either', and `foldr' is the one for `[]'
2023-11-28 18:18:05 +0100 <ski> @type bool
2023-11-28 18:18:06 +0100 <lambdabot> a -> a -> Bool -> a
2023-11-28 18:18:13 +0100 <ski> that's catamorphism for `Bool'
2023-11-28 18:18:32 +0100 <Unicorn_Princess> HasEvil, i'd stick with fmap and fromMaybe. less confusing. unless you're comfortable with whatever the heck catamorphisms are
2023-11-28 18:19:08 +0100 <ski> "catamorphism" means : replace all the data constructors (belonging to the type in question) with corresponding callback parameters
2023-11-28 18:19:11 +0100 <EvanR> I had "so you want to unpack a Maybe. Let me first introduce you to some category theory" ready xD
2023-11-28 18:19:24 +0100chomwitt(~chomwitt@ppp-2-85-137-120.home.otenet.gr)
2023-11-28 18:19:34 +0100 <ski> so `foldr cons nil xs' replaces the `(:)'s in `xs' with `cons', and the `[]' with `nil'
2023-11-28 18:19:57 +0100 <ski> > foldr f z (a:b:c:d:[])
2023-11-28 18:19:58 +0100 <lambdabot> f a (f b (f c (f d z)))
2023-11-28 18:20:23 +0100 <ski> similarly, `maybe nothing just m' replaces `Nothing' in `m' with `nothing', and `Just' in `m' with `just'
2023-11-28 18:20:32 +0100 <ski> and ditto for `either left right e'
2023-11-28 18:20:40 +0100 <ski> (and `bool false true b')
2023-11-28 18:20:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Remote host closed the connection)
2023-11-28 18:20:53 +0100AlexZenon(~alzenon@178.34.151.29)
2023-11-28 18:21:25 +0100 <Unicorn_Princess> is this the text equivalent of throwing chalk at your students?
2023-11-28 18:21:26 +0100skihits EvanR over the haid with a right Kan extension
2023-11-28 18:21:34 +0100 <HasEvil> so, what's the diff between just and maube
2023-11-28 18:21:50 +0100 <HasEvil> Unicorn_Princess: probably.
2023-11-28 18:22:14 +0100 <ski> `just' above is an arbitrary parameter, given to the library function `maybe'. i could have said `maybe n j m' instead, if that would make it clearer ?
2023-11-28 18:22:54 +0100 <HasEvil> that I understand. I mant in more gernal terms. If a stdlib function is returing a just or a maybe. Why the difference
2023-11-28 18:22:56 +0100 <EvanR> variables with over 1 letter in haskell, incomprehensible
2023-11-28 18:23:34 +0100 <Unicorn_Princess> HasEvil, anyway, fmap will apply a function to whatever is inside your Maybe, and fromMaybe will return either what's inside your Maybe, or a default value you give it. nice and simple
2023-11-28 18:23:35 +0100 <geekosaur> Just is a data constructor, it takes a value and produces a value. Maybe is a type constructor, it takes a type and produces a type
2023-11-28 18:23:42 +0100 <Unicorn_Princess> the 'maybe' function does both at the same time
2023-11-28 18:24:02 +0100 <ski> e.g. in `maybe 0 (2 ^) (lookup "four" [("two",2),("three",3),("five",5),("seven",7)])', the `nothing'/`n' is `0' (which is what `Nothing' in the result of calling `lookup' will be replaced with), while the `just'/`j' here would be `(2 ^)'. so if the `lookup' gives you `Just n', you compute `2 ^ n'. if it gives you `Nothing', you give `0' as result instead
2023-11-28 18:24:03 +0100 <HasEvil> EvanR: true, As a bignner the whole `a -> b` was so hard to read. And then `Num a =>` can't just say `Num numa => numa`
2023-11-28 18:24:09 +0100 <HasEvil> would be much helpful
2023-11-28 18:24:24 +0100 <EvanR> Numa (Numa a)
2023-11-28 18:24:47 +0100 <ski> Unicorn_Princess : "the 'maybe' function does both at the same time" -- that's more or less an accident. it's nothing particular related to `maybe' being a catamorphism
2023-11-28 18:24:51 +0100 <HasEvil> geekosaur: ok, that actually is starting to make sense
2023-11-28 18:25:14 +0100ski. o O ( `E (Numa (E (Lich a)))' )
2023-11-28 18:25:19 +0100 <HasEvil> Unicorn_Princess: wdym does both at the same time
2023-11-28 18:25:35 +0100 <HasEvil> EvanR: yeah
2023-11-28 18:25:47 +0100 <ski> HasEvil : you're free to name your type variables with multiple characters, if you like to
2023-11-28 18:26:19 +0100 <HasEvil> ski: yeah, but when I ask `:type` they are named single char
2023-11-28 18:26:33 +0100 <EvanR> :t Just
2023-11-28 18:26:34 +0100 <lambdabot> a -> Maybe a
2023-11-28 18:26:48 +0100 <ski> because the implementation doesn't have common sense, can't figure out sensible names for the intended meaning of type variables
2023-11-28 18:26:52 +0100 <EvanR> Just :: a -> Maybe a -- explains the relationships between Just and Maybe
2023-11-28 18:26:58 +0100 <EvanR> in compressed form
2023-11-28 18:27:15 +0100 <geekosaur> the problem here is that `a` could be anything
2023-11-28 18:27:24 +0100 <geekosaur> so there's not really a sensible name for it
2023-11-28 18:27:48 +0100 <johnw> in fact, the opaqueness of the name "a" is meaningful: you can't know anything about that type other than its existence
2023-11-28 18:27:54 +0100 <geekosaur> ghc likes to use `t` (for `type`) when it doesn't have any other name for something
2023-11-28 18:28:00 +0100 <HasEvil> i get that, and it's readable here but when my prof. shows functioin whose type defination contains 3 generics. My mind goes black
2023-11-28 18:28:17 +0100 <ski> .. i guess one could decide to start by using the name `num' for instances of `Num', and `integral' for instances of `Integral', and so on .. but what, then, for a type variable which is constrained to belong to multiple type classes ?
2023-11-28 18:28:19 +0100 <EvanR> sometimes there are useful names for type variables
2023-11-28 18:28:26 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 18:28:32 +0100 <ski> ("perfect being the enemy of good" ?)
2023-11-28 18:28:37 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:28:39 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 18:29:05 +0100 <HasEvil> ski: maybe ord (change to lower case) but I'm just ranting. pretty sure will get used to it
2023-11-28 18:29:13 +0100 <Unicorn_Princess> HasEvil, basically, `maybe x f = fromMaybe x . fmap f`
2023-11-28 18:29:20 +0100 <Unicorn_Princess> (i assume this clears everything up)
2023-11-28 18:29:23 +0100 <ski> in fact, GHC does pick up the names of type variables, from operation that have explicit type signatures .. but often there's be multiple conflicting ones it could use, and so it just picks one of them
2023-11-28 18:29:24 +0100 <johnw> numOrIntegral? :)
2023-11-28 18:29:31 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 245 seconds)
2023-11-28 18:29:34 +0100 <HasEvil> it does. thx
2023-11-28 18:29:41 +0100 <geekosaur> "thingy"
2023-11-28 18:29:44 +0100 <HasEvil> Unicorn_Princess:
2023-11-28 18:29:59 +0100 <ski> HasEvil : in practice, you get used to it. and the succinctness of one-letter names can also help comprehend types (and ordinary value expressions) more, at times
2023-11-28 18:30:00 +0100 <EvanR> StateT stateType baseMonad returnType
2023-11-28 18:30:09 +0100 <EvanR> as opposed to StateT s m a
2023-11-28 18:30:24 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de)
2023-11-28 18:30:27 +0100 <ski> johnw : s/Or/And/, perchance :p
2023-11-28 18:30:41 +0100 <HasEvil> ski: yeah, I thought so. But rn it feels archaic.
2023-11-28 18:30:46 +0100skinods
2023-11-28 18:31:20 +0100 <ski> HasEvil : are you used to some other system where type variables automagically get more useful names inferred ?
2023-11-28 18:31:22 +0100 <HasEvil> also, is `&&` and `and` same
2023-11-28 18:31:30 +0100 <EvanR> :t (&&)
2023-11-28 18:31:31 +0100 <lambdabot> Bool -> Bool -> Bool
2023-11-28 18:31:32 +0100 <EvanR> :t and
2023-11-28 18:31:33 +0100 <lambdabot> Foldable t => t Bool -> Bool
2023-11-28 18:31:43 +0100 <ski> one is binary, the other "variadic"
2023-11-28 18:31:55 +0100 <ski> @type min
2023-11-28 18:31:56 +0100 <lambdabot> Ord a => a -> a -> a
2023-11-28 18:31:57 +0100 <ski> @type minimum
2023-11-28 18:31:58 +0100 <lambdabot> (Foldable t, Ord a) => t a -> a
2023-11-28 18:32:04 +0100 <HasEvil> ski: nah, the only other type system I have used is Rust.
2023-11-28 18:32:15 +0100 <ski> ok
2023-11-28 18:33:01 +0100 <EvanR> && always works, while technically and is totally unsafe and can crash!
2023-11-28 18:33:07 +0100 <EvanR> > and []
2023-11-28 18:33:08 +0100 <lambdabot> True
2023-11-28 18:33:10 +0100 <EvanR> I'm wrong
2023-11-28 18:33:16 +0100 <EvanR> > minimum []
2023-11-28 18:33:17 +0100 <lambdabot> *Exception: Prelude.minimum: empty list
2023-11-28 18:33:40 +0100 <HasEvil> hmm, ok, So, && for two expr. while and for multiple?
2023-11-28 18:33:56 +0100 <EvanR> and works for zero or more bools
2023-11-28 18:34:18 +0100 <exarkun> "while and for" is a lovely triple
2023-11-28 18:35:12 +0100 <EvanR> now I'm wondering how to define while to make that work
2023-11-28 18:37:09 +0100 <ski> @type ?while and for
2023-11-28 18:37:10 +0100 <lambdabot> (?while::(t1 Bool -> Bool) -> (t2 a -> (a -> f b) -> f (t2 b)) -> t3, Traversable t2, Applicative f, Foldable t1) => t3
2023-11-28 18:37:15 +0100 <ski> luvly jubly
2023-11-28 18:37:28 +0100 <EvanR> o_O
2023-11-28 18:38:29 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-11-28 18:39:02 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 18:39:43 +0100 <Inst> what's the most efficient way to express a string of text in unary?
2023-11-28 18:40:30 +0100 <EvanR> run length encoding
2023-11-28 18:41:14 +0100 <EvanR> [(),(),(),(),(),(),()] ==> 7
2023-11-28 18:42:02 +0100 <ski> fwiw, i would not call that "unary"
2023-11-28 18:42:23 +0100 <ski> (the only number you can express in "base one" is zero)
2023-11-28 18:42:36 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:42:38 +0100 <EvanR> not one?
2023-11-28 18:42:42 +0100 <ski> (you could say Peano, or perhaps tally marks, if you wish)
2023-11-28 18:42:53 +0100 <Inst> peano, then
2023-11-28 18:43:02 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 18:43:08 +0100 <ski> the digits in base `n' are the elements of `{0,1,2,...,n-2,n-1}'
2023-11-28 18:43:18 +0100 <ski> if `n = 1', then that's `{0}'
2023-11-28 18:43:35 +0100 <ski> so, we have the only numeral being `...00000', which expresses zero
2023-11-28 18:45:03 +0100 <ski> hm, anyway, to express pairs, we need an injection `pair :: Nat -> Nat -> Nat'. one possible definition is `pair m n = 2^m * 3^n'
2023-11-28 18:45:37 +0100 <ski> it's better, though, if it's also surjective, so that we don't waste representations by having no pairs map to them
2023-11-28 18:45:57 +0100 <Inst> yeah, but I think commonplace unary is good enough
2023-11-28 18:45:58 +0100 <ski> so, one can pick `pair m n = 2^m * (2*n + 1)', which is a bijection
2023-11-28 18:46:38 +0100 <Inst> this algorithm is far from efficient, right?
2023-11-28 18:46:52 +0100 <Inst> convert the chars in a string to numbers, show, then concat
2023-11-28 18:47:02 +0100 <Inst> that gives you a unary representation of a given text
2023-11-28 18:47:07 +0100 <Inst> but the size of the output is ridiculous
2023-11-28 18:47:17 +0100 <Inst> erm, replicate onto the concat
2023-11-28 18:47:30 +0100 <ski> still, that grows quite fast in `m'. even better is `pair m n = (m+n)*(m+n+1) `div` 2 + m' (which is counting diagonally in a quadrant of a coordinate system. (m+n)*(m+n+1) `div` 2 is the triangular number of `m+n')
2023-11-28 18:48:21 +0100 <ski> now, considering `[a] = 1 + a * [a]', we can use `pair' for the cons case here. and we use `0' for the `1' alternative, and `(1 +)' for the other alternative
2023-11-28 18:48:32 +0100 <ski> so
2023-11-28 18:48:49 +0100 <ski> encodeList :: (a -> Nat) -> ([a] -> Nat)
2023-11-28 18:48:59 +0100 <ski> encodeList encodeElem [ ] = 0
2023-11-28 18:49:16 +0100 <ski> encodeList encodeElem (x:xs) = 1 + pair (encodeElem x) (encodeList encodeElem xs)
2023-11-28 18:49:47 +0100 <ski> (decoding isn't much harder)
2023-11-28 18:49:48 +0100notzmv(~zmv@user/notzmv)
2023-11-28 18:50:10 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 276 seconds)
2023-11-28 18:50:11 +0100 <Inst> welp
2023-11-28 18:50:14 +0100 <Inst> i just crashed nvim
2023-11-28 18:50:21 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-11-28 18:50:34 +0100 <int-e> Inst: Nothing will be efficient here since you need length O(N) to represent N different values in "unary"; there are exponentially many strings of length n, so N ~ 2^O(n), so you're looking at exponentially large encodings or worse.
2023-11-28 18:50:49 +0100 <ski> an alternative is think of `[a]' as `exists (n :: Nat). a^n', so you represent a list as a pair of its length `n', and an `n'-tuple of elements
2023-11-28 18:50:52 +0100absence_(torgeihe@hildring.pvv.ntnu.no) (Quit: Lost terminal)
2023-11-28 18:50:56 +0100euleritian(~euleritia@dynamic-046-114-202-009.46.114.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-28 18:51:15 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-28 18:51:17 +0100 <int-e> These kind of questions are quite firmly theoretical.
2023-11-28 18:51:34 +0100 <EvanR> you can use run-length encoding on your "unary" to compress it xD
2023-11-28 18:51:36 +0100 <ski> yea
2023-11-28 18:51:47 +0100 <Inst> It's an acquaintance of sorts
2023-11-28 18:51:50 +0100troydm(~troydm@user/troydm) (Ping timeout: 252 seconds)
2023-11-28 18:51:53 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:51:56 +0100 <Inst> I joked I'd only message them during business hours in unary
2023-11-28 18:52:08 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 18:52:32 +0100 <EvanR> do they have a client which can "decode unary"
2023-11-28 18:52:37 +0100 <int-e> Well you can send a sequence of messages I suppose.
2023-11-28 18:52:48 +0100 <int-e> One character per message. That's not *too* explosive.
2023-11-28 18:53:07 +0100ski. o O ( "A Functional Hitchhiker's Guide to Hereditarily Finite Sets, Ackermann Encodings and Pairing Functions" by Paul Tarau in 2008-08-06 at <https://arxiv.org/abs/0808.0754> )
2023-11-28 18:53:10 +0100 <Inst> anyways, any idea how to convert from unicode to ASCII?
2023-11-28 18:53:17 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 18:53:25 +0100 <geekosaur> how do you convert 🙂 ?
2023-11-28 18:53:27 +0100 <Inst> because now this is a huge mess
2023-11-28 18:53:54 +0100 <int-e> UTF-7
2023-11-28 18:54:01 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 260 seconds)
2023-11-28 18:54:03 +0100 <exarkun> UTF-1, obviously
2023-11-28 18:54:12 +0100 <geekosaur> if you mean "how do I encode Unicode as bytes?" then the answer is UTF-8
2023-11-28 18:54:26 +0100 <EvanR> when one character is a big deal you can utilize ham radio codes like CQ, QRZ, QRM, etc
2023-11-28 18:54:38 +0100 <EvanR> QSO
2023-11-28 18:55:33 +0100 <int-e> How can UTF-7 be "obsolete"... it's much newer than Fortran ;-)
2023-11-28 18:56:09 +0100 <EvanR> meanwhile UTF-9 is alive and well
2023-11-28 18:58:07 +0100 <Inst> it turns out peano isn't efficient enough a representation format to encode messages as a joke :(
2023-11-28 18:59:30 +0100 <EvanR> you can send one character per line, each line a number of |
2023-11-28 18:59:30 +0100 <Inst> just to encode "ilu" takes 230 mb
2023-11-28 19:00:01 +0100 <geekosaur> -.-. --.- -.. . -.- -... ---.. -. ....
2023-11-28 19:00:14 +0100 <int-e> ah, ternary
2023-11-28 19:00:16 +0100 <int-e> ;)
2023-11-28 19:00:21 +0100 <ski> as `n' goes to `Nat', `m + n' goes to `Nat' (being `m + Nat') -- this is comparision/subtraction (by/with `m'), offsets
2023-11-28 19:00:22 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 19:00:28 +0100 <ski> if `n > 0', then as `m' goes to `Nat', `m * n' goes to `Nat' (being `Nat * n') -- this is quotient&remainder, coordinates
2023-11-28 19:00:34 +0100 <ski> if `n > 1', then as `m' goes to `Nat', `n ^ m' goes to `Nat' (being `n ^ (Nat)', functions with finite support) -- this is numeral representation (in base `n'), digits
2023-11-28 19:00:40 +0100 <Inst> CQDEKB8NH ?
2023-11-28 19:01:09 +0100 <geekosaur> hm, I got that slightly wrong
2023-11-28 19:01:19 +0100 <geekosaur> been years since I did CW
2023-11-28 19:02:03 +0100 <EvanR> > let f n = replicate n '|' in (length . unlines . map (f . ord)) "ilu"
2023-11-28 19:02:04 +0100 <lambdabot> 333
2023-11-28 19:02:12 +0100 <EvanR> 333 < 230 MB
2023-11-28 19:02:27 +0100 <Inst> goddamnit :(
2023-11-28 19:02:47 +0100 <Inst> but that's not a correct representation
2023-11-28 19:02:54 +0100 <EvanR> no?
2023-11-28 19:03:07 +0100 <Inst> is the representation of ilu and uli the same in this situation?
2023-11-28 19:03:13 +0100 <EvanR> no
2023-11-28 19:03:19 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-11-28 19:03:47 +0100 <Inst> unlines is working as a join
2023-11-28 19:03:58 +0100 <Inst> you lose the character information, i.e, there is a large number of possible interpretations of the resulting code
2023-11-28 19:04:01 +0100 <geekosaur> but it inserts spaces
2023-11-28 19:04:03 +0100 <EvanR> the newlines are serving the same purpose as the pause between codes in the CW above
2023-11-28 19:04:14 +0100 <geekosaur> er, newlines
2023-11-28 19:04:16 +0100 <int-e> Inst: no, there are newlines in there
2023-11-28 19:04:18 +0100 <Inst> i guess my implementation doesn't have spaces :(
2023-11-28 19:04:32 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 19:04:34 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 19:04:42 +0100 <Inst> so i have to encode character separation via unary
2023-11-28 19:04:46 +0100 <Inst> all these jokes are silly, though
2023-11-28 19:04:54 +0100 <EvanR> a space could be a blank line or 32 |
2023-11-28 19:05:02 +0100stevenxl(uid133530@id-133530.uxbridge.irccloud.com)
2023-11-28 19:05:46 +0100 <Inst> the problem is that the encoding isn't data complete
2023-11-28 19:06:11 +0100 <EvanR> if you can send 0 and 1, that's the best you can do. Unless you're trying to send quantum states
2023-11-28 19:06:17 +0100 <Inst> you need something other than the simple representation, i.e, if you had space, it's spiritually the same as binary with space operating as 0
2023-11-28 19:06:26 +0100 <Inst> if i can only send 1, or the number of 1s
2023-11-28 19:06:36 +0100 <EvanR> oh, then send the number of 1s
2023-11-28 19:06:40 +0100 <EvanR> much more efficient
2023-11-28 19:06:41 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 19:06:46 +0100 <EvanR> aka run length encoding
2023-11-28 19:06:55 +0100 <Inst> but that ruins the joke, no?
2023-11-28 19:07:05 +0100 <EvanR> or is it much funnier
2023-11-28 19:07:11 +0100 <int-e> EvanR: oh and then you can encode the numbers in binary
2023-11-28 19:07:13 +0100 <Inst> it's not funny at all in an objective context
2023-11-28 19:07:19 +0100 <EvanR> lol
2023-11-28 19:07:21 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 19:07:27 +0100 <int-e> EvanR: you might end up with "ilu", just 3 characters
2023-11-28 19:07:41 +0100 <int-e> that seems rather efficient
2023-11-28 19:08:01 +0100 <Inst> subjectively? corny joke to encode messages in emoticons
2023-11-28 19:08:09 +0100 <Inst> oh well, the counterparty wouldn't appreciate this joke at this time anyways
2023-11-28 19:08:10 +0100 <EvanR> recursively run-length encoded natural numbers are pretty cool
2023-11-28 19:08:11 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 19:08:29 +0100 <EvanR> might not help with "ilu" though
2023-11-28 19:08:31 +0100 <Inst> given a single emoticon, encode a message using that emoticon only
2023-11-28 19:08:32 +0100 <int-e> single "unary" characters seaparated by newlines seems to be very much in the spirit of the joke and have a reasonable chance of being decoded.
2023-11-28 19:08:54 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-28 19:08:57 +0100 <Inst> thanks for being a dating coach!
2023-11-28 19:09:00 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 19:09:02 +0100 <Inst> now, to actually find someone who likes this as a joke!
2023-11-28 19:09:11 +0100HasEvil(~HasEvil@5.151.177.140) (Remote host closed the connection)
2023-11-28 19:09:12 +0100 <int-e> any added layer of encoding will make decoding less likely to happen or even be attempted.
2023-11-28 19:09:36 +0100 <int-e> qba'g ubyq lbhe oerngu
2023-11-28 19:09:44 +0100 <EvanR> you think you have a chance with that influencer xD
2023-11-28 19:09:49 +0100 <Inst> not that one
2023-11-28 19:09:50 +0100 <EvanR> is that what this is about
2023-11-28 19:10:19 +0100 <Inst> this is only the sort of lame joke that possibly flies when you're already "plushies" relative to each other
2023-11-28 19:10:54 +0100 <EvanR> this is starting to sound like a huge XY
2023-11-28 19:11:32 +0100 <geekosaur> figuratively or literally?
2023-11-28 19:11:32 +0100 <Inst> XY?
2023-11-28 19:11:33 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a)
2023-11-28 19:11:36 +0100 <ski> hm, now i'm reminded of that programming challenge thing, that reoccured subsequent years, where in one year, you got a huge chunk of "alien DNA", that you were to decode an initial portion of, and then use that to decompress the remainder, and then decode an initial portion of that, and then decompress remainder again, &c.
2023-11-28 19:11:52 +0100pr0ton(~pr0ton@176.254.244.83) (Ping timeout: 256 seconds)
2023-11-28 19:12:58 +0100 <EvanR> was the kicker that the alien DNA was the HTTP over TCP over IP protocol
2023-11-28 19:14:30 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 260 seconds)
2023-11-28 19:15:39 +0100 <ski> i don't recall
2023-11-28 19:16:03 +0100 <ski> this may've been ICFP challenge or somesuch
2023-11-28 19:20:09 +0100danso(~danso@user/danso) (Ping timeout: 260 seconds)
2023-11-28 19:20:55 +0100danso(~danso@user/danso)
2023-11-28 19:21:57 +0100troydm(~troydm@user/troydm)
2023-11-28 19:23:44 +0100 <int-e> ski: this? https://save-endo.cs.uu.nl/
2023-11-28 19:24:39 +0100haasn`(~nand@haasn.dev)
2023-11-28 19:26:27 +0100pr0ton(~pr0ton@176.254.244.83)
2023-11-28 19:28:43 +0100 <ski> i believe that's it, yes
2023-11-28 19:29:31 +0100Shock_shOkEy
2023-11-28 19:31:30 +0100gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2023-11-28 19:32:38 +0100 <EvanR> Teams may work in any programming language(s) that they wish. They may employ any computational resources at their disposal.
2023-11-28 19:32:45 +0100 <EvanR> ah the simple times before "AI"
2023-11-28 19:32:53 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-28 19:37:06 +0100gentauro(~gentauro@user/gentauro)
2023-11-28 19:40:34 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Remote host closed the connection)
2023-11-28 19:41:27 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 19:41:56 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 19:42:54 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 19:49:56 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 19:52:37 +0100alp_(~alp@2001:861:e3d6:8f80:d1dc:7d30:db10:a74e) (Ping timeout: 256 seconds)
2023-11-28 19:54:44 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 19:55:10 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 19:56:20 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-11-28 19:58:28 +0100 <Inst> Would it be worth putting up on hackage an idiomatic utility program for peano-based cryptography?
2023-11-28 20:00:35 +0100target_i(~target_i@217.175.14.39)
2023-11-28 20:03:21 +0100infinity0_(~infinity0@pwned.gg)
2023-11-28 20:03:21 +0100infinity0Guest2611
2023-11-28 20:03:21 +0100Guest2611(~infinity0@pwned.gg) (Killed (zirconium.libera.chat (Nickname regained by services)))
2023-11-28 20:03:21 +0100infinity0_infinity0
2023-11-28 20:04:49 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 20:05:40 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 20:06:54 +0100 <dminuoso_> Is that software worth to you?
2023-11-28 20:08:23 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 264 seconds)
2023-11-28 20:12:14 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-11-28 20:12:21 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 20:12:34 +0100mc47(~mc47@xmonad/TheMC47)
2023-11-28 20:19:00 +0100jargon(~jargon@184.101.176.143) (Remote host closed the connection)
2023-11-28 20:20:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Read error: Connection reset by peer)
2023-11-28 20:20:48 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 20:25:32 +0100Inst(~Inst@120.244.192.187) (Ping timeout: 256 seconds)
2023-11-28 20:28:03 +0100Inst(~Inst@120.244.192.187)
2023-11-28 20:28:31 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-11-28 20:28:40 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 20:32:20 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 256 seconds)
2023-11-28 20:32:55 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 20:37:26 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa)
2023-11-28 20:38:22 +0100JeremyB99(~JeremyB99@2607:fb91:17e0:e4b0:df9:9507:1cb2:bcfa) (Read error: Connection reset by peer)
2023-11-28 20:38:44 +0100not_reserved(~not_reser@45.144.113.236) (Quit: Client closed)
2023-11-28 20:38:48 +0100zetef(~quassel@2a02:2f00:5201:4b00:7fc8:6fbe:33d9:ba2a) (Remote host closed the connection)
2023-11-28 20:42:19 +0100alp_(~alp@2001:861:e3d6:8f80:1cde:a541:9274:7e5a)
2023-11-28 20:43:39 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 20:47:38 +0100JeremyB99(~JeremyB99@208.64.173.6)
2023-11-28 20:48:03 +0100 <EvanR> cryptography based on obscure humor xD
2023-11-28 20:49:51 +0100 <tomsmeding> Inst: what does that even mean
2023-11-28 20:51:36 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 256 seconds)
2023-11-28 20:51:49 +0100 <dminuoso_> Sigh I wish nix was more like haskell. :(
2023-11-28 20:52:11 +0100JeremyB99(~JeremyB99@208.64.173.6) (Ping timeout: 252 seconds)
2023-11-28 20:52:38 +0100 <dminuoso_> I want a rich prelude, whitespace aware grammar where bindings, list pattern matching...
2023-11-28 20:53:38 +0100 <dminuoso_> Its curious how Haskell has this "its a research" language label, but nix does not have this "its shoehorned unfinished research" label
2023-11-28 20:53:53 +0100 <dminuoso_> Maybe "get things done quickly instead of right" really is the recipe for success
2023-11-28 20:56:55 +0100 <zzz> javascript
2023-11-28 20:57:09 +0100 <[exa]> dminuoso_: it's a failure-delaying recipe
2023-11-28 20:57:26 +0100 <dminuoso_> [exa]: Seems to be a recurring theme in humanity.
2023-11-28 20:57:49 +0100 <zzz> nature knows there is no such thing as "right"
2023-11-28 20:57:51 +0100 <[exa]> dminuoso_: life is short, you gotta find the balance
2023-11-28 20:58:50 +0100 <kaol> Should've tried avoiding success more.
2023-11-28 21:00:07 +0100 <zzz> safety is commonly overrated but it's nice to think about
2023-11-28 21:01:11 +0100 <zzz> an in life you have to take risks
2023-11-28 21:03:49 +0100Pickchea(~private@user/pickchea)
2023-11-28 21:04:11 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 21:05:35 +0100 <sshine> dminuoso_, doesn't Dhall translate to Nix?
2023-11-28 21:06:25 +0100 <sshine> dminuoso_, I attended my first Nix meetup last week. there was a "for beginners" talk, and I heard the sentence "Nix is *just* a bunch of shell scripts, and Perl." a lot of times.
2023-11-28 21:07:27 +0100 <dminuoso_> sshine: Yeah, dhall is somewhat nicer, but really adding another compilation layer isn't going to help with adoption at $work.
2023-11-28 21:07:54 +0100 <sshine> dminuoso_, I suppose so. but I also thought maybe that could be fixed with just a single package in one's nix configuration.
2023-11-28 21:08:09 +0100 <sshine> dminuoso_, do you use Nix for deployment at work?
2023-11-28 21:08:13 +0100 <dminuoso_> Yes.
2023-11-28 21:08:21 +0100 <dminuoso_> We operate over a hundred machines with it
2023-11-28 21:08:28 +0100 <dminuoso_> NixOS that is.
2023-11-28 21:08:50 +0100 <sshine> I'm aiming to do so. the lead architect asked me a leading question if I'd tried Nix. so I know I've got buy-in. :) it's just one of those things you have to invest your own time in also.
2023-11-28 21:09:25 +0100 <dminuoso_> Im really torn with nix.
2023-11-28 21:09:35 +0100 <sshine> I think we're at 15 or so now, running Debian with custom .debs, but upgrading is gradually turning to haywire.
2023-11-28 21:09:47 +0100 <dminuoso_> If it was just pure nix, I wouldnt focus too much on it. With NixOS its a trade off.
2023-11-28 21:10:02 +0100 <sshine> why?
2023-11-28 21:10:14 +0100 <dminuoso_> It comes with significant costs, none of which make me happy - but the benefits outweigh them slightly.
2023-11-28 21:11:02 +0100 <sshine> what costs are associated with NixOS that aren't with Nix? (also, if this is too offtopic for #haskell, I'm in #haskell-offtopic now.)
2023-11-28 21:11:44 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 21:12:44 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 268 seconds)
2023-11-28 21:15:42 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-28 21:15:52 +0100 <yushyin> i always tell myself, at least it's not YAML with python filters
2023-11-28 21:16:06 +0100 <dminuoso_> yushyin: Right, and thats sort of the "why do we even use it" reason.
2023-11-28 21:16:07 +0100pounce(~pounce@user/cute/pounce) (Read error: error:0A000119:SSL routines::decryption failed or bad record mac)
2023-11-28 21:16:10 +0100 <dminuoso_> Its better than the alternatives.
2023-11-28 21:16:16 +0100 <sshine> that's what they say at the Nix club.
2023-11-28 21:16:22 +0100 <dminuoso_> Which isnt mich to go on, but hey, its something.
2023-11-28 21:17:08 +0100 <dminuoso_> One of my favourite ones in nixos modules is: infinite recursion detected. GOOD LUCK!
2023-11-28 21:17:13 +0100 <sshine> "at least it's not YAML." -- but I think all YAML isn't created equally. for example, Ansible YAML seems to be schema-validated before they try to execute it. (executing is a mess, but at least you get good error messages in case you made a scope indentation error.)
2023-11-28 21:17:23 +0100pounce(~pounce@user/cute/pounce)
2023-11-28 21:17:37 +0100 <dminuoso_> The YAML part is a red herring in all of ansible.
2023-11-28 21:17:42 +0100 <ski> (sshine : it's fine)
2023-11-28 21:17:42 +0100 <dminuoso_> YAML is merely the lexical structure.
2023-11-28 21:17:48 +0100 <dminuoso_> It doesnt mean anything
2023-11-28 21:17:48 +0100 <Rembane> It's very red. It's very herring.
2023-11-28 21:17:50 +0100 <sshine> whereas Helm has a nicer execution model, but the syntax is... footguns with footguns all the way down.
2023-11-28 21:18:08 +0100 <Rembane> sshine: Does Helm use its own syntax? Home rolled and dangerous?
2023-11-28 21:18:09 +0100 <dminuoso_> Rembane: Are herrings red, though?
2023-11-28 21:18:20 +0100 <dminuoso_> Pink, maybe.
2023-11-28 21:18:34 +0100 <Rembane> dminuoso_: All my herrings are red. I am quite drunk when I am close to them though, and they are fermented.
2023-11-28 21:18:47 +0100 <ski> not smoked ?
2023-11-28 21:19:34 +0100 <sshine> Rembane, Helm uses handlebar-like macros, but the really difficult thing is that when you have macros that produce whitespace-sensitive output, you have a bunch of variations of handlebars that regulate the output, and a bunch of helper macros that indent it further. it feels like most of my cognitive capacity, when writing Helm scripts, goes into thinking about whitespace, and very little goes into
2023-11-28 21:19:40 +0100 <sshine> thinking about the underlying resource definitions.
2023-11-28 21:20:33 +0100 <dminuoso_> Rembane: Is there a casual connection to you being close to them, and them being fermeted?
2023-11-28 21:20:47 +0100 <dminuoso_> I can imagine throwing up while drunk could trigger fermentation. Is that it?
2023-11-28 21:21:18 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-28 21:21:38 +0100 <monochrom> :(
2023-11-28 21:23:19 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-11-28 21:24:46 +0100stevenxl(uid133530@id-133530.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 21:26:10 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-28 21:27:37 +0100AlexNoo_AlexNoo
2023-11-28 21:29:44 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-11-28 21:31:51 +0100iqubic(~avi@2601:602:9502:c70:c94f:89a4:f1d7:2a2a) (Ping timeout: 268 seconds)
2023-11-28 21:33:58 +0100pounce(~pounce@user/cute/pounce) (Ping timeout: 276 seconds)
2023-11-28 21:38:46 +0100shapr(~user@2600:1700:c640:3100:7dfc:b197:b7f3:90c3) (Remote host closed the connection)
2023-11-28 21:39:00 +0100shapr(~user@2600:1700:c640:3100:9f9c:9e66:1ec1:188)
2023-11-28 21:41:32 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-28 21:44:07 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f) (Remote host closed the connection)
2023-11-28 21:45:21 +0100yahb2(~yahb2@2a01:4f8:c0c:5c7b::2) (Remote host closed the connection)
2023-11-28 21:45:45 +0100yahb2(~yahb2@static.56.27.47.78.clients.your-server.de)
2023-11-28 21:45:45 +0100ChanServ+v yahb2
2023-11-28 21:45:56 +0100danza(~francesco@151.47.212.250)
2023-11-28 21:46:58 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 268 seconds)
2023-11-28 21:53:13 +0100ircbrowse_tom(~ircbrowse@static.162.49.55.162.clients.your-server.de)
2023-11-28 21:53:19 +0100Server+Cnt
2023-11-28 21:53:52 +0100marinelli(~weechat@gateway/tor-sasl/marinelli)
2023-11-28 21:54:28 +0100 <zzz> if i have a haskell program running on my server and i want another program (not haskell) to communicate with it, sending and getting responses just a few times a second, what would be the simplest way to do it? i am looking at IPC, pipes and so on but i'm a little lost. i've never done anything of the sort
2023-11-28 21:55:28 +0100 <juri_> can confirm all of the above, and pour on some gasoline: ansible's yaml verification is great, too bad it uses a templating system that is very python version / templating tool version / ansible version dependant. nothing like an ansible script doing the wrong thing halfway through a run because your dependencies don't quite work well enough together.
2023-11-28 21:56:13 +0100 <sshine> juri_, haha yeah, I do remember that. doing Ansible scripts to bootstrap a system, you have to install the right Python version first.
2023-11-28 21:56:48 +0100tomsmeding(~tomsmedin@static.21.109.88.23.clients.your-server.de) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-28 21:57:21 +0100tomsmeding(~tomsmedin@2a01:4f8:c0c:5e5e::2)
2023-11-28 21:58:21 +0100 <sshine> zzz, there's quite a lot you can do. TCP, UNIX domain socket. REST, RPC. here's a simple example: https://stackoverflow.com/questions/29593116/simple-unix-domain-sockets-server
2023-11-28 21:58:29 +0100 <Rembane> dminuoso_: No, not at all. First the herring is fermented and then it is eaten while drinking lots of fermented and distilled beverages.
2023-11-28 21:59:22 +0100 <Rembane> sshine: W.r.t. Helm: That sounds exciting in all the wrong ways. I think I would've prefered a compiler to macros and templates.
2023-11-28 22:02:34 +0100 <sshine> Rembane, the Helm documentation even has a section on how bad this is: https://helm.sh/docs/chart_template_guide/control_structures/#controlling-whitespace -- I remember doing this for a while, it occurred to me "Wait, Lisp has macros, and Lisp doesn't blow up when I misplace a whitespace. what's happening here?"
2023-11-28 22:02:52 +0100 <dminuoso_> Rembane: That sounds like an awful complication. Couldnt you just ferment the hering in the same drink you are drinking?
2023-11-28 22:02:57 +0100 <dminuoso_> Seems it would speed up the consumption process.
2023-11-28 22:03:01 +0100 <Rembane> sshine: That's hilarious!
2023-11-28 22:03:31 +0100 <Rembane> dminuoso_: Hm... that's a good point. The part I'm really interested in is the concept of distilling herring.
2023-11-28 22:03:53 +0100 <dminuoso_> Rembane: Well you can distill herring just fine. Its just that after one destillation you will have 0% herring left.
2023-11-28 22:04:02 +0100 <sshine> Rembane, it's like the clip from Rick & Morty where, if you align the dead flies correctly on Rick's table, it unlocks his bunker. except, it's not a joke.
2023-11-28 22:04:08 +0100 <dminuoso_> That may or may not be what you want.
2023-11-28 22:05:56 +0100 <Rembane> dminuoso_: Is there no herring in the alcohol?
2023-11-28 22:06:19 +0100danza(~francesco@151.47.212.250) (Ping timeout: 255 seconds)
2023-11-28 22:06:26 +0100 <Rembane> sshine: I try to laugh at it anyway. I'm a fool. I am truly fascinated that things ended up like this.
2023-11-28 22:06:33 +0100 <dminuoso_> You have a point, I dont actually know the boiling point of herring.
2023-11-28 22:06:47 +0100 <dminuoso_> Sounds like we need some bachelor students.
2023-11-28 22:06:50 +0100 <Rembane> I assume the same as water.
2023-11-28 22:07:16 +0100 <dminuoso_> Rembane: Are you suggesting if you boil a pot of water with herrings, some of the herring will start evaporating into air as herring gas?
2023-11-28 22:07:23 +0100 <Vq> You fry or pickle them, you don't boil them.
2023-11-28 22:07:34 +0100 <Rembane> dminuoso_: Yes!
2023-11-28 22:07:46 +0100 <sshine> Rembane, I think handlebar-style templating was a pretty great thing in back-end web frameworks, it was a great improvement over PHP, decoupling markup and domain logic, and the syntax is super lightweight and non-invasive wrt. HTML/CSS. so why not repurpose it for generating YAML that defines what servers run and not?
2023-11-28 22:08:23 +0100 <EvanR> I said HTML should just have functions in the sense of lambda calculus, beta reduction. People thought I was nuts
2023-11-28 22:08:38 +0100 <EvanR> either because that's PHP and it's terrible. Or that's PHP which is great and already exists
2023-11-28 22:09:08 +0100 <juri_> xhtml + xslt was neat. wish it would have caught on, instead of css.
2023-11-28 22:09:10 +0100trev(~trev@user/trev)
2023-11-28 22:09:19 +0100 <Rembane> sshine: I agree wholheartedly until the part where it should generate something that is whitespace sensitive.
2023-11-28 22:09:31 +0100 <sshine> yeah, I liked xslt.
2023-11-28 22:09:43 +0100 <Rembane> I think there is a language that is a lisp and that compiles down to html.
2023-11-28 22:09:56 +0100 <EvanR> is it called javascript
2023-11-28 22:10:23 +0100 <Rembane> It might be a lisp, but it doesn't look like one.
2023-11-28 22:10:28 +0100 <sshine> I try to obsess about only a couple of languages per decade.
2023-11-28 22:11:02 +0100pavonia(~user@user/siracusa)
2023-11-28 22:11:03 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-11-28 22:12:15 +0100teqwve(teqwve@2a01:4f8:c2c:e5b0::1)
2023-11-28 22:13:05 +0100 <Rembane> It seems like I was thinking of X-expressions and Racket which is a Scheme and not really a Lisp, so Javascript could most definitely work too.
2023-11-28 22:13:21 +0100 <ski> Scheme is a Lisp
2023-11-28 22:13:58 +0100 <Rembane> Then I've misunderstood something.
2023-11-28 22:14:02 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-11-28 22:14:02 +0100 <Rembane> That's reassuring.
2023-11-28 22:14:07 +0100 <ski> (Logo and Dylan are often also "spiritually" considered Lisps, even though they don't use SExps)
2023-11-28 22:14:17 +0100 <EvanR> by defining suitable "builder" functions a bunch of markup in js looks vaguely like funny looking s-expressions xD
2023-11-28 22:14:18 +0100 <sshine> somehow the lisp in Scheme is silent.
2023-11-28 22:14:52 +0100end(~end@user/end/x-0094621) (Quit: end)
2023-11-28 22:17:22 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5836:1305:ce95:7f7f)
2023-11-28 22:19:29 +0100end(~end@user/end/x-0094621)
2023-11-28 22:22:09 +0100JeremyB99(~JeremyB99@208.64.173.6)
2023-11-28 22:23:47 +0100bcksl(~bcksl@user/bcksl) (Quit: \)
2023-11-28 22:27:16 +0100JeremyB99(~JeremyB99@208.64.173.6) (Ping timeout: 276 seconds)
2023-11-28 22:28:08 +0100bcksl(~bcksl@user/bcksl)
2023-11-28 22:28:08 +0100JeremyB99(~JeremyB99@2607:fb91:17ee:4c81:15dc:c9c4:136:fc18)
2023-11-28 22:31:31 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-11-28 22:34:27 +0100caryhartline(~caryhartl@168.182.58.169) (Ping timeout: 268 seconds)
2023-11-28 22:35:34 +0100mrmr15533(~mrmr@user/mrmr) (Ping timeout: 255 seconds)
2023-11-28 22:35:39 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 22:38:45 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-28 22:41:35 +0100dhil(~dhil@2001:8e0:2014:3100:8523:26aa:23b6:e435) (Ping timeout: 260 seconds)
2023-11-28 22:43:12 +0100alp_(~alp@2001:861:e3d6:8f80:1cde:a541:9274:7e5a) (Ping timeout: 256 seconds)
2023-11-28 22:44:00 +0100JeremyB99(~JeremyB99@2607:fb91:17ee:4c81:15dc:c9c4:136:fc18) (Ping timeout: 268 seconds)
2023-11-28 22:44:56 +0100brettgilio(a35ba67324@2604:bf00:561:2000::260) (Ping timeout: 245 seconds)
2023-11-28 22:44:56 +0100aniketd(32aa4844cd@2604:bf00:561:2000::dcb) (Ping timeout: 245 seconds)
2023-11-28 22:44:56 +0100evanrelf(3addc196af@2604:bf00:561:2000::f0) (Ping timeout: 245 seconds)
2023-11-28 22:44:56 +0100jleightcap(7bc4014b62@user/jleightcap) (Ping timeout: 245 seconds)
2023-11-28 22:44:56 +0100bsima1(9d7e39c8ad@2604:bf00:561:2000::dd) (Ping timeout: 245 seconds)
2023-11-28 22:45:05 +0100chaitlatte0(ea29c0bb16@user/chaitlatte0) (Read error: Connection reset by peer)
2023-11-28 22:45:05 +0100lukec(9dfd4d094e@2604:bf00:561:2000::10e) (Read error: Connection reset by peer)
2023-11-28 22:45:10 +0100shreyasminocha(51fdc93eda@user/shreyasminocha) (Read error: Connection reset by peer)
2023-11-28 22:45:11 +0100whereiseveryone(206ba86c98@2604:bf00:561:2000::2e4) (Read error: Connection reset by peer)
2023-11-28 22:45:11 +0100fluffyballoon(45ce440a48@2604:bf00:561:2000::e2) (Read error: Connection reset by peer)
2023-11-28 22:45:18 +0100lukec(9dfd4d094e@2604:bf00:561:2000::10e)
2023-11-28 22:45:21 +0100evanrelf(3addc196af@2604:bf00:561:2000::f0)
2023-11-28 22:45:23 +0100bsima1(9d7e39c8ad@2604:bf00:561:2000::dd)
2023-11-28 22:45:27 +0100chaitlatte0(ea29c0bb16@2604:bf00:561:2000::1124)
2023-11-28 22:45:28 +0100chaitlatte0(ea29c0bb16@2604:bf00:561:2000::1124) (Changing host)
2023-11-28 22:45:28 +0100chaitlatte0(ea29c0bb16@user/chaitlatte0)
2023-11-28 22:45:35 +0100brettgilio(a35ba67324@2604:bf00:561:2000::260)
2023-11-28 22:45:35 +0100whereiseveryone(206ba86c98@2604:bf00:561:2000::2e4)
2023-11-28 22:45:35 +0100jleightcap(7bc4014b62@user/jleightcap)
2023-11-28 22:45:35 +0100fluffyballoon(45ce440a48@2604:bf00:561:2000::e2)
2023-11-28 22:45:35 +0100shreyasminocha(51fdc93eda@user/shreyasminocha)
2023-11-28 22:45:37 +0100aniketd(32aa4844cd@2604:bf00:561:2000::dcb)
2023-11-28 22:45:49 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-11-28 22:45:57 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 22:46:01 +0100fgaz_(1ff9197ed6@2604:bf00:561:2000::11ea) (Read error: Connection reset by peer)
2023-11-28 22:46:01 +0100kuruczgy(55b66dd3ae@2604:bf00:561:2000::127f) (Read error: Connection reset by peer)
2023-11-28 22:46:01 +0100sus(1b7af6299f@user/zeromomentum) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100theesm(2cbdf4b38a@2604:bf00:561:2000::11c8) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100fvr(ef3e56ca8b@2604:bf00:561:2000::3c4) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100b0o(0e4a0bf4c9@2604:bf00:561:2000::1bf) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100JoelMcCracken(5ea8252fbb@2604:bf00:561:2000::10e3) (Write error: Connection reset by peer)
2023-11-28 22:46:02 +0100akspecs(00cc8321af@sourcehut/user/akspecs) (Write error: Connection reset by peer)
2023-11-28 22:46:02 +0100jkoshy(99b9359beb@user/jkoshy) (Write error: Connection reset by peer)
2023-11-28 22:46:02 +0100arcadewise(52968ed80d@2604:bf00:561:2000::3df) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100ymherklotz(cb2c9cfbdd@2604:bf00:561:2000::29a) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100henrytill(e0180937c3@2604:bf00:561:2000::e8c) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100samhh_(7569f027cf@2604:bf00:561:2000::e4) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100sm2n(ae95cb1267@user/sm2n) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100rselim(ce261f06ff@user/milesrout) (Write error: Connection reset by peer)
2023-11-28 22:46:02 +0100Ankhers(e99e97ef8e@2604:bf00:561:2000::2a2) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100filwisher(2e6936c793@2604:bf00:561:2000::170) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100samhh(7569f027cf@2604:bf00:561:2000::e4) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100jakzale(6291399afa@user/jakzale) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100fn_lumi(3d621153a5@2604:bf00:561:2000::df7) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100eso(a0662dfd5e@2604:bf00:561:2000::1266) (Read error: Connection reset by peer)
2023-11-28 22:46:02 +0100fluffyballoon(45ce440a48@2604:bf00:561:2000::e2) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100probie(cc0b34050a@user/probie) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100ggb(a62ffbaf4f@2604:bf00:561:2000::3ac) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100shreyasminocha(51fdc93eda@user/shreyasminocha) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100chaitlatte0(ea29c0bb16@user/chaitlatte0) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100raghavgururajan(ea769b8000@user/raghavgururajan) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100aniketd(32aa4844cd@2604:bf00:561:2000::dcb) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100bsima1(9d7e39c8ad@2604:bf00:561:2000::dd) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100brettgilio(a35ba67324@2604:bf00:561:2000::260) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100whereiseveryone(206ba86c98@2604:bf00:561:2000::2e4) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100evanrelf(3addc196af@2604:bf00:561:2000::f0) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100jleightcap(7bc4014b62@user/jleightcap) (Read error: Connection reset by peer)
2023-11-28 22:46:03 +0100cpli(77fc530071@2604:bf00:561:2000::252) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100jmcantrell(644f1bed9a@user/jmcantrell) (Write error: Connection reset by peer)
2023-11-28 22:46:03 +0100lukec(9dfd4d094e@2604:bf00:561:2000::10e) (Write error: Connection reset by peer)
2023-11-28 22:46:09 +0100Ram-Z_(Ram-Z@2a01:7e01::f03c:91ff:fe57:d2df) (Ping timeout: 256 seconds)
2023-11-28 22:46:14 +0100samhh(7569f027cf@2604:bf00:561:2000::e4)
2023-11-28 22:46:17 +0100fgaz_(1ff9197ed6@2604:bf00:561:2000::11ea)
2023-11-28 22:46:17 +0100ggb(a62ffbaf4f@2604:bf00:561:2000::3ac)
2023-11-28 22:46:17 +0100bsima1(9d7e39c8ad@2604:bf00:561:2000::dd)
2023-11-28 22:46:17 +0100lukec(9dfd4d094e@2604:bf00:561:2000::10e)
2023-11-28 22:46:18 +0100filwisher(2e6936c793@2604:bf00:561:2000::170)
2023-11-28 22:46:18 +0100raghavgururajan(ea769b8000@user/raghavgururajan)
2023-11-28 22:46:28 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883)
2023-11-28 22:46:32 +0100jkoshy(99b9359beb@user/jkoshy)
2023-11-28 22:46:32 +0100arcadewise(52968ed80d@2604:bf00:561:2000::3df)
2023-11-28 22:46:32 +0100jleightcap(7bc4014b62@user/jleightcap)
2023-11-28 22:46:32 +0100brettgilio(a35ba67324@2604:bf00:561:2000::260)
2023-11-28 22:46:32 +0100fvr(ef3e56ca8b@2604:bf00:561:2000::3c4)
2023-11-28 22:46:36 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2023-11-28 22:46:37 +0100eso(a0662dfd5e@2604:bf00:561:2000::1266)
2023-11-28 22:46:37 +0100sus(1b7af6299f@user/zeromomentum)
2023-11-28 22:46:37 +0100fluffyballoon(45ce440a48@2604:bf00:561:2000::e2)
2023-11-28 22:46:44 +0100kuruczgy(55b66dd3ae@2604:bf00:561:2000::127f)
2023-11-28 22:46:44 +0100theesm(2cbdf4b38a@2604:bf00:561:2000::11c8)
2023-11-28 22:46:44 +0100whereiseveryone(206ba86c98@2604:bf00:561:2000::2e4)
2023-11-28 22:46:50 +0100aniketd(32aa4844cd@2604:bf00:561:2000::dcb)
2023-11-28 22:46:54 +0100fn_lumi(3d621153a5@2604:bf00:561:2000::df7)
2023-11-28 22:46:54 +0100ymherklotz(cb2c9cfbdd@2604:bf00:561:2000::29a)
2023-11-28 22:46:54 +0100probie(cc0b34050a@user/probie)
2023-11-28 22:46:54 +0100henrytill(e0180937c3@2604:bf00:561:2000::e8c)
2023-11-28 22:46:54 +0100shreyasminocha(51fdc93eda@user/shreyasminocha)
2023-11-28 22:46:57 +0100JoelMcCracken(5ea8252fbb@2604:bf00:561:2000::10e3)
2023-11-28 22:46:57 +0100cpli(77fc530071@2604:bf00:561:2000::252)
2023-11-28 22:46:57 +0100chaitlatte0(ea29c0bb16@user/chaitlatte0)
2023-11-28 22:46:57 +0100akspecs(00cc8321af@sourcehut/user/akspecs)
2023-11-28 22:46:58 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-28 22:47:00 +0100jakzale(6291399afa@user/jakzale)
2023-11-28 22:47:00 +0100jmcantrell(644f1bed9a@user/jmcantrell)
2023-11-28 22:47:00 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883) (Read error: Connection reset by peer)
2023-11-28 22:47:00 +0100evanrelf(3addc196af@2604:bf00:561:2000::f0)
2023-11-28 22:47:00 +0100sm2n(ae95cb1267@2604:bf00:561:2000::109)
2023-11-28 22:47:00 +0100rselim(ce261f06ff@2604:bf00:561:2000::257)
2023-11-28 22:47:00 +0100Ankhers(e99e97ef8e@2604:bf00:561:2000::2a2)
2023-11-28 22:47:00 +0100b0o(0e4a0bf4c9@2604:bf00:561:2000::1bf)
2023-11-28 22:47:02 +0100rselim(ce261f06ff@2604:bf00:561:2000::257) (Changing host)
2023-11-28 22:47:02 +0100rselim(ce261f06ff@user/milesrout)
2023-11-28 22:47:02 +0100sm2n(ae95cb1267@2604:bf00:561:2000::109) (Changing host)
2023-11-28 22:47:02 +0100sm2n(ae95cb1267@user/sm2n)
2023-11-28 22:47:38 +0100samhh_(7569f027cf@2604:bf00:561:2000::e4)
2023-11-28 22:48:25 +0100mechap(~mechap@user/mechap)
2023-11-28 22:48:42 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883)
2023-11-28 22:48:49 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-28 22:48:52 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883) (Read error: Connection reset by peer)
2023-11-28 22:49:19 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 240 seconds)
2023-11-28 22:50:04 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 22:50:42 +0100Ram-Z(~Ram-Z@li1814-254.members.linode.com)
2023-11-28 22:50:56 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-11-28 22:51:26 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 22:52:40 +0100iqubic(~avi@2601:602:9502:c70:2d15:c772:1b7d:e5a5)
2023-11-28 22:54:20 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-11-28 22:54:56 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 22:55:53 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2023-11-28 22:56:23 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-11-28 22:58:46 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2023-11-28 22:59:05 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection)
2023-11-28 22:59:19 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883)
2023-11-28 22:59:41 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883) (Read error: Connection reset by peer)
2023-11-28 23:01:11 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-28 23:01:39 +0100jinsun(~jinsun@user/jinsun) (Ping timeout: 260 seconds)
2023-11-28 23:01:48 +0100jinsun_(~jinsun@user/jinsun)
2023-11-28 23:01:48 +0100jinsun_jinsun
2023-11-28 23:08:59 +0100mechap(~mechap@user/mechap) (Quit: WeeChat 4.1.1)
2023-11-28 23:11:52 +0100mechap(~mechap@user/mechap)
2023-11-28 23:12:25 +0100mechap(~mechap@user/mechap) (Client Quit)
2023-11-28 23:12:33 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-28 23:13:01 +0100mechap(~mechap@user/mechap)
2023-11-28 23:15:37 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 255 seconds)
2023-11-28 23:17:03 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 259 seconds)
2023-11-28 23:19:30 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-28 23:22:52 +0100acidjnk(~acidjnk@p200300d6e72b9317058012a22410a419.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-11-28 23:28:00 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883)
2023-11-28 23:28:15 +0100Inst(~Inst@120.244.192.187) (Remote host closed the connection)
2023-11-28 23:30:16 +0100JeremyB99(~JeremyB99@2600:1702:21b0:a500:6581:2a34:dec3:8883) (Read error: Connection reset by peer)
2023-11-28 23:30:31 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-28 23:31:39 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net) (Quit: WeeChat 4.1.1)
2023-11-28 23:32:58 +0100mengu(~mengu@c83-254-18-254.bredband.tele2.se)
2023-11-28 23:40:02 +0100Jackneill(~Jackneill@20014C4E1E120500906E1D747CFD14BF.dsl.pool.telekom.hu) (Ping timeout: 260 seconds)
2023-11-28 23:40:57 +0100shapr(~user@2600:1700:c640:3100:9f9c:9e66:1ec1:188) (Remote host closed the connection)
2023-11-28 23:41:10 +0100shapr(~user@2600:1700:c640:3100:147b:3662:c432:30f1)
2023-11-28 23:41:16 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-11-28 23:41:47 +0100alp_(~alp@2001:861:e3d6:8f80:1124:c998:cd66:bc03)
2023-11-28 23:44:50 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-28 23:47:20 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-28 23:49:11 +0100dolio(~dolio@130.44.134.54)
2023-11-28 23:50:37 +0100dolio(~dolio@130.44.134.54) (Client Quit)
2023-11-28 23:52:15 +0100dolio(~dolio@130.44.134.54)
2023-11-28 23:52:23 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-11-28 23:55:18 +0100ddellacosta(~ddellacos@ool-44c73d16.dyn.optonline.net)
2023-11-28 23:56:06 +0100cyphase(~cyphase@user/cyphase)