2024/09/09

2024-09-09 00:00:13 +0200 <EvanR> xterm unfortunately can't be beaten
2024-09-09 00:00:24 +0200ZharMeny(~ZharMeny@user/ZharMeny)
2024-09-09 00:00:25 +0200 <geekosaur> urxvt 😛
2024-09-09 00:00:38 +0200 <EvanR> urxvt is pretty good now
2024-09-09 00:00:41 +0200ZharMeny(~ZharMeny@user/ZharMeny) (Read error: Connection reset by peer)
2024-09-09 00:00:43 +0200mreh(~matthew@host86-160-168-12.range86-160.btcentralplus.com) (Ping timeout: 264 seconds)
2024-09-09 00:00:45 +0200 <geekosaur> (that said, I actually use mate-terminal because I use mate)
2024-09-09 00:00:57 +0200ZharMeny(~ZharMeny@user/ZharMeny)
2024-09-09 00:01:52 +0200 <juri_> urxvt here too, but i'm looking at doing some ai .... stuff .... and am looking for a terminal emulator to add features to, so...
2024-09-09 00:04:10 +0200 <EvanR> AI in your terminal xD
2024-09-09 00:04:37 +0200 <justsomeguy> There are some experiments in that area, like https://www.warp.dev/
2024-09-09 00:04:38 +0200 <geekosaur> ai yai yai
2024-09-09 00:04:42 +0200 <EvanR> make sure you have wireframe vector graphics support so you can draw an andros-like face
2024-09-09 00:05:10 +0200 <justsomeguy> Personally I would rather have a simple cli utility I can query for things with.
2024-09-09 00:07:05 +0200 <justsomeguy> What does lifting mean? I see it used in different contexts and find it confusing.
2024-09-09 00:08:02 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 00:08:09 +0200 <juri_> I'm doing something a bit different, but.. :D
2024-09-09 00:10:03 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 00:14:57 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 00:15:07 +0200 <EvanR> justsomeguy, have you seen fmap
2024-09-09 00:15:32 +0200 <EvanR> :: Functor f => (a -> b) -> (f a -> f b)
2024-09-09 00:16:03 +0200 <EvanR> it lifts any function to a corresponding function on f-things
2024-09-09 00:16:46 +0200 <EvanR> I've seen it in other contexts to means similar abstract structural moves
2024-09-09 00:17:03 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 00:17:35 +0200 <monochrom> Yes "lift" is an intuitive word, not a rigorous word.
2024-09-09 00:18:44 +0200 <monochrom> where intuition = without evident rational thought and inference. https://www.merriam-webster.com/dictionary/intuition
2024-09-09 00:18:47 +0200 <justsomeguy> So, in (=<<) :: Monad m => (a -> m b) -> m a -> m b, the a -> b is lifted to m a -> m b. What about the m b in (a -> m b?
2024-09-09 00:18:54 +0200 <EvanR> no
2024-09-09 00:19:06 +0200 <EvanR> I wouldn't call that lifting xD
2024-09-09 00:19:16 +0200 <monochrom> That one "lifts" a->mb to ma->mb.
2024-09-09 00:19:39 +0200 <EvanR> it's more like monad function application
2024-09-09 00:19:54 +0200 <monochrom> Or maybe it's demotion? Because contravariant something something?
2024-09-09 00:20:06 +0200 <EvanR> if anything gets actually applied to a function, all the cool words go out the window xD
2024-09-09 00:20:09 +0200 <EvanR> like composition
2024-09-09 00:20:23 +0200 <EvanR> you hear that elixir people!
2024-09-09 00:20:32 +0200 <EvanR> applying is not function composition
2024-09-09 00:21:00 +0200 <monochrom> Heh
2024-09-09 00:21:42 +0200ZharMeny`(~ZharMeny@user/ZharMeny)
2024-09-09 00:21:56 +0200 <EvanR> a "lifted type" is, unrelated it seems, a type with an additional bottom
2024-09-09 00:22:00 +0200 <monochrom> Remember how people look at the equivalent of "f . g $ x" and "f $ g $ x" and be like "so what is the difference between . and $"
2024-09-09 00:22:45 +0200 <EvanR> D:
2024-09-09 00:23:05 +0200 <EvanR> unboxed Int = ... -1 | 0 | 1 | 2 | 3 | ...
2024-09-09 00:23:05 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 00:23:10 +0200 <EvanR> Int = Int | bottom xD
2024-09-09 00:23:16 +0200 <EvanR> Int = unboxed Int | bottom xD
2024-09-09 00:23:24 +0200 <EvanR> lifted
2024-09-09 00:23:44 +0200ZharMeny(~ZharMeny@user/ZharMeny) (Ping timeout: 260 seconds)
2024-09-09 00:24:31 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 00:25:53 +0200 <justsomeguy> Does boxed mean there's a pointer involved, and unboxed mean there isn't?
2024-09-09 00:26:19 +0200 <EvanR> boxed means there's a box, which you access with a pointer
2024-09-09 00:26:27 +0200 <EvanR> you could access an unboxed value with a pointer to, if you want
2024-09-09 00:26:35 +0200 <monochrom> Yes but there is more. boxed is heap-allocated.
2024-09-09 00:27:23 +0200 <EvanR> unboxed values are scattered loose
2024-09-09 00:27:45 +0200 <EvanR> or confusingly, packed into an unboxed array
2024-09-09 00:27:53 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 245 seconds)
2024-09-09 00:28:20 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2024-09-09 00:30:48 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 245 seconds)
2024-09-09 00:32:47 +0200 <monochrom> More confusingly, that array itself is boxed (because heap) but unlifted (because no bottom). >:)
2024-09-09 00:33:11 +0200ZharMeny`ZharMeny
2024-09-09 00:35:16 +0200 <haskellbridge> <thirdofmay18081814goya> anyone got good references about designing applications as a consequence of type-level reasoning?
2024-09-09 00:35:33 +0200 <haskellbridge> <thirdofmay18081814goya> algebra-driven design is about this, no?
2024-09-09 00:38:52 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 00:42:01 +0200 <justsomeguy> thirdofmay: I came across this book but haven't read it yet (it's over my head) https://thinkingwithtypes.com/
2024-09-09 00:42:41 +0200 <haskellbridge> <thirdofmay18081814goya> nice! i'll give it a read, ty
2024-09-09 00:43:59 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 00:45:00 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 00:53:19 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 00:54:39 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 00:54:54 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 00:54:59 +0200peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com)
2024-09-09 00:56:23 +0200 <justsomeguy> I have to admit that even though I like the idea of preventing more errors throught the type system I really dread the thought of working on a complicated code base that does type-level stuff.
2024-09-09 00:57:05 +0200 <haskellbridge> <thirdofmay18081814goya> imo it's less about safety and more about compositionality/modularity of design
2024-09-09 00:57:13 +0200 <haskellbridge> <thirdofmay18081814goya> although safety is nice too
2024-09-09 00:59:17 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-09-09 00:59:38 +0200 <EvanR> business requirements are not well-typed
2024-09-09 00:59:46 +0200Tuplanolla(~Tuplanoll@91-159-69-59.elisa-laajakaista.fi) (Ping timeout: 252 seconds)
2024-09-09 00:59:51 +0200 <justsomeguy> The main issue for me is that it's a huge time investment to understand such a design well enough to contribute to it.
2024-09-09 01:00:14 +0200 <justsomeguy> But I'm also not an experienced programmer, more of a sysadmin, and I'm a little out of my element where Haskell is concerned.
2024-09-09 01:01:07 +0200 <geekosaur> you can get there
2024-09-09 01:01:23 +0200 <geekosaur> <-- ex-sysadmin (retired/disability)
2024-09-09 01:03:14 +0200xff0x(~xff0x@2405:6580:b080:900:c1a4:8f81:9151:7c9c) (Ping timeout: 260 seconds)
2024-09-09 01:05:04 +0200troojg(~troojg@user/troojg)
2024-09-09 01:05:56 +0200xff0x(~xff0x@2405:6580:b080:900:64f3:44bc:1e36:4a59)
2024-09-09 01:08:15 +0200 <monochrom> I don't use type-level design. I use Jackson Structured Design, which is type-driven but actually gets things done cleanly. It takes the view that a [abstract] type is specified by which operations you want it to support, so you ask yourself that question first, and not jump into implementation prematurely.
2024-09-09 01:10:13 +0200 <haskellbridge> <thirdofmay18081814goya> monochrom: https://en.wikipedia.org/wiki/Jackson_structured_programming this?
2024-09-09 01:10:22 +0200 <monochrom> There are some old FP papers actually doing that (without calling it that). For example the Wadler pretty-printing paper. They call it "algebra" instead, because if you have a [abstract] type and a bunch of operations, that's an algebra.
2024-09-09 01:10:26 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 01:13:14 +0200 <justsomeguy> monochrom: This one: https://en.wikipedia.org/wiki/Jackson_structured_programming ?
2024-09-09 01:13:24 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 01:13:30 +0200 <justsomeguy> lol, nevermind, definitely not that one
2024-09-09 01:15:01 +0200sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 248 seconds)
2024-09-09 01:15:09 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 01:15:11 +0200 <monochrom> Or maybe I have a beautified memory of it.
2024-09-09 01:17:06 +0200acidjnk_new(~acidjnk@p200300d6e72cfb75c990977c7caf1962.dip0.t-ipconnect.de) (Ping timeout: 248 seconds)
2024-09-09 01:22:56 +0200morb(~morb@108.41.100.120)
2024-09-09 01:24:58 +0200 <monochrom> Maybe https://en.wikipedia.org/wiki/Jackson_system_development instead. I'll [mis]interpret "identifies the entities in the system, the actions they perform" as what I said above. >:)
2024-09-09 01:26:13 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 01:26:41 +0200peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Quit: peterbecich)
2024-09-09 01:30:28 +0200tstat(~tstat@user/tstat) (Quit: ZNC 1.8.2 - https://znc.in)
2024-09-09 01:31:01 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-09-09 01:31:59 +0200morb(~morb@108.41.100.120) (Ping timeout: 260 seconds)
2024-09-09 01:37:25 +0200justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 248 seconds)
2024-09-09 01:42:01 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 01:47:04 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 01:47:10 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 01:50:24 +0200justsomeguy(~justsomeg@user/justsomeguy)
2024-09-09 01:51:33 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 01:56:48 +0200xff0x(~xff0x@2405:6580:b080:900:64f3:44bc:1e36:4a59) (Ping timeout: 246 seconds)
2024-09-09 01:57:46 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 01:57:57 +0200xff0x(~xff0x@2405:6580:b080:900:5825:9cdb:90f7:52b0)
2024-09-09 02:00:07 +0200xff0x(~xff0x@2405:6580:b080:900:5825:9cdb:90f7:52b0) (Client Quit)
2024-09-09 02:02:03 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 02:05:58 +0200Axman6(~Axman6@user/axman6)
2024-09-09 02:06:39 +0200xff0x(~xff0x@2405:6580:b080:900:55c2:e74c:3e3:5f94)
2024-09-09 02:07:36 +0200 <xacktm> hello, I'm trying to parse an HTML page with xml-conduit by ignoring the HTML <head> boilerplate to get to the <body> data but can't work out how to use the provided ignore* functions to accomplish that - any hints? https://bpa.st/7YMVS
2024-09-09 02:11:58 +0200 <xacktm> oh wait, I got it to compile... wrapped parens around the bit after >> like: (ignoreTree "head" ignoreAttrs) >> (tagIgnoreAttrs "body" $ manyYield parseNode)
2024-09-09 02:12:26 +0200 <xacktm> thanks rubber ducks ^^
2024-09-09 02:13:11 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 02:18:09 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 02:18:32 +0200 <mauke> the parens in (ignoreTree "head" ignoreAttrs) are redundant
2024-09-09 02:20:00 +0200spew(~spew@201.141.99.170) (Ping timeout: 272 seconds)
2024-09-09 02:20:29 +0200 <mauke> the problem is that $ has low precedence, so `a >> b $ c` parses as `(a >> b) $ c`, when you wanted `a >> (b $ c)`
2024-09-09 02:21:44 +0200spew(~spew@201.141.99.170)
2024-09-09 02:22:16 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 02:25:01 +0200ZharMeny(~ZharMeny@user/ZharMeny) (Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.4))
2024-09-09 02:26:33 +0200xff0x(~xff0x@2405:6580:b080:900:55c2:e74c:3e3:5f94) (Ping timeout: 276 seconds)
2024-09-09 02:26:42 +0200 <xacktm> thanks, yes that error did confuse me where to put the parens - I overlooked that $, thinking I could simply chain
2024-09-09 02:27:24 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 252 seconds)
2024-09-09 02:28:59 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 02:30:45 +0200JuanDaugherty(~juan@user/JuanDaugherty)
2024-09-09 02:33:59 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 02:36:55 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 02:38:11 +0200tcard_(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303) (Quit: Leaving)
2024-09-09 02:41:15 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 02:44:46 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 02:49:39 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 02:59:39 +0200Everything(~Everythin@109.162.122.37) (Quit: leaving)
2024-09-09 02:59:44 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 03:00:34 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 03:02:28 +0200peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com)
2024-09-09 03:05:24 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 03:07:01 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 248 seconds)
2024-09-09 03:07:21 +0200auri(~auri@fsf/member/auri) ()
2024-09-09 03:07:46 +0200weary-traveler(~user@user/user363627)
2024-09-09 03:09:36 +0200machinedgod(~machinedg@d50-99-47-73.abhsia.telus.net)
2024-09-09 03:16:21 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 03:21:09 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 03:21:42 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 03:22:31 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 03:24:33 +0200xff0x(~xff0x@om126166210134.28.openmobile.ne.jp)
2024-09-09 03:26:01 +0200 <Axman6> xacktm: ignoreTree "head" ignoreAttrs >> tagIgnoreAttrs "body" (manyYield parseNode) is how I would write that
2024-09-09 03:26:09 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 03:27:05 +0200auri(~auri@fsf/member/auri)
2024-09-09 03:27:39 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 276 seconds)
2024-09-09 03:32:34 +0200troojg(~troojg@user/troojg) (Ping timeout: 260 seconds)
2024-09-09 03:34:42 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 03:38:11 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 03:39:58 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 245 seconds)
2024-09-09 03:40:00 +0200xff0x(~xff0x@om126166210134.28.openmobile.ne.jp) (Read error: Connection reset by peer)
2024-09-09 03:42:51 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 03:44:45 +0200 <xacktm> hm yes, that is a bit clearer
2024-09-09 03:45:02 +0200xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2024-09-09 03:45:54 +0200ACuriousMoose(~ACuriousM@156.34.161.188)
2024-09-09 03:50:28 +0200Guest55(~Guest55@c-71-229-185-228.hsd1.co.comcast.net)
2024-09-09 03:50:42 +0200Guest55(~Guest55@c-71-229-185-228.hsd1.co.comcast.net) (Client Quit)
2024-09-09 03:53:59 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 03:54:39 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 03:59:04 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 252 seconds)
2024-09-09 03:59:24 +0200 <haskellbridge> <Bowuigi> Is there some resource on syntactic experiments for functional languages? I have seen some really interesting ideas (do/codo/arrow notation, indentation-based grouping, etc) but I don't know if there is a central place for them
2024-09-09 03:59:24 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 04:00:56 +0200 <haskellbridge> <Bowuigi> Indentation-based grouping seems interesting for languages that don't have Haskell-style pattern matching, but rather use eliminators and/or first class patterns and/or optics
2024-09-09 04:04:16 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 04:08:44 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 04:09:46 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 04:14:45 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-09-09 04:18:50 +0200comonad1(~comonad@p200300d02705e800d14b563ba919432f.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2024-09-09 04:22:12 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 04:25:34 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 04:27:40 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 252 seconds)
2024-09-09 04:29:27 +0200comonad(~comonad@p200300d02705e800d14b563ba919432f.dip0.t-ipconnect.de)
2024-09-09 04:30:27 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 04:35:58 +0200spew(~spew@201.141.99.170) (Quit: spew)
2024-09-09 04:41:21 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 04:41:55 +0200weary-traveler(~user@user/user363627) (Remote host closed the connection)
2024-09-09 04:41:58 +0200machinedgod(~machinedg@d50-99-47-73.abhsia.telus.net) (Ping timeout: 252 seconds)
2024-09-09 04:42:04 +0200terrorjack4(~terrorjac@static.48.15.202.116.clients.your-server.de) (Quit: The Lounge - https://thelounge.chat)
2024-09-09 04:42:22 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 04:42:30 +0200greenflower(~greenflow@125.16.7.78)
2024-09-09 04:43:43 +0200terrorjack4(~terrorjac@2a01:4f8:c17:dc9f::)
2024-09-09 04:46:12 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 04:48:39 +0200td_(~td@i53870918.versanet.de) (Ping timeout: 246 seconds)
2024-09-09 04:50:43 +0200td_(~td@i5387092B.versanet.de)
2024-09-09 04:57:07 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 05:02:09 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-09-09 05:03:42 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 05:04:54 +0200peterbecich(~Thunderbi@syn-047-229-123-186.res.spectrum.com) (Ping timeout: 260 seconds)
2024-09-09 05:09:18 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 05:14:12 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 05:14:17 +0200 <ski> Bowuigi : "Indentation-based grouping seems interesting for languages that don't have Haskell-style pattern matching, but rather use eliminators and/or first class patterns and/or optics" -- why ? (and "first class patterns" meaning ?)
2024-09-09 05:18:31 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 05:25:05 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 05:28:50 +0200JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2024-09-09 05:29:12 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 276 seconds)
2024-09-09 05:30:24 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 05:30:40 +0200Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2024-09-09 05:35:12 +0200aforemny_(~aforemny@2001:9e8:6cde:3200:4b2a:73ea:fa78:d732)
2024-09-09 05:36:14 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 05:36:21 +0200aforemny(~aforemny@2001:9e8:6cfd:5300:79d5:7cd7:efda:1b62) (Ping timeout: 276 seconds)
2024-09-09 05:40:52 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 05:45:53 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 248 seconds)
2024-09-09 05:48:54 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 05:52:32 +0200sourcetarius(~sourcetar@user/sourcetarius) (Quit: zzz)
2024-09-09 05:52:43 +0200tcard(~tcard@2400:4051:5801:7500:cf17:befc:ff82:5303)
2024-09-09 05:55:51 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 276 seconds)
2024-09-09 06:02:09 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 06:12:26 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 06:19:59 +0200misterfish(~misterfis@84.53.85.146)
2024-09-09 06:20:00 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 06:26:32 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 255 seconds)
2024-09-09 06:31:48 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 06:34:39 +0200arahael_(~arahael@user/arahael)
2024-09-09 06:36:27 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 06:41:30 +0200arahael(~arahael@user/arahael) (Ping timeout: 252 seconds)
2024-09-09 06:47:35 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 06:52:50 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 265 seconds)
2024-09-09 06:54:58 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 06:59:56 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 272 seconds)
2024-09-09 07:00:26 +0200 <haskellbridge> <Bowuigi> "First class patterns" are functions that act like small scale pattern matches (like checking if a constructor tag matches and running an action if it does), they are described in a calculus form in a paper of the same name by B. Jay and D. Kessner
2024-09-09 07:00:37 +0200 <haskellbridge> <Bowuigi> Kesner*
2024-09-09 07:02:22 +0200 <haskellbridge> <Bowuigi> A more modern formulation can be found in "Optimizing First-Class Pattern Matching" by J. Smits, T. Hartman and J. Cockx
2024-09-09 07:02:57 +0200michalz(~michalz@185.246.207.203)
2024-09-09 07:03:20 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 07:04:03 +0200 <haskellbridge> <Bowuigi> As usual, it can be modelled with row types. Pattern matching on the constructor is equivalent to many variant decompositions or to a single variant elimination, pattern matching on fields is equivalent to record patterns, add some combinators and done, reusable patterns
2024-09-09 07:04:54 +0200xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp) (Ping timeout: 260 seconds)
2024-09-09 07:05:36 +0200 <haskellbridge> <Bowuigi> Any kind of first class pattern matching can be eventually optimized to the usual pattern matching so their optimization methods also apply
2024-09-09 07:07:12 +0200 <haskellbridge> <Bowuigi> If with "why" you mean why is it a good idea to use indentation to group expressions on these cases, consider the map function for Church-encoded lists
2024-09-09 07:07:36 +0200arahael_(~arahael@user/arahael) (Ping timeout: 246 seconds)
2024-09-09 07:07:54 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 07:10:22 +0200 <haskellbridge> <Bowuigi> (I hope IRC is fine with multi-line messages)
2024-09-09 07:10:22 +0200 <haskellbridge> ... long message truncated: https://kf8nh.com/_matrix/media/v3/download/kf8nh.com/ZocllxsAxFUSJmQebtytfPyz (3 lines)
2024-09-09 07:10:23 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 07:14:54 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 244 seconds)
2024-09-09 07:16:13 +0200youthlic(~Thunderbi@user/youthlic) (Quit: youthlic)
2024-09-09 07:17:42 +0200youthlic(~Thunderbi@user/youthlic)
2024-09-09 07:18:33 +0200qqe(~qqq@92.43.167.61)
2024-09-09 07:22:47 +0200 <mauke> <+haskellbridge> ... long message truncated: https://kf8nh.com/_matrix/media/v3/download/kf8nh.com/ZocllxsAxFUSJmQebtytfPyz (3 lines
2024-09-09 07:23:58 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 07:24:09 +0200michalz(~michalz@185.246.207.203) (Remote host closed the connection)
2024-09-09 07:25:41 +0200misterfish(~misterfis@84.53.85.146) (Ping timeout: 248 seconds)
2024-09-09 07:26:04 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 07:26:58 +0200xff0x(~xff0x@om126166210134.28.openmobile.ne.jp)
2024-09-09 07:27:01 +0200michalz(~michalz@185.246.207.200)
2024-09-09 07:27:03 +0200arahael(~arahael@user/arahael)
2024-09-09 07:28:15 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 07:28:49 +0200 <haskellbridge> <Bowuigi> Yeah that works too
2024-09-09 07:33:18 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 245 seconds)
2024-09-09 07:34:05 +0200takuan(~takuan@178-116-218-225.access.telenet.be)
2024-09-09 07:36:50 +0200mstksg(~jle`@2603:8001:3b02:84d4:a690:69a1:4e16:510b) (Quit: WeeChat 4.2.2)
2024-09-09 07:39:36 +0200jle`(~jle`@2603:8001:3b02:84d4:1e01:15c4:e899:3d70)
2024-09-09 07:41:22 +0200arahael(~arahael@user/arahael) (Read error: Connection reset by peer)
2024-09-09 07:41:54 +0200jle`(~jle`@2603:8001:3b02:84d4:1e01:15c4:e899:3d70) (Client Quit)
2024-09-09 07:42:43 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds)
2024-09-09 07:43:46 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 07:44:23 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 07:44:44 +0200jle`(~jle`@2603:8001:3b02:84d4:1413:617c:6ead:3f73)
2024-09-09 07:46:16 +0200euleritian(~euleritia@dynamic-176-006-140-223.176.6.pool.telefonica.de)
2024-09-09 07:48:11 +0200acidjnk_new(~acidjnk@p200300d6e72cfb21181cd9b506c11910.dip0.t-ipconnect.de)
2024-09-09 07:48:57 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 276 seconds)
2024-09-09 07:49:20 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 255 seconds)
2024-09-09 07:53:03 +0200CiaoSen(~Jura@2a05:5800:2b2:3500:ca4b:d6ff:fec1:99da)
2024-09-09 08:00:10 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 08:01:00 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 08:05:31 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 264 seconds)
2024-09-09 08:07:33 +0200xff0x(~xff0x@om126166210134.28.openmobile.ne.jp) (Read error: Connection reset by peer)
2024-09-09 08:08:21 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 248 seconds)
2024-09-09 08:11:16 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 08:12:58 +0200xff0x(~xff0x@fsb6a9491c.tkyc517.ap.nuro.jp)
2024-09-09 08:16:06 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 08:20:31 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-09-09 08:23:00 +0200Square2(~Square4@user/square)
2024-09-09 08:26:00 +0200Squared(~Square@user/square) (Ping timeout: 252 seconds)
2024-09-09 08:27:05 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 08:34:24 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2024-09-09 08:36:04 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 08:36:33 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 08:40:17 +0200TMA(tma@twin.jikos.cz) (Ping timeout: 248 seconds)
2024-09-09 08:41:19 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 08:42:00 +0200sord937(~sord937@gateway/tor-sasl/sord937)
2024-09-09 08:42:01 +0200TMA(tma@twin.jikos.cz)
2024-09-09 08:42:21 +0200Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2024-09-09 08:44:58 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 265 seconds)
2024-09-09 08:51:53 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 08:54:43 +0200ft(~ft@p4fc2a393.dip0.t-ipconnect.de) (Quit: leaving)
2024-09-09 08:54:49 +0200machinedgod(~machinedg@d50-99-47-73.abhsia.telus.net)
2024-09-09 08:56:47 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 08:58:52 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 09:02:09 +0200CiaoSen(~Jura@2a05:5800:2b2:3500:ca4b:d6ff:fec1:99da) (Ping timeout: 248 seconds)
2024-09-09 09:04:07 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 252 seconds)
2024-09-09 09:04:39 +0200euleritian(~euleritia@dynamic-176-006-140-223.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-09-09 09:04:57 +0200euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-09-09 09:07:40 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 09:08:20 +0200Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2024-09-09 09:17:20 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 252 seconds)
2024-09-09 09:18:26 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 09:18:56 +0200tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-09-09 09:23:09 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 09:25:18 +0200EarlPitts(~EarlPitts@20014C4C1C6E6700A4006D5FAF3CEF25.catv.pool.telekom.hu)
2024-09-09 09:26:04 +0200talismanick(~user@2601:644:937c:ed10:536b:7670:fffc:851a) (Ping timeout: 260 seconds)
2024-09-09 09:28:05 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 09:34:47 +0200kuribas(~user@ptr-17d51epau2xs89jopnb.18120a2.ip6.access.telenet.be)
2024-09-09 09:36:34 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 09:37:26 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 09:41:05 +0200srazkvt(~sarah@user/srazkvt)
2024-09-09 09:41:27 +0200 <kuribas> I want to participate in munichac with my hasqlator library.
2024-09-09 09:41:48 +0200 <kuribas> Would you say that Applicative/Monoid/Functor are Beginner level, or intermediate level?
2024-09-09 09:42:45 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 248 seconds)
2024-09-09 09:43:34 +0200 <kuribas> What about phantom variables with lifted DataKinds? I have a single type family.
2024-09-09 09:44:54 +0200 <kuribas> The lower level of my library just uses Applicative/Monoid, I'd say that's pretty standard haskell?
2024-09-09 09:47:49 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 09:50:58 +0200sourcetarius(~sourcetar@user/sourcetarius)
2024-09-09 09:52:47 +0200lortabac(~lortabac@2a01:e0a:541:b8f0:55ab:e185:7f81:54a4)
2024-09-09 09:53:04 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 09:53:57 +0200 <Unicorn_Princess> kuribas, i'd say applicative/monoid/functor are intermediate level for non-haskellers, and beginner-level for haskellers
2024-09-09 09:54:40 +0200 <Unicorn_Princess> but then i'm sure there's a mind-bending way of using them that'd make them intermediate/advanced
2024-09-09 09:55:22 +0200 <Unicorn_Princess> in any case the surest way to find out would be to check how older submissions were categorized
2024-09-09 09:55:43 +0200 <dminuoso> kuribas: Depends on how you spin it.
2024-09-09 09:55:57 +0200hgolden_(~hgolden@146.70.173.37) (Ping timeout: 246 seconds)
2024-09-09 09:56:01 +0200 <dminuoso> If you forego the generalization and focus on just `fmap/<*>/<+>` at a specific instance, it's beginner level.
2024-09-09 09:56:04 +0200cfricke(~cfricke@user/cfricke)
2024-09-09 09:56:18 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 09:56:22 +0200hgolden(~hgolden@169.150.203.10)
2024-09-09 09:56:51 +0200 <dminuoso> You can even assist that by providing bindings at those specific types.
2024-09-09 09:57:06 +0200misterfish(~misterfis@87.215.131.102)
2024-09-09 09:57:29 +0200 <dminuoso> Like if we had `thenIO :: IO a -> (a -> IO b) -> IO b`, and `pureIO :: a -> IO a`, I think much of the monad scare would just... not exist.
2024-09-09 09:57:58 +0200 <dminuoso> (In fact, this is even why we have `map`)
2024-09-09 10:00:15 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 10:01:14 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 260 seconds)
2024-09-09 10:01:39 +0200 <kuribas> Unicorn_Princess: I would think people who attend a haskell conference already no so minimum haskell.
2024-09-09 10:01:48 +0200 <kuribas> Including Monads and Applicatives.
2024-09-09 10:02:13 +0200rickbx(~rick@38.42.185.148)
2024-09-09 10:02:36 +0200rickbx(~rick@38.42.185.148) (Remote host closed the connection)
2024-09-09 10:02:41 +0200 <kuribas> dminuoso: right, people working on this would not have to make their own instances, so you could say it's beginner friendly...
2024-09-09 10:02:59 +0200rickbx(~rick@38.42.185.148)
2024-09-09 10:04:29 +0200 <dminuoso> Well this is not necessarily about "making their own instances", but rather using the polymorphic interface can be intimidating for beginners.
2024-09-09 10:04:37 +0200arahael(~arahael@user/arahael)
2024-09-09 10:04:48 +0200 <kuribas> right
2024-09-09 10:05:04 +0200arahael_(~arahael@user/arahael)
2024-09-09 10:05:27 +0200 <dminuoso> The confusion arises because the generalization of these interfaces is only relevant if a) you are writing that interface to begin with, or b) you want to provide some polymorphic library function yourself that uses the former primitive.
2024-09-09 10:06:05 +0200 <dminuoso> But if a user uses `>>=` they see a bizarre looking operator, and an intimiating class name, both of which are mostly irrelevant to the task at hand.
2024-09-09 10:06:05 +0200 <kuribas> Not sure I get your second point...
2024-09-09 10:06:32 +0200 <dminuoso> Well say Im exposing `double :: Functor f -> f Int -> f Int` rather than `double :: [Int] -> [Int]`
2024-09-09 10:06:35 +0200Smiles(uid551636@id-551636.lymington.irccloud.com)
2024-09-09 10:06:35 +0200mreh(~matthew@host86-160-168-12.range86-160.btcentralplus.com)
2024-09-09 10:06:41 +0200 <dminuoso> Or even more confusing
2024-09-09 10:06:52 +0200 <dminuoso> double :: (Num a, Functor f) => f a -> f a
2024-09-09 10:07:00 +0200 <kuribas> Yeah, the applicative operator is hard to grasp, but if composing it is easy, just put <$> first, then <*>
2024-09-09 10:07:13 +0200 <dminuoso> Im saying using it at a particular instance is simnple.
2024-09-09 10:07:17 +0200srazkvt(~sarah@user/srazkvt) (Ping timeout: 248 seconds)
2024-09-09 10:07:39 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 260 seconds)
2024-09-09 10:07:58 +0200 <dminuoso> With some implicit understanding of f `(<*> @IO)` 1 `(<$> IO)` 2
2024-09-09 10:08:01 +0200 <dminuoso> if it were.
2024-09-09 10:08:29 +0200 <kuribas> There is not a lot of polymorphism at the lower level: https://hackage.haskell.org/package/hasqlator-mysql-0.1.0/docs/Database-MySQL-Hasqlator.html
2024-09-09 10:08:32 +0200 <dminuoso> That way you're no longer talking about Applicative, but some particular functions that can attribute clear and explainable behavior to.
2024-09-09 10:09:01 +0200 <kuribas> right, abstraction is difficult.
2024-09-09 10:09:13 +0200__monty__(~toonn@user/toonn)
2024-09-09 10:09:14 +0200 <kuribas> Before you actually understand the things it's abstracting over.
2024-09-09 10:10:41 +0200EarlPitts(~EarlPitts@20014C4C1C6E6700A4006D5FAF3CEF25.catv.pool.telekom.hu) (Remote host closed the connection)
2024-09-09 10:12:01 +0200rickbx(~rick@38.42.185.148) (Ping timeout: 248 seconds)
2024-09-09 10:13:17 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 10:15:22 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net)
2024-09-09 10:16:31 +0200EarlPitts(~EarlPitts@20014C4C1C6E6700A4006D5FAF3CEF25.catv.pool.telekom.hu)
2024-09-09 10:18:43 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 264 seconds)
2024-09-09 10:19:45 +0200morb(~morb@pool-108-41-100-120.nycmny.fios.verizon.net) (Ping timeout: 246 seconds)
2024-09-09 10:20:37 +0200oo_miguel(~Thunderbi@78.10.207.45)
2024-09-09 10:21:27 +0200Guest12(~Guest12@210.115.223.46)
2024-09-09 10:22:35 +0200 <kuribas> I am on a waitlist :( I already bought a busticket and hotel...
2024-09-09 10:24:41 +0200qqe(~qqq@92.43.167.61) (Quit: Lost terminal)
2024-09-09 10:26:35 +0200srazkvt(~sarah@user/srazkvt)
2024-09-09 10:29:04 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl)
2024-09-09 10:35:04 +0200CiaoSen(~Jura@2a05:5800:2b2:3500:ca4b:d6ff:fec1:99da)
2024-09-09 10:35:15 +0200chele(~chele@user/chele)
2024-09-09 10:37:27 +0200EvanR_(~EvanR@user/evanr)
2024-09-09 10:37:47 +0200EvanR(~EvanR@user/evanr) (Read error: Connection reset by peer)
2024-09-09 10:39:42 +0200merijn(~merijn@204-220-045-062.dynamic.caiway.nl) (Ping timeout: 272 seconds)
2024-09-09 10:39:49 +0200Axman6(~Axman6@user/axman6) (Ping timeout: 246 seconds)