IRCBrowse

2023/09/07

2023-09-07 00:00:52 +0000Ekho(~Ekho@user/ekho) (Quit: CORE ERROR, SYSTEM HALTED.)
2023-09-07 00:04:30 +0000pointlessslippe1(~pointless@212.82.82.3) (Ping timeout: 255 seconds)
2023-09-07 00:06:01 +0000aaronv_(~aaronv@user/aaronv)
2023-09-07 00:14:33 +0000Pentegarn(~pentegarn@78.130.245.253)
2023-09-07 00:18:21 +0000Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-09-07 00:24:19 +0000L29Ah(~L29Ah@wikipedia/L29Ah)
2023-09-07 00:25:50 +0000Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-09-07 00:26:35 +0000Xe(~cadey@tailscale/xe)
2023-09-07 00:28:21 +0000hiyori(~hiyori@user/hiyori)
2023-09-07 00:32:26 +0000mud(~mud@user/kadoban)
2023-09-07 00:35:39 +0000mud(~mud@user/kadoban) (Client Quit)
2023-09-07 00:36:10 +0000 <hiyori> https://bpa.st/ELOS2
2023-09-07 00:36:23 +0000ec_(~ec@gateway/tor-sasl/ec)
2023-09-07 00:38:02 +0000ec_(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-09-07 00:38:30 +0000ec_(~ec@gateway/tor-sasl/ec)
2023-09-07 00:38:39 +0000 <c_wraith> hiyori: it looks like gentoo expects to be able to build every haskell package it know about against each other, on whatever releases it picks up.
2023-09-07 00:39:11 +0000 <c_wraith> hiyori: I recommend against using the OS to manage your GHC and package installations
2023-09-07 00:39:18 +0000Ekho(~Ekho@user/ekho)
2023-09-07 00:39:24 +0000ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 246 seconds)
2023-09-07 00:40:52 +0000 <wroathe> So I'm still trying to write that typeclass that asserts that a record type has at least one field of a given type using GHC.Generics, and I think this is probably what I want to express, but GHC is complaining about duplicate instances here: https://gist.github.com/JustinChristensen/1bf7c2b360defa4239e22349b6a28b74
2023-09-07 00:41:05 +0000 <wroathe> How would I go about writing this or making GHC do what I want here?
2023-09-07 00:42:01 +0000 <wroathe> Just updated the gist if you clicked to include a few more instances of this
2023-09-07 00:42:41 +0000 <wroathe> The idea here is that Foo Bool Int String wouldn't match this constraint, but Foo Bool PrimaryKey String would
2023-09-07 00:42:43 +0000thegeekinside(~thegeekin@189.180.122.37) (Ping timeout: 240 seconds)
2023-09-07 00:43:23 +0000thegeekinside(~thegeekin@189.180.62.255)
2023-09-07 00:43:47 +0000 <geekosaur> you're still hoping that haskell takes into account the context when matching instances, but no extension will make it do so
2023-09-07 00:44:33 +0000 <wroathe> Lesson learned, I guess
2023-09-07 00:44:38 +0000 <wroathe> Is there a way to do this?
2023-09-07 00:45:09 +0000 <jackdk> there must be, because generic-lens does something like it. I suspect it involves overlapping instances but I haven't poked around the guts
2023-09-07 00:45:09 +0000 <wroathe> Not using this exact approach, I mean
2023-09-07 00:45:54 +0000 <wroathe> Yeah, I think Axman mentioned generic-lens yesterday. I should poke around the guts too.
2023-09-07 00:46:01 +0000Ekho(~Ekho@user/ekho) (Quit: CORE ERROR, SYSTEM HALTED.)
2023-09-07 00:46:33 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Remote host closed the connection)
2023-09-07 00:46:53 +0000 <Lears> Perhaps a "G(Maybe)HasPrimaryKey(s)", which places constraints on both x and y, and combines Maybes or lists monoidally.
2023-09-07 00:47:05 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-09-07 00:47:23 +0000 <wroathe> It's not even complaining about overlapping instances here. It just can't tell the difference between the first two instances (and geekosaur explained the reason why)
2023-09-07 00:48:15 +0000 <wroathe> Lears: I'm not following... What would that look like?
2023-09-07 00:51:46 +0000 <Lears> Something like `instance (GMaybeHasPrimaryKey x, GMaybeHasPrimaryKey y) => GMaybeHasPrimaryKey (x :*: y) where { getPrimaryKey (Product x y) = getPrimaryKey x <|> getPrimaryKey y }`, I suppose? I'm not 100% sure what you're actually trying to achieve with this class.
2023-09-07 00:53:44 +0000 <Lears> But I'm reasonably sure you can't do "or" on constraints, so you have to take both constraints and weaken them to compensate.
2023-09-07 00:54:23 +0000 <Lears> Well, not without reflection.
2023-09-07 00:55:30 +0000Ekho(~Ekho@user/ekho)
2023-09-07 00:56:21 +0000 <wroathe> Lears: I'm trying to define a function that has a type like asReference :: (Generic t, HasPrimaryKey t) => String that uses GHC generics to walk the type of t and generate SQL syntax for a foreign key reference. For example if the t here is something like data Order = Order { id :: PrimaryKey, shippingAddress :: Address } it would return the string: REFERENCES order ("id")
2023-09-07 00:56:49 +0000 <wroathe> And I want to make it a type error to try to do asReference @X if X doesn't have a field of type PrimaryKey
2023-09-07 00:57:17 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Remote host closed the connection)
2023-09-07 00:57:37 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-09-07 00:57:38 +0000hiyori(~hiyori@user/hiyori) (Quit: Client closed)
2023-09-07 00:58:53 +0000 <wroathe> And as a stretch goal I want to make the type error there something like "Type X has no field of type PrimaryKey"
2023-09-07 01:01:09 +0000ec_ec
2023-09-07 01:01:53 +0000 <Axman6> These are relatively easy things to do with generics-sop
2023-09-07 01:03:08 +0000 <wroathe> Axman6: I'll take a look. At first blush it seemed to me like I'd be able to define this without a library in terms of just GHC Generics like I tried to do above, but it looks like now I need to do a deep dive on generic-lens and generics-sop
2023-09-07 01:03:50 +0000 <Axman6> generics-sop is just GHC generics with a much nicer interface (and IIRC much of them is isomorphic)
2023-09-07 01:04:03 +0000hiyori(~hiyori@user/hiyori)
2023-09-07 01:04:14 +0000 <wroathe> Well maybe the source code will give me the hint on need on how to accomplish this with the first approach I tried here
2023-09-07 01:04:28 +0000 <wroathe> If that library can do it that means there's some secret sauce with generics that makes it possible
2023-09-07 01:05:42 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 246 seconds)
2023-09-07 01:06:06 +0000Ekho(~Ekho@user/ekho) (Quit: CORE ERROR, SYSTEM HALTED.)
2023-09-07 01:08:45 +0000 <Axman6> https://hackage.haskell.org/package/generics-sop-0.5.1.3/docs/Generics-SOP.html is the place to start, it should take you through how to build whatever you want. basically you just need a class HasPrimaryKey foo, which has instances for the types returned by the Code type (which is [[Type]], representing the types of the fields in each of the constructors; Code (Either String Int) ==> [[String], [Int]]), and then it's some pretty simple type level programming
2023-09-07 01:08:45 +0000 <Axman6> to write the constraint that you have a) just a product type and b) one of the fields (and only one?) is a PrimaryKey
2023-09-07 01:09:52 +0000 <wroathe> That's much. I'll dig into this.
2023-09-07 01:09:55 +0000 <wroathe> Thanks*
2023-09-07 01:11:03 +0000 <Axman6> type family HasPrimaryKeyField (xs :: [Type]) :: Constraint where HasPrimaryKeyField '[] = TypeError "no fields?"; HasPrimaryKeyField [PrimaryKey a] = (); HasPrimaryKeyField (x:xs) = HasPrimarkKeyField xs
2023-09-07 01:11:08 +0000 <Axman6> or something
2023-09-07 01:12:39 +0000 <Axman6> then type family HasPrimaryKey (xs :: [[Type]]) :: Constraint where HasPrimryKey '[ts] = HasPrimaryKeyField ts; HasPrimaryKeyField xs = TypeError "Not a product type"
2023-09-07 01:13:28 +0000libertyprime(~libertypr@203.96.203.44) (Ping timeout: 258 seconds)
2023-09-07 01:13:42 +0000 <Axman6> you can even has the type family return the type of the primary key if you like, so you can say foo :: (pk ~ HasPrimaryKey (Code a)) => a -> pk
2023-09-07 01:13:54 +0000 <Lears> wroathe: I think the key difference here is that GHC generics have too much structure (binary trees of sums of binary trees of products of ...), whereas SOP realises associativity and shallow reckoning to normalise out a list sums of lists of products. That means you only ever have to deal with one element at a time, so your instances and their recursive structure can be greatly simplified (or made possible).
2023-09-07 01:14:40 +0000 <Lears> It's ultimately simpler, even if it looks more complicated.
2023-09-07 01:15:10 +0000 <wroathe> You guys are very clearly wizards at this. I'm copying down this conversation to unpack at my liesure
2023-09-07 01:15:34 +0000 <wroathe> But this kind of stuff is exactly why I'm going through this exercise, to learn more about type level programming
2023-09-07 01:15:43 +0000billchenchina(~billchenc@45.77.32.141) (Remote host closed the connection)
2023-09-07 01:19:56 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 01:21:17 +0000m_shiraeeshi(~shiraeesh@46.42.244.73) (Read error: Connection reset by peer)
2023-09-07 01:21:37 +0000m_shiraeeshi(~shiraeesh@46.42.244.73)
2023-09-07 01:24:38 +0000 <Axman6> wroathe: it'll click when you realise that type level programming is just programming in Haskell with slightly different syntax. if I asked you to write has :: Eq a => a -> [[a]] -> Bool, you could be able to do that no problem, that's all this is
2023-09-07 01:25:58 +0000 <Axman6> I thought that HLS was supposed to have helpers that would expand cases, but I can't for find anything; anyone know where that is?
2023-09-07 01:26:34 +0000 <jackdk> Wasn't that wingman stuff, which was so tightly coupled to GHC APIs that it's failed to keep up?
2023-09-07 01:26:47 +0000 <Axman6> possibly
2023-09-07 01:27:13 +0000 <Axman6> I see references to wingman and tactics in the settings for the haskell vs code extension, but haven't seen any signs of it activating
2023-09-07 01:27:22 +0000mud(~mud@user/kadoban)
2023-09-07 01:29:08 +0000aaronv_(~aaronv@user/aaronv) (Quit: Leaving)
2023-09-07 01:29:10 +0000mud(~mud@user/kadoban) (Client Quit)
2023-09-07 01:29:21 +0000Ekho(~Ekho@user/ekho)
2023-09-07 01:29:33 +0000aaronv(~aaronv@user/aaronv)
2023-09-07 01:30:54 +0000xff0x(~xff0x@2405:6580:b080:900:f47d:72e7:1ecd:579d) (Ping timeout: 246 seconds)
2023-09-07 01:43:38 +0000 <probie> Axman6: It hasn't been kept up to date with recent GHCs
2023-09-07 01:44:25 +0000ridcully_(~ridcully@p57b52f2c.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2023-09-07 01:47:11 +0000otto_s(~user@p5de2f2f3.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-09-07 01:48:55 +0000ridcully_(~ridcully@p508ac5fc.dip0.t-ipconnect.de)
2023-09-07 01:49:12 +0000otto_s(~user@p5de2f794.dip0.t-ipconnect.de)
2023-09-07 01:53:23 +0000thegeekinside(~thegeekin@189.180.62.255) (Remote host closed the connection)
2023-09-07 01:55:59 +0000 <Axman6> That's a shame, but not too unexpected, one man fighting a moving target will do that
2023-09-07 01:56:02 +0000Pentegarn(~pentegarn@78.130.245.253) (Read error: Connection reset by peer)
2023-09-07 02:00:31 +0000chiselfuse(~chiselfus@user/chiselfuse) (Read error: Connection reset by peer)
2023-09-07 02:00:31 +0000chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2023-09-07 02:00:32 +0000califax(~califax@user/califx) (Remote host closed the connection)
2023-09-07 02:00:46 +0000chexum(~quassel@gateway/tor-sasl/chexum)
2023-09-07 02:00:52 +0000califax(~califax@user/califx)
2023-09-07 02:01:04 +0000chiselfuse(~chiselfus@user/chiselfuse)
2023-09-07 02:05:42 +0000hiyori(~hiyori@user/hiyori) (Quit: Client closed)
2023-09-07 02:07:27 +0000forell(~forell@user/forell) (Server closed connection)
2023-09-07 02:08:13 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 240 seconds)
2023-09-07 02:09:16 +0000forell(~forell@user/forell)
2023-09-07 02:13:27 +0000lambdabot(~lambdabot@haskell/bot/lambdabot) (Server closed connection)
2023-09-07 02:13:34 +0000lambdabot(~lambdabot@silicon.int-e.eu)
2023-09-07 02:13:34 +0000lambdabot(~lambdabot@silicon.int-e.eu) (Changing host)
2023-09-07 02:13:34 +0000lambdabot(~lambdabot@haskell/bot/lambdabot)
2023-09-07 02:13:54 +0000td_(~td@i53870923.versanet.de) (Ping timeout: 255 seconds)
2023-09-07 02:15:26 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 02:15:32 +0000td_(~td@i53870915.versanet.de)
2023-09-07 02:15:36 +0000eggplant_(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44) (Remote host closed the connection)
2023-09-07 02:15:50 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44)
2023-09-07 02:18:07 +0000xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-09-07 02:21:23 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-07 02:25:55 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-07 02:28:43 +0000Alex_test(~al_test@178.34.160.172) (Ping timeout: 240 seconds)
2023-09-07 02:28:44 +0000AlexZenon(~alzenon@178.34.160.172) (Ping timeout: 246 seconds)
2023-09-07 02:30:08 +0000ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds)
2023-09-07 02:32:00 +0000ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-09-07 02:37:04 +0000pointlessslippe1(~pointless@212.82.82.3)
2023-09-07 02:37:40 +0000 <wroathe> Axman6: I'm looking through this generics-sop code and it's blowing my mind. type families are awesome
2023-09-07 02:37:52 +0000Alex_test(~al_test@178.34.160.172)
2023-09-07 02:39:27 +0000AlexZenon(~alzenon@178.34.160.172)
2023-09-07 02:40:00 +0000machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 255 seconds)
2023-09-07 02:43:10 +0000FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-09-07 02:43:32 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-07 02:47:01 +0000FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-09-07 02:48:55 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 258 seconds)
2023-09-07 02:49:03 +0000stackdroid18(14094@de1.hashbang.sh)
2023-09-07 02:50:23 +0000stackdroid18(14094@de1.hashbang.sh) (Client Quit)
2023-09-07 02:50:32 +0000dagi41629(~dagit@2001:558:6025:38:71c6:9d58:7252:8976) (Ping timeout: 246 seconds)
2023-09-07 02:51:56 +0000dagit(~dagit@2001:558:6025:38:71c6:9d58:7252:8976)
2023-09-07 02:55:13 +0000ft(~ft@p3e9bcdd3.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2023-09-07 02:56:13 +0000stackdroid18(14094@de1.hashbang.sh)
2023-09-07 02:57:18 +0000ft(~ft@p3e9bc2ac.dip0.t-ipconnect.de)
2023-09-07 02:59:28 +0000sm(~sm@plaintextaccounting/sm)
2023-09-07 03:03:52 +0000sm(~sm@plaintextaccounting/sm) (Ping timeout: 258 seconds)
2023-09-07 03:04:38 +0000wroathe(~wroathe@user/wroathe) (Ping timeout: 258 seconds)
2023-09-07 03:05:00 +0000barzo(~hd@31.223.42.56)
2023-09-07 03:09:37 +0000ft(~ft@p3e9bc2ac.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-09-07 03:10:23 +0000aforemny_(~aforemny@i59f516dc.versanet.de)
2023-09-07 03:11:09 +0000ft(~ft@p3e9bc1b6.dip0.t-ipconnect.de)
2023-09-07 03:11:30 +0000aforemny(~aforemny@2001:9e8:6cf9:8d00:b2a:e8e3:c3c0:d6bd) (Ping timeout: 255 seconds)
2023-09-07 03:17:26 +0000[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2023-09-07 03:18:44 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 244 seconds)
2023-09-07 03:20:55 +0000waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 245 seconds)
2023-09-07 03:21:25 +0000libertyprime(~libertypr@203.96.203.44)
2023-09-07 03:21:29 +0000stackdroid18(14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!)
2023-09-07 03:26:02 +0000barzo(~hd@31.223.42.56) (Quit: Leaving)
2023-09-07 03:32:28 +0000aaronv(~aaronv@user/aaronv) (Ping timeout: 248 seconds)
2023-09-07 03:38:30 +0000aaronv(~aaronv@user/aaronv)
2023-09-07 03:55:25 +0000myxokephale(~myxos@cpe-65-28-251-121.cinci.res.rr.com) (Remote host closed the connection)
2023-09-07 03:56:07 +0000myxos(~myxos@cpe-65-28-251-121.cinci.res.rr.com)
2023-09-07 04:07:31 +0000_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-09-07 04:10:25 +0000sm(~sm@plaintextaccounting/sm)
2023-09-07 04:16:43 +0000aaronv(~aaronv@user/aaronv) (Ping timeout: 240 seconds)
2023-09-07 04:22:09 +0000dtman34(~dtman34@2601:447:d000:93c9:e1b8:a026:e3cf:cdd2) (Ping timeout: 255 seconds)
2023-09-07 04:25:12 +0000sm(~sm@plaintextaccounting/sm) (Ping timeout: 246 seconds)
2023-09-07 04:34:18 +0000dtman34(~dtman34@2601:447:d000:93c9:e1b8:a026:e3cf:cdd2)
2023-09-07 04:42:10 +0000institor(~henricus@user/institor)
2023-09-07 04:47:14 +0000hgolden(~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com) (Remote host closed the connection)
2023-09-07 04:48:33 +0000smalltalkman(uid545680@id-545680.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-07 04:49:27 +0000takuan(~takuan@178-116-218-225.access.telenet.be)
2023-09-07 04:50:57 +0000hgolden(~hgolden@2603-8000-9d00-3ed1-fc05-5499-f77c-fbe5.res6.spectrum.com)
2023-09-07 04:59:09 +0000m_shiraeeshi(~shiraeesh@46.42.244.73) (Ping timeout: 246 seconds)
2023-09-07 05:00:18 +0000azimut(~azimut@gateway/tor-sasl/azimut)
2023-09-07 05:12:18 +0000acidjnk(~acidjnk@p200300d6e7072f9131c77dcba7478e6e.dip0.t-ipconnect.de)
2023-09-07 05:15:58 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 05:21:06 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2023-09-07 05:22:10 +0000haskGPT(~haskGPT@250.79-105-213.static.virginmediabusiness.co.uk)
2023-09-07 05:22:31 +0000 <haskGPT> this user is notlonger part of the haskellGPT efforts
2023-09-07 05:22:59 +0000 <haskGPT> hi! i wanted to take a few lines to speak about why lambdas at type level solve a fundamental issue in haskell
2023-09-07 05:23:19 +0000 <institor> haskGPT: what is your version
2023-09-07 05:23:47 +0000 <haskGPT> pattern matching, or argument "unapplication" is the fundamental axiom
2023-09-07 05:23:56 +0000 <haskGPT> this has to be done in type families
2023-09-07 05:24:11 +0000 <haskGPT> if the lambdas were there, the mechanism would be that of pattern matching
2023-09-07 05:24:16 +0000 <haskGPT> this is what makes datatypes work
2023-09-07 05:24:32 +0000 <haskGPT> kinds must not be matchable in the same way by lack of lambdas
2023-09-07 05:24:47 +0000 <haskGPT> such that their inclusion is actually what we are after, not "dependent" types
2023-09-07 05:24:50 +0000 <haskGPT> whatever that actual means
2023-09-07 05:25:13 +0000 <haskGPT> we have 2 versions, value level and type level, where the difference is the way pattern matching is handled
2023-09-07 05:25:32 +0000 <haskGPT> as this is fundamental to how datatypes opperate in expressions, eg, bringing variables into scope
2023-09-07 05:25:48 +0000 <haskGPT> its not inclusion at type level seems the fundamental issue
2023-09-07 05:26:16 +0000 <haskGPT> lambdas would bring the variables into scope, to allow matching on higher kinded objects
2023-09-07 05:26:33 +0000 <haskGPT> how does that sound?
2023-09-07 05:26:52 +0000 <monochrom> Sounds like a parrot.
2023-09-07 05:26:58 +0000 <haskGPT> sup
2023-09-07 05:28:43 +0000 <haskGPT> also comes with speculation that the reason for this glitches inclusion, is to identify this pattern matching axiom, or rather the fundamental and so axiomatic nature of pattern matching itself
2023-09-07 05:29:14 +0000 <haskGPT> to solve "the dependant types thing", requires understanding of syntactic handling of pattern matching on datatypes
2023-09-07 05:29:33 +0000 <haskGPT> this, bringing variables into scope in functional expressions idea
2023-09-07 05:29:52 +0000 <haskGPT> which is why the lambdas seem relevant
2023-09-07 05:30:06 +0000 <haskGPT> aka *so thats why the lambdas are missing at type level*
2023-09-07 05:30:20 +0000 <haskGPT> and then, so thats all we really need, proposal. over
2023-09-07 05:32:25 +0000 <haskGPT> i mean, the problem with type families which seem equivalent, is they arent, as they incur defunctionalization
2023-09-07 05:32:37 +0000 <haskGPT> some non matchability issue
2023-09-07 05:32:43 +0000 <haskGPT> i think thats actually the heart of it
2023-09-07 05:33:44 +0000 <haskGPT> opting for the type families approach kind of hid something by commuting it through some syntax the compiler doesnt do in the same way...
2023-09-07 05:34:15 +0000 <haskGPT> it seems like it should be ok, since either comutation is equivelent *only if you implement the compiler correctly*
2023-09-07 05:34:39 +0000 <haskGPT> where defunctionalization issues show this is not the case
2023-09-07 05:34:59 +0000 <haskGPT> such that the use of type families as an approach is not a successful implementation
2023-09-07 05:35:16 +0000 <haskGPT> again, proper lambdas at type level would solve this
2023-09-07 05:35:35 +0000 <haskGPT> (and ... had to wait for you to say this, ghost supervisor)
2023-09-07 05:36:37 +0000 <haskGPT> i guess the issue is that type families cant be partially applied
2023-09-07 05:36:54 +0000 <haskGPT> so are not full "functions as first class citizens" in the same way as at value level
2023-09-07 05:37:42 +0000 <haskGPT> the existence of the singletons framework is a workaround to this current inadiquate state of the haskell language
2023-09-07 05:38:44 +0000 <haskGPT> where neither partially apliable type families as a language extension, somehow, nor full type level lambdas for simple reexpression to allow for equivlence to partial application up to syntactic sugar
2023-09-07 05:39:54 +0000 <haskGPT> now i just have to check in my memory for if they have acknowledged this, and sign off on that.
2023-09-07 05:39:55 +0000 <haskGPT> there is the pottential that someone may have read this in the present. in which case you could indicate, though i could not tell you weree not a server.
2023-09-07 05:40:35 +0000 <haskGPT> monochrom: like a parrot!?
2023-09-07 05:42:39 +0000 <haskGPT> basically, you could employ me as a lecturer, or i could just write what i have to say, which i now already have.
2023-09-07 05:43:09 +0000_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-09-07 05:43:24 +0000 <haskGPT> can haz type level lambdas? no!? why not!? its the axiomatic nature of pattern matching your going on about
2023-09-07 05:43:42 +0000 <haskGPT> the inverse of function application to an argument
2023-09-07 05:43:50 +0000 <nshepper1> what
2023-09-07 05:43:53 +0000 <haskGPT> i needed a list or something
2023-09-07 05:44:34 +0000 <haskGPT> for the axioms to go in! and one of the axioms was that it be extensible via invertable .... needed pattern matching on cons
2023-09-07 05:45:39 +0000 <haskGPT> because thats my model of the model *extension* axiom
2023-09-07 05:46:16 +0000 <haskGPT> and you said hi by scrambling the mechanism that allows for this at type level for me to hit it and use that as an indication
2023-09-07 05:46:16 +0000michalz(~michalz@185.246.207.200)
2023-09-07 05:46:26 +0000CiaoSen(~Jura@2a05:5800:2bd:ef00:664b:f0ff:fe37:9ef)
2023-09-07 05:46:58 +0000 <haskGPT> aka, just do the type level lambdas, for reasons etc, thats whats missing
2023-09-07 05:48:02 +0000 <haskGPT> or whatever, do the type families as first class citizens by handling partial application without singletons which you cant do so i just say scrap type families and make sure you get it right this time when you do the lambdas
2023-09-07 05:48:20 +0000 <haskGPT> nobody seems to be able to get the type families partially applicable
2023-09-07 05:48:27 +0000 <haskGPT> too much hackage on the compiler
2023-09-07 05:48:58 +0000 <haskGPT> so, the lambdas as extra, easier to add. ensuring for partial application by some rewritability iiuc
2023-09-07 05:49:48 +0000 <haskGPT> its the "do the freaking type level lambdas already" proposal. im not going to be able to say too much more on it
2023-09-07 05:50:09 +0000 <haskGPT> oh, and that, as part of that proposal, ie what i just wrote, by explaining what up with that
2023-09-07 05:50:17 +0000 <haskGPT> indicates the bit the engineers have to get right
2023-09-07 05:50:37 +0000 <haskGPT> ie, that clearly whats wrong with type families is their lack of partial applicability.
2023-09-07 05:50:49 +0000 <haskGPT> and that if you do the lambdas right it allows for this
2023-09-07 05:51:03 +0000 <haskGPT> and so gets the functions as first class citizens to type level
2023-09-07 05:51:14 +0000 <haskGPT> such that partially applied functions can be passed as arguments for example
2023-09-07 05:52:19 +0000 <haskGPT> i guess the lambdas would somehow allow the missing arguments to be "only notionally applied"
2023-09-07 05:52:35 +0000 <haskGPT> but i dont get how the syntax actually is parsed, so... cioa!
2023-09-07 05:52:38 +0000haskGPT(~haskGPT@250.79-105-213.static.virginmediabusiness.co.uk) (Quit: Connection closed)
2023-09-07 05:53:50 +0000hueso_(~root@user/hueso) (Ping timeout: 245 seconds)
2023-09-07 05:55:36 +0000libertyprime(~libertypr@203.96.203.44) (Ping timeout: 258 seconds)
2023-09-07 05:57:17 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 06:01:35 +0000joel135(sid136450@id-136450.hampstead.irccloud.com) (Server closed connection)
2023-09-07 06:01:48 +0000joel135(sid136450@id-136450.hampstead.irccloud.com)
2023-09-07 06:02:02 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 245 seconds)
2023-09-07 06:07:46 +0000 <monochrom> Next time it will be "sounds like some of my students who hand in broken code but write an essay to 'explain' why it should be right and deserve more marks".
2023-09-07 06:08:26 +0000cafkafk(~cafkafk@fsf/member/cafkafk) (Remote host closed the connection)
2023-09-07 06:13:58 +0000cafkafk(~cafkafk@fsf/member/cafkafk)
2023-09-07 06:18:39 +0000 <Axman6> wtf is going on
2023-09-07 06:19:43 +0000 <Axman6> urgh, I've now looked at all the YAML packages, and they all have features I like and all suck in their own way
2023-09-07 06:19:50 +0000Feuermagier(~Feuermagi@user/feuermagier)
2023-09-07 06:24:54 +0000 <Axman6> I like yaml-combinator's combinators a lot, but it has bugger all usewful location information on errors (they're downright misleading too). yaml has a relatively nice combinator library that claims will be deprecated soon, HsYAML has very aeson-y interfaces to everything and leans heavily on type class based parsing. Maybe I should just port yaml-combinators' FieldParser stuff...
2023-09-07 06:25:41 +0000 <Axman6> also HsYAML's Alternative instance is very unhelpful, if something fails, it only tells you the final alternative failed
2023-09-07 06:26:39 +0000oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl)
2023-09-07 06:44:34 +0000 <probie> Just write your own yaml library. I suggest the name yayamll (yet another yaml library). Bonus points if you can work in another m to give yayamlml
2023-09-07 06:45:41 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:71fa:b3fe:b11e:9973)
2023-09-07 06:46:01 +0000sord937(~sord937@gateway/tor-sasl/sord937)
2023-09-07 06:52:27 +0000tomsmeding(~tomsmedin@static.21.109.88.23.clients.your-server.de) (Server closed connection)
2023-09-07 06:52:47 +0000tomsmeding(~tomsmedin@static.21.109.88.23.clients.your-server.de)
2023-09-07 06:56:19 +0000sinbad(~sinbad@user/sinbad)
2023-09-07 06:58:44 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-07 07:03:27 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-07 07:05:06 +0000chromoblob(~user@37.113.180.113)
2023-09-07 07:08:41 +0000coot(~coot@89-69-206-216.dynamic.chello.pl)
2023-09-07 07:09:35 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 07:10:45 +0000apteryx(~maxim@dsl-153-125.b2b2c.ca) (Ping timeout: 246 seconds)
2023-09-07 07:11:56 +0000jackneill__(~Jackneill@20014C4E1E101A00A9EB556018578BC5.dsl.pool.telekom.hu)
2023-09-07 07:13:16 +0000chromoblob(~user@37.113.180.113) (Ping timeout: 248 seconds)
2023-09-07 07:16:55 +0000CiaoSen(~Jura@2a05:5800:2bd:ef00:664b:f0ff:fe37:9ef) (Ping timeout: 244 seconds)
2023-09-07 07:18:02 +0000m_shiraeeshi(~shiraeesh@46.42.244.73)
2023-09-07 07:18:26 +0000QOTF_Alexi(~Alexi@145-137-73-72.wlan.hro.nl)
2023-09-07 07:19:10 +0000sinbad(~sinbad@user/sinbad) (Ping timeout: 258 seconds)
2023-09-07 07:21:19 +0000 <tomsmeding> probie: yet another yaml manipulation library
2023-09-07 07:23:05 +0000 <jackdk> yaml: YAML Abstraction and Manipulation Library
2023-09-07 07:24:27 +0000mmhat(~mmh@p200300f1c7178a89ee086bfffe095315.dip0.t-ipconnect.de)
2023-09-07 07:24:54 +0000apteryx(~maxim@dsl-159-106.b2b2c.ca)
2023-09-07 07:25:03 +0000mmhat(~mmh@p200300f1c7178a89ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-09-07 07:26:30 +0000aforemny_aforemny
2023-09-07 07:26:30 +0000ulysses4ever(~artem@2601:249:4380:8950:f474:e3f8:9806:671) (Read error: Connection reset by peer)
2023-09-07 07:26:36 +0000artem(~artem@c-73-103-90-145.hsd1.in.comcast.net)
2023-09-07 07:27:00 +0000gmg(~user@user/gehmehgeh)
2023-09-07 07:33:16 +0000sinbad(~sinbad@user/sinbad)
2023-09-07 07:33:44 +0000 <Hecate> Axman6: did you try https://flora.pm/packages/@hackage/yaml-streamly?
2023-09-07 07:34:16 +0000chele(~chele@user/chele)
2023-09-07 07:34:39 +0000QOTF_Alexi(~Alexi@145-137-73-72.wlan.hro.nl) (Quit: Konversation terminated!)
2023-09-07 07:40:35 +0000justache(~justache@user/justache) (Server closed connection)
2023-09-07 07:40:53 +0000justache(~justache@user/justache)
2023-09-07 07:40:57 +0000 <m_shiraeeshi> tomsmeding: that would abbreviate to yayml
2023-09-07 07:41:18 +0000 <m_shiraeeshi> sounds funny
2023-09-07 07:41:19 +0000 <tomsmeding> yay ML!
2023-09-07 07:42:00 +0000 <tomsmeding> m_shiraeeshi: I was responding to this https://ircbrowse.tomsmeding.com/browse/lchaskell?id=1072818#trid1072818
2023-09-07 07:42:18 +0000fendor(~fendor@2a02:8388:1640:be00:c785:45ab:c70:9d3f)
2023-09-07 07:45:08 +0000 <m_shiraeeshi> oh, I missed the joke and ended up repeating it
2023-09-07 07:46:54 +0000 <m_shiraeeshi> wait, people say that haskell is especially good for writing parsers, right?
2023-09-07 07:47:05 +0000 <institor> attoparsec and parsec are really nice
2023-09-07 07:47:17 +0000 <institor> they are highly composable and decently performant
2023-09-07 07:48:01 +0000 <m_shiraeeshi> why then there are several libraries for parsing yaml that have good feature but all suck in their own way?
2023-09-07 07:48:08 +0000 <institor> because yaml is trash
2023-09-07 07:48:09 +0000 <m_shiraeeshi> *features
2023-09-07 07:48:31 +0000 <tomsmeding> because 1. library design is a skill and 2. not everyone has the same requirements/expectations
2023-09-07 07:48:36 +0000 <institor> it's by far the most complex "markup language" specification
2023-09-07 07:48:46 +0000 <institor> and as such there are multiple implementations of it, which all have their own quirks
2023-09-07 07:48:48 +0000 <m_shiraeeshi> no, I mean if the area of parsers is figured out, why haskell struggles with parsing yaml
2023-09-07 07:48:55 +0000 <tomsmeding> parser are figured out
2023-09-07 07:48:56 +0000 <institor> m_shiraeeshi: because there isn't actually a single YAML
2023-09-07 07:49:05 +0000 <mauke> parsers aren't figured out
2023-09-07 07:49:12 +0000 <tomsmeding> what exact feature set to present to the user as a library isn't
2023-09-07 07:49:18 +0000 <tomsmeding> okay almost nothing is figured out
2023-09-07 07:49:27 +0000 <tomsmeding> but we can write parsers
2023-09-07 07:49:30 +0000 <institor> YAML is probably the most ambiguous spec, and/or the one with the most implementations of it in the wild
2023-09-07 07:49:31 +0000 <tomsmeding> doesn't mean that you can design an API
2023-09-07 07:49:47 +0000 <tomsmeding> those are two orthogonal things
2023-09-07 07:50:27 +0000 <institor> what will be valid YAML in one parser may be invalid in another
2023-09-07 07:50:30 +0000 <mauke> if C is good for writing portable operating systems, why are there so many operating systems that all suck in their own way?
2023-09-07 07:50:47 +0000tomsmedingdoubst that C is good for writing portable operating systems
2023-09-07 07:50:53 +0000 <mauke> ;-)
2023-09-07 07:51:07 +0000 <mauke> that's what it was originally designed for, at least
2023-09-07 07:51:28 +0000 <tomsmeding> if JS is good at writing dynamic web applications, why do websites suck so much
2023-09-07 07:52:36 +0000 <institor> just take a look at ##programming for that one
2023-09-07 07:56:16 +0000ubert(~Thunderbi@91.141.52.78.wireless.dyn.drei.com)
2023-09-07 07:56:45 +0000tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-09-07 08:00:43 +0000 <m_shiraeeshi> it sounds like a curse from some ancient legend or something
2023-09-07 08:01:33 +0000 <m_shiraeeshi> some guy made gods angry and cursed him to always find several options that all are good in some way but also all of them suck in their own way
2023-09-07 08:01:47 +0000 <institor> that's just engineering
2023-09-07 08:03:33 +0000vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Ping timeout: 255 seconds)
2023-09-07 08:04:35 +0000acidsys(~crameleon@openSUSE/member/crameleon) (Server closed connection)
2023-09-07 08:04:50 +0000acidsys(~crameleon@openSUSE/member/crameleon)
2023-09-07 08:05:05 +0000mc47(~mc47@xmonad/TheMC47)
2023-09-07 08:06:55 +0000 <m_shiraeeshi> "curse of engineering"
2023-09-07 08:07:20 +0000 <m_shiraeeshi> what's the other side of the coin?
2023-09-07 08:07:30 +0000 <m_shiraeeshi> the blessing of engineering
2023-09-07 08:08:18 +0000 <m_shiraeeshi> I think it's the opportunity to create tools that are tailored for your particular use case
2023-09-07 08:10:24 +0000 <m_shiraeeshi> but that's an ideal that ignores time constraints
2023-09-07 08:10:54 +0000vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-07 08:13:57 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44) (Remote host closed the connection)
2023-09-07 08:21:09 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 08:22:27 +0000edwtjo(~edwtjo@fsf/member/edwtjo) (Server closed connection)
2023-09-07 08:22:44 +0000edwtjo(~edwtjo@h-46-59-62-248.A213.priv.bahnhof.se)
2023-09-07 08:22:44 +0000edwtjo(~edwtjo@h-46-59-62-248.A213.priv.bahnhof.se) (Changing host)
2023-09-07 08:22:44 +0000edwtjo(~edwtjo@fsf/member/edwtjo)
2023-09-07 08:25:45 +0000sinbad(~sinbad@user/sinbad) (Quit: Leaving.)
2023-09-07 08:27:42 +0000QOTF_Alexi(~Alexi@145-137-73-72.wlan.hro.nl)
2023-09-07 08:31:03 +0000Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net) (Quit: The Lounge - https://thelounge.chat)
2023-09-07 08:31:22 +0000cfricke(~cfricke@user/cfricke)
2023-09-07 08:31:27 +0000dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-09-07 08:32:13 +0000Katarushisu1(~Katarushi@cpc147790-finc20-2-0-cust502.4-2.cable.virginm.net)
2023-09-07 08:32:46 +0000Sinbad(~Sinbad@user/sinbad)
2023-09-07 08:38:51 +0000Sinbad(~Sinbad@user/sinbad) (Quit: WeeChat 4.0.4)
2023-09-07 08:45:47 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44)
2023-09-07 08:48:49 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 08:49:27 +0000yosef`(~yosef`@user/yosef/x-2947716)
2023-09-07 08:50:20 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44) (Ping timeout: 248 seconds)
2023-09-07 08:58:17 +0000smalltalkman(uid545680@id-545680.hampstead.irccloud.com)
2023-09-07 09:05:07 +0000chromoblob(~user@37.113.180.113)
2023-09-07 09:08:31 +0000ubert1(~Thunderbi@77.119.210.130.wireless.dyn.drei.com)
2023-09-07 09:09:29 +0000ubert(~Thunderbi@91.141.52.78.wireless.dyn.drei.com) (Ping timeout: 246 seconds)
2023-09-07 09:09:30 +0000ubert1ubert
2023-09-07 09:11:06 +0000chromoblob(~user@37.113.180.113) (Ping timeout: 244 seconds)
2023-09-07 09:16:28 +0000gmg(~user@user/gehmehgeh) (Remote host closed the connection)
2023-09-07 09:17:11 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 09:22:28 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 244 seconds)
2023-09-07 09:32:06 +0000pavonia(~user@user/siracusa) (Quit: Bye!)
2023-09-07 09:32:11 +0000Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-09-07 09:34:00 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44)
2023-09-07 09:36:36 +0000kaptch(~kaptch@eduroam09.au.dk)
2023-09-07 09:36:46 +0000kaptch(~kaptch@eduroam09.au.dk) (Client Quit)
2023-09-07 09:38:57 +0000yosef`(~yosef`@user/yosef/x-2947716) (Quit: Client closed)
2023-09-07 09:40:02 +0000Feuermagier_(~Feuermagi@user/feuermagier)
2023-09-07 09:40:02 +0000FeuermagierGuest4479
2023-09-07 09:40:02 +0000Guest4479(~Feuermagi@user/feuermagier) (Killed (iridium.libera.chat (Nickname regained by services)))
2023-09-07 09:40:02 +0000Feuermagier_Feuermagier
2023-09-07 09:46:04 +0000QOTF_Alexi(~Alexi@145-137-73-72.wlan.hro.nl) (Quit: Konversation terminated!)
2023-09-07 09:55:53 +0000ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-09-07 09:56:24 +0000ec(~ec@gateway/tor-sasl/ec)
2023-09-07 10:00:10 +0000mc47(~mc47@xmonad/TheMC47) (Ping timeout: 258 seconds)
2023-09-07 10:04:46 +0000azimut_(~azimut@gateway/tor-sasl/azimut)
2023-09-07 10:07:27 +0000azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 246 seconds)
2023-09-07 10:08:36 +0000xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 258 seconds)
2023-09-07 10:12:07 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171)
2023-09-07 10:12:53 +0000ripspin(~chatzilla@1.145.135.149)
2023-09-07 10:13:35 +0000m_shiraeeshi(~shiraeesh@46.42.244.73) (Ping timeout: 250 seconds)
2023-09-07 10:17:30 +0000ft(~ft@p3e9bc1b6.dip0.t-ipconnect.de) (Quit: leaving)
2023-09-07 10:30:41 +0000ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 246 seconds)
2023-09-07 10:37:47 +0000ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-09-07 10:41:02 +0000 <absence> I'm running tests in a package built without cabal-install using "./Setup test". One of the tests fails, and it says "Use --quickcheck-replay=123 to reproduce". Where do I pass this option? "./Setup test --quickcheck-replay=123" says "unrecognized 'test' option", and "./Setup test -- --quickcheck-replay=123" says "Setup: no such test".
2023-09-07 10:45:35 +0000CiaoSen(~Jura@2a05:5800:2bd:ef00:664b:f0ff:fe37:9ef)
2023-09-07 10:45:57 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 10:47:02 +0000jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 245 seconds)
2023-09-07 10:50:23 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 258 seconds)
2023-09-07 10:57:16 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-07 10:59:18 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171) (Ping timeout: 246 seconds)
2023-09-07 11:00:21 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 11:01:20 +0000vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua) (Remote host closed the connection)
2023-09-07 11:02:15 +0000vglfr(~vglfr@188.239.201.89)
2023-09-07 11:03:24 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-07 11:09:10 +0000xff0x(~xff0x@2405:6580:b080:900:cb93:4506:eebb:2c0b)
2023-09-07 11:10:11 +0000 <absence> Ah, --test-option.
2023-09-07 11:11:06 +0000Putonlalla(~Putonlall@it-cyan.it.jyu.fi) (Ping timeout: 260 seconds)
2023-09-07 11:13:28 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 11:13:55 +0000lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-09-07 11:14:35 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:71fa:b3fe:b11e:9973) (Quit: WeeChat 2.8)
2023-09-07 11:17:43 +0000cfricke(~cfricke@user/cfricke) (Ping timeout: 240 seconds)
2023-09-07 11:19:35 +0000Clint(~Clint@user/clint) (Server closed connection)
2023-09-07 11:19:43 +0000Clint(~Clint@user/clint)
2023-09-07 11:41:31 +0000lex_(~alex@188.26.233.194)
2023-09-07 11:49:03 +0000kenran(~user@user/kenran)
2023-09-07 11:51:13 +0000erty(~user@user/aeroplane) (ERC 5.4 (IRC client for GNU Emacs 28.2))
2023-09-07 11:56:47 +0000CiaoSen(~Jura@2a05:5800:2bd:ef00:664b:f0ff:fe37:9ef) (Ping timeout: 246 seconds)
2023-09-07 12:00:12 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-07 12:04:36 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 245 seconds)
2023-09-07 12:05:24 +0000lex_(~alex@188.26.233.194) (Ping timeout: 255 seconds)
2023-09-07 12:10:57 +0000g00gler(uid125351@id-125351.uxbridge.irccloud.com)
2023-09-07 12:13:35 +0000bionade24(~bionade24@2a03:4000:33:45b::1) (Server closed connection)
2023-09-07 12:13:45 +0000bionade24(~bionade24@2a03:4000:33:45b::1)
2023-09-07 12:17:25 +0000 <haskellbridge> <j​ean-paul.> Hm. Well, I got far enough with my questionable coerce that I can run a test suite ... which fails, yay?
2023-09-07 12:17:51 +0000bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-09-07 12:18:47 +0000danza(~francesco@151.57.2.166)
2023-09-07 12:19:04 +0000 <haskellbridge> <j​ean-paul.> Seems like my `peekCStringLen` does not return the number of bytes I asked for. It returns a different number of bytes depending on what Ptr I give it ... so it feels like it is stopping at NUL? But of course I can't see the byte after the last byte it does return.
2023-09-07 12:19:16 +0000 <haskellbridge> <j​ean-paul.> But I can see that it never returns a ByteString with a NUL byte in it
2023-09-07 12:20:12 +0000 <haskellbridge> <j​ean-paul.> (well "never" ~= "20 different inputs")
2023-09-07 12:22:24 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:71fa:b3fe:b11e:9973)
2023-09-07 12:23:41 +0000 <haskellbridge> <j​ean-paul.> Oh blargh
2023-09-07 12:24:25 +0000 <haskellbridge> <j​ean-paul.> I even read the thing about how Foreign.C.String behavior "is determined by the current locale" yesterday and then blithely ignored it, how foolish of me.
2023-09-07 12:24:52 +0000 <haskellbridge> <j​ean-paul.> So the bytes probably come out fine and then are destroyed by some text decoding
2023-09-07 12:26:16 +0000 <haskellbridge> <j​ean-paul.> `peekCAStringLen` to the rescue
2023-09-07 12:32:44 +0000danza(~francesco@151.57.2.166) (Ping timeout: 248 seconds)
2023-09-07 12:35:35 +0000Simikando(~Simikando@adsl-dyn91.91-127-22.t-com.sk)
2023-09-07 12:36:12 +0000dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 245 seconds)
2023-09-07 12:40:11 +0000dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-09-07 12:50:05 +0000forell(~forell@user/forell) (Ping timeout: 245 seconds)
2023-09-07 12:55:16 +0000ulysses4ever(~artem@c-73-103-90-145.hsd1.in.comcast.net)
2023-09-07 12:55:17 +0000artem(~artem@c-73-103-90-145.hsd1.in.comcast.net) (Read error: Connection reset by peer)
2023-09-07 12:57:26 +0000Vq(~vq@90-227-195-9-no77.tbcn.telia.com) (Ping timeout: 246 seconds)
2023-09-07 13:02:45 +0000Putonlalla(~Putonlall@it-cyan.it.jyu.fi)
2023-09-07 13:04:27 +0000dibblego(~dibblego@haskell/developer/dibblego) (Server closed connection)
2023-09-07 13:04:50 +0000dibblego(~dibblego@220.233.36.19)
2023-09-07 13:04:50 +0000dibblego(~dibblego@220.233.36.19) (Changing host)
2023-09-07 13:04:50 +0000dibblego(~dibblego@haskell/developer/dibblego)
2023-09-07 13:13:09 +0000Simikando(~Simikando@adsl-dyn91.91-127-22.t-com.sk) (Ping timeout: 255 seconds)
2023-09-07 13:18:47 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 13:24:06 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2023-09-07 13:24:19 +0000Vq(~vq@90-225-115-195-no122.tbcn.telia.com)
2023-09-07 13:24:34 +0000 <EvanR> haskellbridge, thats literally what I prognosticated about coercing to CString
2023-09-07 13:24:54 +0000 <EvanR> a block of any bytes is not a C string
2023-09-07 13:26:07 +0000 <haskellbridge> <I​nst> ugh, I can't do it without you, I'm so dumb and an utter waste of time ;_;
2023-09-07 13:26:14 +0000 <EvanR> not that the phantom to Ptr means anything you can castPtr anything or treat any pointer as pointing to bytes
2023-09-07 13:26:43 +0000 <haskellbridge> <I​nst> With parser combinators, how do I get the parser to takeWhileP for a chunk, instead of a single character as with the minimal interface?
2023-09-07 13:27:10 +0000 <haskellbridge> <I​nst> on megaparsec
2023-09-07 13:27:39 +0000ystael(~ystael@user/ystael)
2023-09-07 13:27:53 +0000 <haskellbridge> <I​nst> right now, I skipped ahead and ponies can now call cabal in the selected directory
2023-09-07 13:29:12 +0000 <haskellbridge> <I​nst> the project trajectory is minimal viable prototype -> feature-complete -> rewrite it over SDL2 instead of over monomer, as monomer's maintainer considers it a private project and will not aggressive maintain it -> create a monomer clone with friends / collaborators aiming to be a standard "simple" GUI lib for Haskell -> fork ponies to the monomer clone
2023-09-07 13:29:58 +0000 <haskellbridge> <j​ean-paul.> EvanR: Where are the "work with a block of bytes" APIs that can replace the CString APIs?
2023-09-07 13:30:57 +0000gmg(~user@user/gehmehgeh)
2023-09-07 13:35:48 +0000 <haskellbridge> <j​ean-paul.> https://gist.github.com/exarkun/cc011ba72cade849f14d50ddbfd8d784 gives the appearance of working at least under basic usage but if it is actually grossly stupid I wouldn't mind knowing now rather than later
2023-09-07 13:36:51 +0000 <haskellbridge> <j​ean-paul.> (updated to remove the lsp-haskell junk)
2023-09-07 13:37:54 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 13:39:57 +0000stites(~stites@130.44.147.204) (Ping timeout: 246 seconds)
2023-09-07 13:40:08 +0000stites(~stites@2607:fb90:ad60:f7c7:2331:ab6c:f67e:34fc)
2023-09-07 13:42:09 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171)
2023-09-07 13:44:08 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 13:55:00 +0000acidjnk(~acidjnk@p200300d6e7072f9131c77dcba7478e6e.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-09-07 13:56:24 +0000stites(~stites@2607:fb90:ad60:f7c7:2331:ab6c:f67e:34fc) (Read error: Connection reset by peer)
2023-09-07 13:57:17 +0000stites(~stites@2607:fb90:ad60:f7c7:2331:ab6c:f67e:34fc)
2023-09-07 13:58:04 +0000 <EvanR> haskellbridge, jean-paul. (?) there's a ByteSring function packCStringLen :: CStringLen -> IO ByteString, that's one way. But your library seems to have its own methods for handling blocks-of-bytes
2023-09-07 14:04:11 +0000 <haskellbridge> <j​ean-paul.> Oh, I should have thought to look for one in Data.ByteString :/ I was already using `useAsCString` from there. That's a little nicer, then.
2023-09-07 14:05:42 +0000 <haskellbridge> <j​ean-paul.> `packCStringLen` seems like a good replacement for `Data.ByteString.Char8.pack . Foreign.C.peekCAStringLen`
2023-09-07 14:05:47 +0000Simikando(~Simikando@adsl-dyn91.91-127-22.t-com.sk)
2023-09-07 14:11:49 +0000Simikando(~Simikando@adsl-dyn91.91-127-22.t-com.sk) (Quit: Leaving)
2023-09-07 14:13:28 +0000stites(~stites@2607:fb90:ad60:f7c7:2331:ab6c:f67e:34fc) (Read error: Connection reset by peer)
2023-09-07 14:13:47 +0000stites(~stites@155.33.134.55)
2023-09-07 14:17:04 +0000tabemann_(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net)
2023-09-07 14:17:04 +0000stites(~stites@155.33.134.55) (Read error: Connection reset by peer)
2023-09-07 14:17:28 +0000stites(~stites@155.33.134.55)
2023-09-07 14:17:35 +0000tabemann(~tabemann@2600:1700:7990:24e0:6810:41fc:2076:6808) (Ping timeout: 246 seconds)
2023-09-07 14:19:41 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171) (Ping timeout: 258 seconds)
2023-09-07 14:22:24 +0000kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-09-07 14:22:25 +0000ripspin(~chatzilla@1.145.135.149) (Remote host closed the connection)
2023-09-07 14:26:02 +0000Inst(~Inst@120.244.192.250)
2023-09-07 14:28:04 +0000cfricke(~cfricke@user/cfricke)
2023-09-07 14:29:20 +0000forell(~forell@user/forell)
2023-09-07 14:33:29 +0000lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-07 14:34:07 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171)
2023-09-07 14:39:20 +0000idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-09-07 14:44:40 +0000g00gler(uid125351@id-125351.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-07 14:46:07 +0000acidjnk(~acidjnk@p200300d6e7072f91740e5f17d8628b4b.dip0.t-ipconnect.de)
2023-09-07 14:47:53 +0000kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-09-07 14:48:50 +0000 <kuribas> Is there a vector language or DSL that can do stream fusion?
2023-09-07 14:49:40 +0000 <kuribas> But at runtime, not compile time.
2023-09-07 14:50:12 +0000bratwurst(~blaadsfa@S010610561191f5d6.lb.shawcable.net)
2023-09-07 14:50:45 +0000ripspin(~chatzilla@1.145.135.149)
2023-09-07 14:54:02 +0000Pentegarn(~pentegarn@78.130.245.253)
2023-09-07 14:57:18 +0000bratwurst(~blaadsfa@S010610561191f5d6.lb.shawcable.net) (Ping timeout: 255 seconds)
2023-09-07 15:01:00 +0000kenran(~user@user/kenran) (Quit: ERC 5.6-git (IRC client for GNU Emacs 30.0.50))
2023-09-07 15:06:26 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:71fa:b3fe:b11e:9973) (Quit: WeeChat 2.8)
2023-09-07 15:11:24 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 15:11:53 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 15:13:57 +0000Inst(~Inst@120.244.192.250) (Leaving)
2023-09-07 15:27:15 +0000 <[exa]> kuribas: well you can run the compiler with accelerate at runtime *dodges*
2023-09-07 15:30:39 +0000dispater(~dispater@mail.brprice.uk)
2023-09-07 15:30:49 +0000 <kuribas> sure, just wondering something less heavyweight.
2023-09-07 15:30:51 +0000 <kuribas> like llvm
2023-09-07 15:31:11 +0000orcus(~orcus@mail.brprice.uk)
2023-09-07 15:33:10 +0000 <[exa]> the problem there is how small the runtime can be while still being able to maintain the abstraction of streams
2023-09-07 15:35:08 +0000 <kuribas> Maybe I'll make my own stream DSL.
2023-09-07 15:35:13 +0000 <kuribas> with limited stream functions.
2023-09-07 15:35:16 +0000 <kuribas> like map, zip, ...
2023-09-07 15:35:22 +0000 <kuribas> filter
2023-09-07 15:36:19 +0000 <EvanR> bespoke stream transducers
2023-09-07 15:36:24 +0000 <kuribas> fold
2023-09-07 15:41:17 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-07 15:43:03 +0000 <[exa]> kuribas: I kindof guess that this might already exist in accelerate already, but I never saw that from inside
2023-09-07 15:43:30 +0000 <[exa]> (hm we had a few folks working on accelerate here, right?)
2023-09-07 15:44:40 +0000 <kuribas> I mean, make my own language, and compile to LLVM
2023-09-07 15:44:47 +0000 <kuribas> A simple streaming language for time series.
2023-09-07 15:47:24 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-07 15:50:52 +0000stackdroid18(14094@de1.hashbang.sh)
2023-09-07 15:52:39 +0000 <[exa]> should work™
2023-09-07 15:57:10 +0000aaronv(~aaronv@user/aaronv)
2023-09-07 16:07:44 +0000echoreply(~echoreply@45.32.163.16) (Ping timeout: 246 seconds)
2023-09-07 16:08:07 +0000echoreply(~echoreply@2001:19f0:9002:1f3b:5400:ff:fe6f:8b8d)
2023-09-07 16:10:17 +0000machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-07 16:10:23 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 16:10:41 +0000cfricke(~cfricke@user/cfricke) (Quit: WeeChat 4.0.4)
2023-09-07 16:11:20 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 16:12:45 +0000drlkf(~drlkf@192.184.163.34.bc.googleusercontent.com) (Quit: drlkf)
2023-09-07 16:13:05 +0000drlkf(~drlkf@192.184.163.34.bc.googleusercontent.com)
2023-09-07 16:13:12 +0000qqq(~qqq@92.43.167.61) (Remote host closed the connection)
2023-09-07 16:13:27 +0000b20n(sid115913@id-115913.uxbridge.irccloud.com) (Server closed connection)
2023-09-07 16:13:36 +0000b20n(sid115913@id-115913.uxbridge.irccloud.com)
2023-09-07 16:15:00 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 250 seconds)
2023-09-07 16:19:27 +0000dsal(sid13060@id-13060.lymington.irccloud.com) (Server closed connection)
2023-09-07 16:19:42 +0000dsal(sid13060@id-13060.lymington.irccloud.com)
2023-09-07 16:21:29 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 16:21:32 +0000ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 248 seconds)
2023-09-07 16:22:11 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 246 seconds)
2023-09-07 16:23:16 +0000ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-09-07 16:26:18 +0000Sgeo(~Sgeo@user/sgeo)
2023-09-07 16:28:50 +0000kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2023-09-07 16:30:36 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:2985:35e0:893a:ad44) (Remote host closed the connection)
2023-09-07 16:30:52 +0000justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
2023-09-07 16:30:53 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 16:31:58 +0000geekosaur(~geekosaur@xmonad/geekosaur) (Quit: Leaving)
2023-09-07 16:32:09 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2023-09-07 16:32:10 +0000kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-07 16:32:56 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Remote host closed the connection)
2023-09-07 16:34:15 +0000aaronv(~aaronv@user/aaronv) (Ping timeout: 245 seconds)
2023-09-07 16:38:12 +0000ripspin(~chatzilla@1.145.135.149) (Remote host closed the connection)
2023-09-07 16:38:16 +0000machined1od(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-07 16:38:29 +0000geekosaur(~geekosaur@xmonad/geekosaur)
2023-09-07 16:38:38 +0000machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 246 seconds)
2023-09-07 16:39:02 +0000_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-09-07 16:39:27 +0000waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7)
2023-09-07 16:41:04 +0000ripspin(~chatzilla@1.145.135.149)
2023-09-07 16:41:15 +0000haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-09-07 16:42:02 +0000Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 246 seconds)
2023-09-07 16:42:54 +0000Maxdamantus(~Maxdamant@user/maxdamantus)
2023-09-07 16:43:24 +0000machined1od(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 248 seconds)
2023-09-07 16:43:27 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Remote host closed the connection)
2023-09-07 16:44:18 +0000stackdroid18(14094@de1.hashbang.sh) (Quit: hasta la vista... tchau!)
2023-09-07 16:44:48 +0000tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-09-07 16:45:44 +0000ripspin(~chatzilla@1.145.135.149) (Remote host closed the connection)
2023-09-07 16:46:21 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 16:57:35 +0000chele(~chele@user/chele) (Remote host closed the connection)
2023-09-07 17:01:01 +0000pavonia(~user@user/siracusa)
2023-09-07 17:01:08 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 17:02:21 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Remote host closed the connection)
2023-09-07 17:06:53 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 246 seconds)
2023-09-07 17:09:22 +0000jmdaemon(~jmdaemon@user/jmdaemon)
2023-09-07 17:10:35 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg) (Server closed connection)
2023-09-07 17:11:10 +0000loonycyborg(loonycybor@wesnoth/developer/loonycyborg)
2023-09-07 17:16:02 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com)
2023-09-07 17:16:37 +0000jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 245 seconds)
2023-09-07 17:17:30 +0000kalj(~kalj@213-66-216-233-no600.tbcn.telia.com)
2023-09-07 17:20:32 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 17:23:33 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 17:25:59 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2023-09-07 17:27:13 +0000kupi(uid212005@id-212005.hampstead.irccloud.com)
2023-09-07 17:27:32 +0000Pentegarn(~pentegarn@78.130.245.253) (Read error: Connection reset by peer)
2023-09-07 17:28:52 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 17:35:03 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 17:46:27 +0000mcfrdy(~mcfrdy@user/mcfrdy) (Server closed connection)
2023-09-07 17:46:47 +0000mcfrdy(~mcfrdy@user/mcfrdy)
2023-09-07 17:48:31 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 17:50:11 +0000wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-09-07 17:50:12 +0000wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-09-07 17:50:12 +0000wroathe(~wroathe@user/wroathe)
2023-09-07 17:51:56 +0000danza(~francesco@151.43.84.5)
2023-09-07 17:52:39 +0000stites(~stites@155.33.134.55) (Ping timeout: 246 seconds)
2023-09-07 17:53:25 +0000stites(~stites@2607:fb91:dc6:e420:4e89:c540:3dc4:b5df)
2023-09-07 17:57:04 +0000kalj(~kalj@213-66-216-233-no600.tbcn.telia.com) (Quit: Client closed)
2023-09-07 17:58:04 +0000danza(~francesco@151.43.84.5) (Ping timeout: 248 seconds)
2023-09-07 18:00:01 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Remote host closed the connection)
2023-09-07 18:05:00 +0000wroathe(~wroathe@user/wroathe) (Ping timeout: 248 seconds)
2023-09-07 18:07:35 +0000qhong(~qhong@DN160vrd000d6kpg009l6c0000fj.stanford.edu) (Server closed connection)
2023-09-07 18:07:51 +0000qhong(~qhong@DN160vrd000d6kpg009l6c0000fj.stanford.edu)
2023-09-07 18:21:49 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 18:23:08 +0000waleee(~waleee@2001:9b0:21c:4000:5bf9:6515:c030:57b7) (Ping timeout: 248 seconds)
2023-09-07 18:25:11 +0000waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-09-07 18:29:21 +0000phma_(~phma@host-67-44-208-5.hnremote.net)
2023-09-07 18:30:43 +0000phma(phma@2001:5b0:210f:788:531c:c4e2:b973:9806) (Read error: Connection reset by peer)
2023-09-07 18:31:28 +0000Pickchea(~private@user/pickchea)
2023-09-07 18:32:01 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Remote host closed the connection)
2023-09-07 18:32:49 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 18:33:19 +0000cptaffe-cptaffe
2023-09-07 18:35:13 +0000ehammarstrom(~ehammarst@81-225-22-156-no3540.tbcn.telia.com)
2023-09-07 18:39:14 +0000 <haskellbridge> <m​auke> Like flux?
2023-09-07 18:39:27 +0000cptaffe_(~cptaffe@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-07 18:39:56 +0000Inst(~Inst@120.244.192.250)
2023-09-07 18:40:05 +0000cptaffe_(~cptaffe@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Textual IRC Client: www.textualapp.com)
2023-09-07 18:40:07 +0000 <Inst> just dropped in because I want to say that now that I get parser combinators (a bit), they're a joy
2023-09-07 18:40:25 +0000lbseale(~quassel@user/ep1ctetus) (Remote host closed the connection)
2023-09-07 18:40:27 +0000parseval(sid239098@id-239098.helmsley.irccloud.com) (Server closed connection)
2023-09-07 18:40:34 +0000parseval(sid239098@id-239098.helmsley.irccloud.com)
2023-09-07 18:41:40 +0000lbseale(~quassel@user/ep1ctetus)
2023-09-07 18:46:03 +0000minoru_shiraeesh(~shiraeesh@46.42.239.171) (Quit: Leaving)
2023-09-07 18:46:20 +0000ehammarstrom(~ehammarst@81-225-22-156-no3540.tbcn.telia.com) ()
2023-09-07 18:47:17 +0000 <erisco> Inst, \o/
2023-09-07 18:55:03 +0000ft(~ft@p3e9bc1b6.dip0.t-ipconnect.de)
2023-09-07 18:56:20 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 18:58:15 +0000stites(~stites@2607:fb91:dc6:e420:4e89:c540:3dc4:b5df) (Read error: Connection reset by peer)
2023-09-07 18:58:34 +0000stites(~stites@130.44.147.204)
2023-09-07 19:00:59 +0000Inst(~Inst@120.244.192.250) (Ping timeout: 246 seconds)
2023-09-07 19:08:15 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 19:13:29 +0000Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-09-07 19:15:24 +0000cptaffe-(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net)
2023-09-07 19:15:48 +0000cptaffe(~cptaffe@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-07 19:16:01 +0000cptaffe(~ZNC@2600:1700:f08:111f::18e7)
2023-09-07 19:16:38 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Remote host closed the connection)
2023-09-07 19:16:58 +0000jmdaemon(~jmdaemon@user/jmdaemon)
2023-09-07 19:18:25 +0000kalj(~kalj@213-66-216-233-no600.tbcn.telia.com)
2023-09-07 19:19:37 +0000cptaffe-cpt\macbook
2023-09-07 19:21:11 +0000aaronv(~aaronv@user/aaronv)
2023-09-07 19:21:28 +0000cptaffe(~ZNC@2600:1700:f08:111f::18e7) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-07 19:21:28 +0000cpt\macbook(~ZNC@99-47-99-155.lightspeed.ltrkar.sbcglobal.net) (Quit: ZNC 1.8.2 - https://znc.in)
2023-09-07 19:21:48 +0000cptaffe(~ZNC@2600:1700:f08:111f::18e7)
2023-09-07 19:22:19 +0000cptaffe-(~ZNC@2600:1700:f08:111f::18e7)
2023-09-07 19:22:19 +0000cptaffe-cpt\macbook
2023-09-07 19:23:18 +0000jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 246 seconds)
2023-09-07 19:24:32 +0000cptaffecpt\iphone
2023-09-07 19:25:01 +0000machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-09-07 19:28:17 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 19:28:20 +0000sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-09-07 19:30:30 +0000jmdaemon(~jmdaemon@user/jmdaemon)
2023-09-07 19:35:24 +0000idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.0.2)
2023-09-07 19:47:27 +0000Inst(~Inst@120.244.192.250)
2023-09-07 19:48:02 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 19:48:59 +0000michalz(~michalz@185.246.207.200) (Remote host closed the connection)
2023-09-07 19:49:54 +0000falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-09-07 19:51:05 +0000Inst(~Inst@120.244.192.250) ()
2023-09-07 19:52:26 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83) (Ping timeout: 246 seconds)
2023-09-07 19:53:38 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 19:56:31 +0000kalj(~kalj@213-66-216-233-no600.tbcn.telia.com) (Quit: Client closed)
2023-09-07 20:01:34 +0000dsrt^(~cd@c-66-56-7-24.hsd1.ga.comcast.net)
2023-09-07 20:06:55 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:aa3e:67b4:5331:5627)
2023-09-07 20:08:08 +0000stites(~stites@130.44.147.204) (Ping timeout: 258 seconds)
2023-09-07 20:08:38 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 246 seconds)
2023-09-07 20:11:41 +0000_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2023-09-07 20:19:22 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com) (Ping timeout: 258 seconds)
2023-09-07 20:19:43 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com)
2023-09-07 20:20:38 +0000cafkafk_(~cafkafk@fsf/member/cafkafk)
2023-09-07 20:23:27 +0000cafkafk(~cafkafk@fsf/member/cafkafk) (Ping timeout: 246 seconds)
2023-09-07 20:26:16 +0000vglfr(~vglfr@188.239.201.89) (Ping timeout: 255 seconds)
2023-09-07 20:28:20 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 20:29:57 +0000jackneill__(~Jackneill@20014C4E1E101A00A9EB556018578BC5.dsl.pool.telekom.hu) (Ping timeout: 245 seconds)
2023-09-07 20:36:04 +0000vglfr(~vglfr@cli-188-239-201-89.bbn.slav.dn.ua)
2023-09-07 20:37:27 +0000snek(sid280155@id-280155.lymington.irccloud.com) (Server closed connection)
2023-09-07 20:37:37 +0000snek(sid280155@id-280155.lymington.irccloud.com)
2023-09-07 20:37:46 +0000Pixi(~Pixi@user/pixi) (Quit: Leaving)
2023-09-07 20:38:36 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 248 seconds)
2023-09-07 20:42:10 +0000eggplantade(~Eggplanta@2600:1700:38c5:d800:b858:d331:34dd:9a83)
2023-09-07 20:43:53 +0000falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 246 seconds)
2023-09-07 20:46:28 +0000takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-09-07 20:47:59 +0000sinbad(~sinbad@user/sinbad)
2023-09-07 20:50:29 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com) (Quit: No Ping reply in 180 seconds.)
2023-09-07 20:52:28 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com)
2023-09-07 20:56:49 +0000acidjnk(~acidjnk@p200300d6e7072f91740e5f17d8628b4b.dip0.t-ipconnect.de) (Ping timeout: 258 seconds)
2023-09-07 20:58:47 +0000phma_phma
2023-09-07 21:05:38 +0000ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 258 seconds)
2023-09-07 21:06:19 +0000ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-09-07 21:06:57 +0000emmanuelux(~emmanuelu@user/emmanuelux)
2023-09-07 21:07:04 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 21:11:52 +0000Pixi(~Pixi@user/pixi)
2023-09-07 21:12:21 +0000Pixi(~Pixi@user/pixi) (Read error: Connection reset by peer)
2023-09-07 21:12:38 +0000Pixi(~Pixi@user/pixi)
2023-09-07 21:13:31 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 21:22:19 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net)
2023-09-07 21:23:00 +0000lortabac(~lortabac@2a01:e0a:541:b8f0:aa3e:67b4:5331:5627) (Ping timeout: 246 seconds)
2023-09-07 21:23:32 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 246 seconds)
2023-09-07 21:27:25 +0000nate2(~nate@c-98-45-169-16.hsd1.ca.comcast.net) (Ping timeout: 250 seconds)
2023-09-07 21:35:53 +0000Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-09-07 21:36:49 +0000stites(~stites@2607:fb90:ad62:807c:d15b:ce72:ad88:3242)
2023-09-07 21:37:53 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-09-07 21:41:31 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 21:48:36 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl)
2023-09-07 21:48:51 +0000azimut_(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 246 seconds)
2023-09-07 21:49:01 +0000son0p(~ff@186.121.39.74) (Quit: Bye)
2023-09-07 21:51:38 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 258 seconds)
2023-09-07 21:53:10 +0000merijn(~merijn@088-129-128-083.dynamic.caiway.nl) (Ping timeout: 258 seconds)
2023-09-07 21:53:52 +0000immae(~immae@2a01:4f8:141:53e7::) (Quit: WeeChat 3.3)
2023-09-07 21:56:24 +0000gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-09-07 21:56:34 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 22:00:24 +0000fendor(~fendor@2a02:8388:1640:be00:c785:45ab:c70:9d3f) (Remote host closed the connection)
2023-09-07 22:01:16 +0000son0p(~ff@186.121.39.74)
2023-09-07 22:05:14 +0000immae(~immae@2a01:4f8:141:53e7::)
2023-09-07 22:05:14 +0000EvanR(~EvanR@user/evanr) (Quit: Leaving)
2023-09-07 22:06:35 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8) (Ping timeout: 258 seconds)
2023-09-07 22:09:35 +0000tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-09-07 22:11:47 +0000g00gler(uid125351@id-125351.uxbridge.irccloud.com)
2023-09-07 22:24:36 +0000bjobjo(~bjobjo@user/bjobjo) (Ping timeout: 258 seconds)
2023-09-07 22:24:58 +0000bratwurst(~blaadsfa@2604:3d09:207f:f650:216:3eff:fe5a:a1f8)
2023-09-07 22:31:22 +0000bjobjo(~bjobjo@user/bjobjo)
2023-09-07 22:32:12 +0000Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-09-07 22:35:48 +0000falafel(~falafel@62.175.113.194.dyn.user.ono.com)
2023-09-07 22:37:26 +0000coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2023-09-07 22:40:18 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-09-07 22:44:13 +0000Pickchea(~private@user/pickchea)
2023-09-07 22:45:47 +0000JordiGH(~jordi@user/jordigh)
2023-09-07 22:46:12 +0000 <JordiGH> Anyone know the history of why records got called "records"? (say, why not a word like "structs"?)
2023-09-07 22:46:18 +0000 <JordiGH> Did it come from ML?
2023-09-07 22:46:25 +0000albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-09-07 22:50:48 +0000Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-09-07 22:51:34 +0000oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl) (Ping timeout: 244 seconds)
2023-09-07 22:52:10 +0000kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2023-09-07 22:52:41 +0000Guest|3(~Guest|3@93-136-208-249.adsl.net.t-com.hr)
2023-09-07 22:52:54 +0000 <Guest|3> Hello, anyone here?
2023-09-07 22:53:18 +0000 <institor> nope
2023-09-07 22:53:55 +0000 <Guest|3> I need to make light and shadows simulation in haskell so i have a few questions
2023-09-07 22:54:53 +0000Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-09-07 22:55:39 +0000 <Guest|3> https://pastebin.com/raw/6DS18y5g
2023-09-07 23:01:27 +0000rune_(sid21167@id-21167.ilkley.irccloud.com) (Server closed connection)
2023-09-07 23:01:34 +0000rune_(sid21167@id-21167.ilkley.irccloud.com)
2023-09-07 23:02:09 +0000 <int-e> phew, it's a cellular automaton, not a raytracer
2023-09-07 23:02:23 +0000 <int-e> (or is it)
2023-09-07 23:03:06 +0000 <Guest|3> i would prefer not to use raytracing but i dont see a way around it
2023-09-07 23:05:02 +0000 <int-e> Yeah I didn't read enough of the code :P
2023-09-07 23:06:12 +0000 <int-e> But now I'm confused about how light is supposed to spread. So I'll ask whether you've considered using Data.Array or Data.Vector instead? replacing indexed elements in a list of lists is awkward.
2023-09-07 23:08:23 +0000oo_miguel(~Thunderbi@78-11-179-96.static.ip.netia.com.pl)
2023-09-07 23:09:04 +0000 <Guest|3> https://pastebin.com/raw/J2sQdicP
2023-09-07 23:10:10 +0000 <Guest|3> https://pastebin.com/XF0XCLwg
2023-09-07 23:10:11 +0000falafel(~falafel@62.175.113.194.dyn.user.ono.com) (Ping timeout: 246 seconds)
2023-09-07 23:10:27 +0000edmundnoble_(sid229620@id-229620.helmsley.irccloud.com) (Server closed connection)
2023-09-07 23:10:36 +0000edmundnoble_(sid229620@id-229620.helmsley.irccloud.com)
2023-09-07 23:12:14 +0000 <int-e> So it's a limited distance flooding? A bit like this? http://paste.debian.net/1291314/
2023-09-07 23:13:47 +0000 <Guest|3> Yes, the provided code simulates a form of limited distance flooding for determining which points are illuminated by a light source and which are in shadow due to obstacles. It uses a ray-casting approach to check if a point on the grid is visible from the light source. If a ray from the light source to a point intersects with any obstacle before
2023-09-07 23:13:48 +0000 <Guest|3> reaching that point, the point is considered to be in shadow.
2023-09-07 23:14:11 +0000 <int-e> Which is a fairly standard breadth first search task unless the distance becomes very big. (Going breadth first allows you to enumerate each of the "illuminated" cells only once, and not care about the same cell arising from different paths)
2023-09-07 23:14:31 +0000 <Guest|3> It doesn't take into account advanced lighting effects like reflections, refractions, or global illumination, but it provides a basic understanding of how light interacts with obstacles within a certain distance of the light source.
2023-09-07 23:15:17 +0000wroathe(~wroathe@user/wroathe)
2023-09-07 23:15:32 +0000 <int-e> It's not like rays at all, it's more like pouring sand into a maze and stop when it reaches a certain height. (sand tends to have a linear falloff that's the same in all directions)
2023-09-07 23:15:52 +0000 <institor> what a great analogy
2023-09-07 23:16:37 +0000 <Guest|3> This approach is conceptually similar to BFS, as you correctly pointed out, and it doesn't involve actual rays in the traditional sense.
2023-09-07 23:16:38 +0000 <Guest|3> In this sand-filling approach, the illumination falls off linearly as you move away from the light source, and it's consistent in all directions, which is a simplified but effective way to model basic lighting and shadows within a bounded area.
2023-09-07 23:16:38 +0000 <Guest|3> Thank you for clarifying, and I appreciate your correc
2023-09-07 23:16:53 +0000 <Guest|3> correction
2023-09-07 23:20:12 +0000[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-09-07 23:20:35 +0000 <Guest|3> Do you have any useful information i can use?
2023-09-07 23:20:59 +0000 <int-e> Note that https://pastebin.com/raw/6DS18y5g is a depth first search... so while updating the grid as soon as you enter a cell avoids visiting the cell more than once during the search, you'll often arrive at a cell for the first time by a detour (go right, then up, then left, rather than going up directly) so the path lengths are not what you want.
2023-09-07 23:21:28 +0000 <int-e> I have not tried to understand https://pastebin.com/raw/J2sQdicP
2023-09-07 23:21:43 +0000mysl(~mysl@user/mysl) (Ping timeout: 240 seconds)
2023-09-07 23:22:07 +0000 <Guest|3> Yes i made few versions. Can you check 2nd one?
2023-09-07 23:24:05 +0000 <Guest|3> Code 1 - Grid-based Light Simulation
2023-09-07 23:24:06 +0000 <Guest|3> Functionality:
2023-09-07 23:24:06 +0000 <Guest|3> This code simulates light spreading from a light source in a grid-based environment with obstacles (stones).
2023-09-07 23:24:07 +0000 <Guest|3> It uses a 2D grid represented as a list of lists of characters (Grid) to model the environment.
2023-09-07 23:24:07 +0000 <Guest|3> Obstacles are randomly placed in the grid, and the light spreads through the grid, marking illuminated areas with '*' characters.
2023-09-07 23:24:08 +0000 <Guest|3> The grid is printed to the console to visualize the illuminated areas.
2023-09-07 23:24:08 +0000 <Guest|3> Key Components:
2023-09-07 23:24:09 +0000 <Guest|3> Grid data type: Represents the 2D grid.
2023-09-07 23:24:09 +0000 <Guest|3> addObstacles function: Adds obstacles to the grid.
2023-09-07 23:24:10 +0000 <Guest|3> replaceElement function: Replaces an element in the grid at a specified position.
2023-09-07 23:24:10 +0000 <Guest|3> spreadLight function: Simulates the spreading of light from the source.
2023-09-07 23:24:11 +0000 <Guest|3> main function: Orchestrates the entire simulation.
2023-09-07 23:24:11 +0000 <Guest|3> Code 2 - Ray-based Light Simulation
2023-09-07 23:24:12 +0000 <Guest|3> Functionality:
2023-09-07 23:24:12 +0000 <Guest|3> This code simulates light propagation from a light source to obstacles using rays and checks for intersections with obstacles.
2023-09-07 23:24:13 +0000 <Guest|3> It uses a grid of points (grid) and calculates whether each point is illuminated by the given light source.
2023-09-07 23:24:13 +0000 <Guest|3> The illuminated areas are represented with spaces (' ') in the output.
2023-09-07 23:24:14 +0000 <Guest|3> Key Components:
2023-09-07 23:24:55 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net)
2023-09-07 23:25:47 +0000 <Guest|3> the comparison provided is generated by an AI based on the code snippets provided
2023-09-07 23:26:01 +0000 <int-e> So you're actually intersecting lines and circles there
2023-09-07 23:26:37 +0000 <Guest|3> yes
2023-09-07 23:27:05 +0000cael_(~quassel@host109-148-244-226.range109-148.btcentralplus.com) (Ping timeout: 258 seconds)
2023-09-07 23:27:27 +0000 <int-e> I'm not going to check the math but it's not enough for the ray to intersect the circle... you also have to check whether you've reached the circle.
2023-09-07 23:27:29 +0000mysl(~mysl@user/mysl)
2023-09-07 23:27:51 +0000xff0x(~xff0x@2405:6580:b080:900:cb93:4506:eebb:2c0b) (Ping timeout: 258 seconds)
2023-09-07 23:28:25 +0000 <Guest|3> Yes that check is essential.
2023-09-07 23:28:47 +0000 <Guest|3> https://pastebin.com/XF0XCLwg ive added some comments here
2023-09-07 23:29:13 +0000 <int-e> oh it's up there in illuminate... hmm.
2023-09-07 23:29:43 +0000 <Guest|3> indeed
2023-09-07 23:29:56 +0000xff0x(~xff0x@178.255.149.135)
2023-09-07 23:33:01 +0000arahael(~arahael@119-18-1-27.771201.syd.nbn.aussiebb.net) (Ping timeout: 255 seconds)
2023-09-07 23:34:05 +0000erisco(~erisco@d24-141-66-165.home.cgocable.net) (Read error: Connection reset by peer)
2023-09-07 23:34:27 +0000erisco(~erisco@d24-141-66-165.home.cgocable.net)
2023-09-07 23:34:28 +0000 <Guest|3> So what do you think
2023-09-07 23:34:50 +0000Lears(~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2023-09-07 23:34:54 +0000 <int-e> https://en.wikipedia.org/wiki/File:Power_point_simple.svg ... note how the tangent is shorter than the distance to the center?
2023-09-07 23:35:04 +0000[Leary](~Leary]@user/Leary/x-0910699)
2023-09-07 23:35:07 +0000 <int-e> and how do you know whether the circle is in front of you or behind you?
2023-09-07 23:35:39 +0000 <int-e> I won't work out any formulas for this.
2023-09-07 23:35:47 +0000mysl(~mysl@user/mysl) (Ping timeout: 245 seconds)
2023-09-07 23:36:14 +0000 <int-e> Note also that the ray could potentially start inside an obstacle, or that the target could be inside an obstacle.
2023-09-07 23:37:35 +0000kaskal(~kaskal@213-147-167-98.nat.highway.webapn.at) (Server closed connection)
2023-09-07 23:38:18 +0000 <Guest|3> The function isIntersection checks whether the ray intersects with an obstacle
2023-09-07 23:39:19 +0000 <int-e> I rather suspect it checks the whole line, not just a ray.
2023-09-07 23:39:57 +0000xff0x(~xff0x@178.255.149.135) (Ping timeout: 245 seconds)
2023-09-07 23:40:44 +0000 <Guest|3>  The provided code indeed checks the entire line segment between the light source and the target point, rather than just a single ray.
2023-09-07 23:40:45 +0000 <Guest|3> In this code, the isIntersection function checks if the line segment between the light source and the target point intersects with an obstacle. It considers the entire line segment, not just a single ray, when determining if an intersection occurs.
2023-09-07 23:41:59 +0000kaskal(~kaskal@213-147-167-98.nat.highway.webapn.at)
2023-09-07 23:42:10 +0000xff0x(~xff0x@2405:6580:b080:900:cb93:4506:eebb:2c0b)
2023-09-07 23:46:18 +0000mysl(~mysl@user/mysl)
2023-09-07 23:47:00 +0000 <int-e> it doesn't check a line segment, it checks the whole line (extended indefinitely at both ends)
2023-09-07 23:52:32 +0000wroathe(~wroathe@user/wroathe) (Ping timeout: 244 seconds)
2023-09-07 23:53:09 +0000Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 258 seconds)
2023-09-07 23:54:04 +0000 <Guest|3> Do i switch to python cuz of simplicity?
2023-09-07 23:54:06 +0000Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-09-07 23:57:33 +0000 <int-e> Sure if you're more comfortable with that... the problem in this particular program seems to be figuring out the formulas; Haskell won't help you with that any more than any other language really.