IRCBrowse

2021/10/31

2021-10-31 00:00:50 +0200chomwitt(~chomwitt@ppp-94-68-249-8.home.otenet.gr) (Ping timeout: 260 seconds)
2021-10-31 00:01:23 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-31 00:01:51 +0200 <maerwald> hmm... I want where-clauses that don't have access to the top-level function arguments
2021-10-31 00:02:54 +0200 <geekosaur> foo = \... where ... ? (hm, probably not)
2021-10-31 00:03:33 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 276 seconds)
2021-10-31 00:04:42 +0200 <energizer> is it possible to declare a binary operator to be associative?
2021-10-31 00:06:01 +0200bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-10-31 00:06:49 +0200 <hpc> what would that mean in practice?
2021-10-31 00:10:48 +0200 <energizer> without associativity, i have to choose foldl or foldr. with it, i can just fold without specifying
2021-10-31 00:11:04 +0200 <hololeap> I'm debugging an build error in gentoo's haskell repo for tasty-discover. it's using v1 cabal stuff to build. when --enable-executable-dynamic configure flag is enabled, I get this when the test suite tries to build:
2021-10-31 00:11:09 +0200 <hololeap> tasty-discover: error while loading shared libraries: libHStasty-discover-4.2.2-EJsJ69ECwwY3j0AkVuZwAF-ghc8.10.6.so: cannot open shared object file: No such file or directory
2021-10-31 00:11:20 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 268 seconds)
2021-10-31 00:12:16 +0200Guest27(~Guest27@188.64.207.100) (Ping timeout: 256 seconds)
2021-10-31 00:12:36 +0200 <energizer> oh i think i'm looking for Data.Monoid
2021-10-31 00:14:44 +0200 <hololeap> energizer: more specifically, Semigroup
2021-10-31 00:16:01 +0200 <hololeap> although you do need Monoid if you want to use fold from Data.Foldable (since some foldables can be empty)
2021-10-31 00:16:43 +0200__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-31 00:17:13 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-31 00:18:17 +0200 <energizer> how common is it to use things like Data.Monoid?
2021-10-31 00:18:34 +0200 <davean> Does anyone not use them?
2021-10-31 00:18:43 +0200 <hololeap> extremely common/useful
2021-10-31 00:18:47 +0200 <energizer> cool
2021-10-31 00:19:05 +0200 <davean> if you don't use them you're seriously weird
2021-10-31 00:19:26 +0200 <hpc> ^
2021-10-31 00:20:31 +0200eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 00:22:41 +0200 <hololeap> energizer: it's a good idea to memorize/understand everything in Data.Semigroup/Data.Monoid and use them whenever possible. it will help make your code easier to understand and maintain
2021-10-31 00:25:09 +0200 <hpc> once you understand it, you'll find monoidal structures all over the place
2021-10-31 00:25:12 +0200 <hpc> like Alternative
2021-10-31 00:25:24 +0200 <hpc> and categories
2021-10-31 00:32:21 +0200acidsys(~LSD@2.lsd.systems) (Quit: I love you.)
2021-10-31 00:32:53 +0200acidsys(~LSD@2.lsd.systems)
2021-10-31 00:33:05 +0200 <maerwald> doesn't convey much information though
2021-10-31 00:33:11 +0200 <maerwald> I dislike how optparse-applicative uses it
2021-10-31 00:35:22 +0200MQ-17J(~MQ-17J@8.6.144.203) (Ping timeout: 260 seconds)
2021-10-31 00:38:30 +0200MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-31 00:39:16 +0200jess(~jess@libera/staff/jess) ()
2021-10-31 00:41:02 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi) (Ping timeout: 260 seconds)
2021-10-31 00:46:02 +0200catman(~catman@user/catman)
2021-10-31 00:49:11 +0200peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-31 00:49:49 +0200max22-(~maxime@2a01cb08833598001f901fd4ac72f6bc.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2021-10-31 00:51:32 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Quit: This computer has gone to sleep)
2021-10-31 00:53:08 +0200 <jackdk> energizer: I can't even make it to the kitchen without tripping over a monoid. They're an extremely flexible tool, and a great introduction to the "let's port algebraic structures to typeclasses" that you see a lot of in Haskell
2021-10-31 00:53:56 +0200 <hpc> and just to rub it in, algebras themselves have two embedded monoids :D
2021-10-31 00:54:51 +0200son0p(~ff@181.136.122.143)
2021-10-31 00:54:52 +0200 <jackdk> hpc: do you have a thing I can ready about that? I haven't heard this one
2021-10-31 00:56:03 +0200 <hpc> just wikipedia
2021-10-31 00:57:44 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 00:58:01 +0200 <hpc> an algebra has a ring, and a ring is basically (+), (*), and the distributive property
2021-10-31 00:59:10 +0200acidjnk_new3(~acidjnk@p200300d0c7441135e59462474fdf3062.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-10-31 00:59:26 +0200 <hpc> if you've ever thought that boolean algebra looks a lot like real algebra, they're the same abstract structure
2021-10-31 01:00:02 +0200 <jackdk> Gotcha - I remember rings from undergrad. So what are (+) and (*) for algebras?
2021-10-31 01:01:07 +0200 <hpc> they're me not wanting to type a bunch - https://en.wikipedia.org/wiki/Ring_(mathematics)#Definition is nice and concise
2021-10-31 01:01:38 +0200 <jackdk> yep, and then by "algebra" you mean https://en.wikipedia.org/wiki/Algebra_over_a_field ?
2021-10-31 01:01:42 +0200 <hpc> yep
2021-10-31 01:02:02 +0200 <hpc> that whole algebraic structures sidebar is worth reading
2021-10-31 01:02:02 +0200 <jackdk> ty for the pointer, I'll take a look
2021-10-31 01:05:27 +0200CannibisIndica(~herb@user/mesaboogie) (Ping timeout: 260 seconds)
2021-10-31 01:06:29 +0200 <hpc> if you want a more difficult rabbit hole to jump down after that, try figuring out what real calculus, lambda calculus, relational calculus, and calculus of constructions have in common
2021-10-31 01:07:56 +0200 <hpc> (the answer may or may not be as neat and tidy)
2021-10-31 01:09:50 +0200 <jackdk> stop making me want to quit my day job and go back to uni ;-)
2021-10-31 01:11:49 +0200 <hpc> never!
2021-10-31 01:12:14 +0200dariof4(~dariof4@95.131.44.100) (Quit: WeeChat 3.3)
2021-10-31 01:13:16 +0200Null_A(~null_a@2601:645:8700:2290:19ff:7d99:67c6:79e3)
2021-10-31 01:14:49 +0200lavaman(~lavaman@98.38.249.169)
2021-10-31 01:19:37 +0200son0p(~ff@181.136.122.143) (Remote host closed the connection)
2021-10-31 01:24:22 +0200mmhat(~mmh@55d4bc38.access.ecotel.net) (Quit: WeeChat 3.3)
2021-10-31 01:27:22 +0200lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 01:28:10 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-31 01:28:53 +0200Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Read error: Connection reset by peer)
2021-10-31 01:29:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 01:29:12 +0200wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 01:29:12 +0200wroathe(~wroathe@user/wroathe)
2021-10-31 01:39:23 +0200machinedgod(~machinedg@24.105.81.50) (Ping timeout: 264 seconds)
2021-10-31 01:43:43 +0200xsperry(~xs@user/xsperry) (Read error: Connection reset by peer)
2021-10-31 01:44:12 +0200CannibisIndica(~herb@user/mesaboogie)
2021-10-31 01:44:51 +0200CannibisIndicaCannabisIndica
2021-10-31 01:45:10 +0200Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi) (Quit: Leaving.)
2021-10-31 01:45:41 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-31 01:45:49 +0200lavaman(~lavaman@98.38.249.169)
2021-10-31 01:48:50 +0200 <DigitalKiwi> contains "calculus"
2021-10-31 01:50:37 +0200machinedgod(~machinedg@24.105.81.50)
2021-10-31 01:52:35 +0200waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 264 seconds)
2021-10-31 01:58:37 +0200DNH(~DNH@8.43.122.53) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-31 01:59:54 +0200hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-10-31 02:00:13 +0100xsperry(~xs@user/xsperry)
2021-10-31 02:00:25 +0100hendursaga(~weechat@user/hendursaga)
2021-10-31 02:02:04 +0100 <hololeap> what does it mean when `cabal info` has parenthesis around an available version?
2021-10-31 02:02:24 +0100 <hololeap> hnix ... Versions available: ... 0.14.0.1, 0.14.0.2, (0.15.0)
2021-10-31 02:02:38 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 260 seconds)
2021-10-31 02:03:13 +0100son0p(~ff@181.136.122.143)
2021-10-31 02:04:10 +0100 <geekosaur> marked as deprecated, according to the hackage page
2021-10-31 02:04:29 +0100 <hololeap> why would the latest version be marked as deprecated?
2021-10-31 02:05:31 +0100 <hololeap> I'm not seeing anything about this being deprecated or being a candidate: https://hackage.haskell.org/package/hnix-0.15.0
2021-10-31 02:05:45 +0100 <geekosaur> unclear. but I note that hackage's annotations conflate "deprecated" and "one version not preferred"
2021-10-31 02:05:53 +0100 <geekosaur> https://hackage.haskell.org/package/hnix/preferred
2021-10-31 02:06:41 +0100 <hololeap> hm, ok
2021-10-31 02:09:18 +0100 <geekosaur> so what it may actually mean is not so mucheprecated" as "don't rely on this yet", but because of the way hackage conflates those it reports it as deprecated
2021-10-31 02:10:01 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 02:12:24 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2021-10-31 02:13:02 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 02:14:24 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-31 02:18:50 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 246 seconds)
2021-10-31 02:20:41 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2021-10-31 02:25:00 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Remote host closed the connection)
2021-10-31 02:29:12 +0100guniberas(~guniberas@42.191.188.121)
2021-10-31 02:29:46 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-31 02:30:31 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 02:32:07 +0100Skyfire(~pyon@user/pyon) (Quit: brb)
2021-10-31 02:32:35 +0100Skyfire(~pyon@user/pyon)
2021-10-31 02:38:10 +0100haritz(~hrtz@user/haritz) (Quit: ZNC 1.7.2+deb3 - https://znc.in)
2021-10-31 02:38:42 +0100Null_A(~null_a@2601:645:8700:2290:19ff:7d99:67c6:79e3) (Remote host closed the connection)
2021-10-31 02:41:05 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 02:42:11 +0100yaroot(~yaroot@6.3.30.125.dy.iij4u.or.jp) (Quit: The Lounge - https://thelounge.chat)
2021-10-31 02:42:57 +0100yaroot(~yaroot@6.3.30.125.dy.iij4u.or.jp)
2021-10-31 02:45:42 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-31 02:46:39 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 02:46:39 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 02:46:39 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 02:50:43 +0100neightchan(~nate@108-233-125-227.lightspeed.sntcca.sbcglobal.net) (Quit: WeeChat 2.9)
2021-10-31 02:50:56 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2021-10-31 02:56:07 +0100machinedgod(~machinedg@24.105.81.50)
2021-10-31 02:56:48 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 02:57:11 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 02:58:47 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2021-10-31 02:58:47 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-10-31 02:58:50 +0100allbery_bgeekosaur
2021-10-31 03:01:07 +0100 <aegon> hololeap: oooh, thats perfect
2021-10-31 03:03:56 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi) (Remote host closed the connection)
2021-10-31 03:07:19 +0100 <cads> Hey all, I am working with the code listing here: https://gist.github.com/maxsu/62e8aeeb6acff3835240c6bc5a7a9651
2021-10-31 03:08:02 +0100 <cads> there are a few places where the code is really repetitive and noisy, and I wonder if I can clean that up
2021-10-31 03:10:11 +0100 <cads> for example, we define categories with two constructors, like Category ob_c, hom_c. But that makes the Bifunctor constructor very noisy: like Bifunctor ob_c hom_c ob_d hom_d ob_e hom_e f
2021-10-31 03:10:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 03:10:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 03:10:25 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 03:13:43 +0100 <cads> can I create an alternative constructor for Category that would let me write:
2021-10-31 03:14:05 +0100 <cads> class (Category C, Category D, Category E) => Bifunctor C D E f where bimap:: (C.ob x, C.ob x', C.ob y, C.ob y') => C.hom x x' -> D.hom y -> y' -> E.hom (f x y) -> (f x' y')
2021-10-31 03:14:28 +0100euouae(~euouae@user/euouae)
2021-10-31 03:14:30 +0100 <euouae> Hello
2021-10-31 03:14:33 +0100 <hololeap> isn't a category a Profunctor?
2021-10-31 03:15:57 +0100 <cads> hololeap, how do you figure?
2021-10-31 03:16:31 +0100 <hololeap> it's contravariant in `a` and covariant in `b`
2021-10-31 03:16:55 +0100 <euouae> I think profunctors are special kinds of categories
2021-10-31 03:17:05 +0100 <hololeap> other way around
2021-10-31 03:17:20 +0100 <hololeap> categories are profunctors that associate under composition
2021-10-31 03:17:34 +0100 <euouae> in that case, it goes both ways hololeap
2021-10-31 03:17:51 +0100 <euouae> e.g. https://en.wikipedia.org/wiki/Profunctor#Profunctors_as_categories explains how to view profunctors as categories
2021-10-31 03:18:34 +0100 <euouae> My question is, is it possible to write Haskell code that is /secure/ and transpiles to C? Now, what secure means, I don't know for sure. One example feature would be the zeroization fo memory after use
2021-10-31 03:19:39 +0100 <euouae> e.g. it would be nice to prove through the type system that the password leaves domain A and gets into domain B only for its use, and it is then deleted
2021-10-31 03:20:21 +0100 <hololeap> that sounds like something that could be done with linear types, perhaps?
2021-10-31 03:20:55 +0100 <cads> euouae, I hear that L4.Verified project did something like this by transpiling haskell to a special subset of C that lets us prove things are correct, but I forgot the details on how they ensured the compiler wouldn't introduce errors in the machine code
2021-10-31 03:21:46 +0100 <hololeap> it honestly sounds like something rust would do better
2021-10-31 03:21:56 +0100 <hololeap> haskell has that pesky garbage collector
2021-10-31 03:22:00 +0100 <cads> bit of a throwback, but might be a useful lead: http://code.ouroborus.net/fp-syd/past/2011/2011-05-sewell-l4v.pdf
2021-10-31 03:22:44 +0100 <euouae> Hmm I don't know if Rust can guarantee this hololeap, but I don't know much Rust either
2021-10-31 03:23:11 +0100 <euouae> I also don't know what linare types are
2021-10-31 03:23:58 +0100 <euouae> aah you're speaking of argument consumption
2021-10-31 03:24:57 +0100 <hololeap> > prove through the type system that the X leaves domain A and gets into domain B only for its use, and it is then deleted
2021-10-31 03:25:08 +0100 <hololeap> that sounds like exactly what linear types do
2021-10-31 03:25:27 +0100 <euouae> Yeah you're right, I agree it is a good solution
2021-10-31 03:26:11 +0100alx741(~alx741@181.196.69.253) (Quit: alx741)
2021-10-31 03:27:16 +0100betelgeuse(~betelgeus@94-225-47-8.access.telenet.be) (Quit: The Lounge - https://thelounge.chat)
2021-10-31 03:28:17 +0100 <cads> I feel like these formal verification approaches have been around since the 70s but they're more or less unsustainable for most teams or individual programmers
2021-10-31 03:30:48 +0100 <cads> even now, after 50 years of development of specification and process algebras, linear logic, temporal logic, and so on. The machinery is there, but the effort to make, for example, a verified microkernel, is so stupendously difficult and technical that volunteers simply do not appear
2021-10-31 03:31:13 +0100 <euouae> cads, what of something a bit simpler, like a TLS library?
2021-10-31 03:32:08 +0100 <euouae> I'm looking at the slides you posted but I can't tell what's going on. There's three components, a Haskell reference implementation, the verification by Isabelle/HOL and a C implementation. I think the C implementation is hand-written using the Haskell as prototype? If I'm reading it correctly.
2021-10-31 03:33:35 +0100 <euouae> although that doesn't sound right. I'm not sure.
2021-10-31 03:34:13 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-31 03:35:35 +0100img(~img@user/img)
2021-10-31 03:38:37 +0100 <euouae> I also know of Ivory https://ivorylang.org/ but it's only a subset of C
2021-10-31 03:39:04 +0100 <euouae> cads so for example I think it's reasonable to use ivory to write certain algorithms in it
2021-10-31 03:41:47 +0100catman(~catman@user/catman)
2021-10-31 03:42:19 +0100 <euouae> Another great feature in Haskell that helps with security that C doesn't have is `hedgehog` or similar unit test libraries
2021-10-31 03:43:15 +0100 <euouae> I'm just trying to understand if there's people who are interested/working in writing safe C programs utilizing Haskell, and to learn more about techniques involving that...
2021-10-31 03:43:48 +0100 <cads> euouae, they started with an abstract specification wrote an haskell implementation. From that they auto-extracted an executable specification. They were able to then do a proof that the haskell derived spec implements the abstract spec
2021-10-31 03:44:40 +0100 <cads> they then manually wrote a C implementation and manually proved that it conforms to the exectutable spec
2021-10-31 03:44:51 +0100 <euouae> I'm not sure about that manual proof cads
2021-10-31 03:44:54 +0100 <euouae> I don't understand how that worked
2021-10-31 03:45:18 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-31 03:47:11 +0100 <cads> trying to find a paper with more details. If I recall correctly, there is a special subset of C and a HOL library that lets you prove things - like "there are no buffer overflows" about just that special subset of C
2021-10-31 03:47:54 +0100 <euouae> OK got it. There must have been some proof by argument too, I don't think it was all automated
2021-10-31 03:48:05 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 264 seconds)
2021-10-31 03:48:48 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 03:49:39 +0100 <sm> euouae: C has fuzz testing tools
2021-10-31 03:49:52 +0100 <cads> euouae, yeah, there are two kinds of proof involved, and they are both manual. First, we prove that the executable specification is really a refinement of the abstract spec. This proves our haskell implementation is legit, but is manual.
2021-10-31 03:50:32 +0100 <cads> euouae, second, we prove that each piece of C-code correctly implements its executable specification
2021-10-31 03:50:35 +0100 <euouae> That first part makes sense cads, I'm following. The abstract spec is something like Z-language
2021-10-31 03:50:39 +0100 <cads> two huge acts of HOL proof bashing
2021-10-31 03:51:28 +0100 <euouae> OK got you. Even /that/ sounds great to me for my purpose. How about secure Haskell then?
2021-10-31 03:51:37 +0100 <cads> euouae, the only part that we get "for free" is the haskell derived executable spec. And then we havbe to prove that the spec really does "carry" the abstract spec, yeah, like with Z-lang refinement or other spec langauges
2021-10-31 03:51:44 +0100 <euouae> Of course Haskell is generally secure, but for instance, a dangling password variable in memory is insecure. That's an example
2021-10-31 03:51:57 +0100 <euouae> cads, you were involved?
2021-10-31 03:52:07 +0100 <cads> nah, I'm just a fanboi
2021-10-31 03:52:35 +0100hendursaga(~weechat@user/hendursaga) (Quit: hendursaga)
2021-10-31 03:52:36 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 245 seconds)
2021-10-31 03:52:41 +0100 <cads> also, I'm frustrated that the technique isn't more popular even though it's a decade old - my theory is just that the technique is incredibly technical
2021-10-31 03:53:05 +0100hendursaga(~weechat@user/hendursaga)
2021-10-31 03:53:11 +0100xff0x(~xff0x@2001:1a81:52f0:9300:c38e:4fda:aa4c:3e21) (Ping timeout: 264 seconds)
2021-10-31 03:54:07 +0100 <cads> euouae, for your needs, maybe all you need is the the ability to draft up a very clean spec, write up some less clean haskell, and then prove that the haskel is to spec...
2021-10-31 03:54:19 +0100proboscis(~proboscis@115-189-81-94.mobile.spark.co.nz)
2021-10-31 03:54:45 +0100xff0x(~xff0x@2001:1a81:5344:9700:7f1d:617d:8156:7d35)
2021-10-31 03:55:27 +0100 <cads> and we do that by auto-translating haskell to a messy "exec-spec", and formally linking that back to the abstract spec
2021-10-31 03:56:01 +0100 <euouae> so you're saying the executable spec can be ran and produces an "ok" or "no-good" as an answer? because as the project evolves and people contribute, a divergence may occur
2021-10-31 03:56:22 +0100 <euouae> it would be nice if it were caught automatically instead of someone noticing "oops, 100 commits ago the specs diverged"
2021-10-31 03:56:47 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 264 seconds)
2021-10-31 03:57:22 +0100 <cads> I suppose the way that would work is that every change to the exec-spec must also come with a proof showing that the change still conforms to the abstract-spec
2021-10-31 03:59:09 +0100 <euouae> It's annoying that I feel like getting sucked in some sort of black hole
2021-10-31 04:00:07 +0100 <cads> yeah, all you want is verifiable code, but now you have to reason about an abstract spec, an implementation, an executable spec, and a proof showing that the executable spec conforms to the abstract spec
2021-10-31 04:00:16 +0100 <euouae> I started by wanting to add a feature to my IRC client, but then I had to modify the elisp TLS implementation, but the C functions were undocumented so I delved into the C lib, and the source code seemed bad so I started dreaming about writing a secure implementation of it
2021-10-31 04:01:17 +0100 <euouae> cads oh yeah, that's also a black hole :P
2021-10-31 04:02:04 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 04:02:26 +0100trillp(~trillp@69.233.98.238) (Quit: nyaa~)
2021-10-31 04:03:38 +0100neurocyte0132889(~neurocyte@user/neurocyte) (Ping timeout: 268 seconds)
2021-10-31 04:05:29 +0100 <cads> " the executable spec can be ran and produces an "ok" or "no-good" as an answer?" That is close, in that we do run /something/ that tells us go/no go
2021-10-31 04:05:51 +0100 <cads> we have 4 artefacts: AbstractSpec (a manually written HOL statement), Implementation (manually written Haskell code), ExecSpec (an automatically written Hol statement), and ExecSpecConformsToAbstractSpec (a manually written Hol proof)
2021-10-31 04:07:10 +0100 <cads> If we update Implementation, that updates ExecSpec. We can then attempt to run ExecSpecConformsToAbstractSpec. If it fails, then our code is out of spec, and we either need to fix our code or update ExecSpecConformsToAbstractSpec to prove the the new feature is still to spec
2021-10-31 04:07:32 +0100 <euouae> OK actually that sounds good enough to me cads
2021-10-31 04:08:39 +0100 <euouae> hmm I don't know anything about HOLs
2021-10-31 04:09:14 +0100 <cads> I would love to see a continuous integration pipeline where you're simply not allowed to push to Implementation unless your PR also passes the ExecSpecConformsToAbstractSpec
2021-10-31 04:11:46 +0100 <aegon> man, Debug.Trace is fantastic for pretending you don't need tests :P
2021-10-31 04:13:47 +0100 <cads> if you invented something that could turn your manual debugging sessions into reasonable unit tests, I feel like building a statue in your honor would be the least we could do
2021-10-31 04:15:06 +0100td_(~td@muedsl-82-207-238-113.citykom.de) (Ping timeout: 245 seconds)
2021-10-31 04:17:47 +0100 <aegon> i wish. I'm suffering from sunk cost fallacies right now. Tested the library to spec, but then for a prototype client for integration i was like, nahhhhh. thats like a one time thing to work out the kinks in. got half way through and paused for the night...
2021-10-31 04:17:53 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 04:17:58 +0100 <aegon> now i'm not sure whats a bug or whats odd stuff i put in there to try to find bugs :\
2021-10-31 04:18:19 +0100 <aegon> and its already mostly manually tested, so why go back to unit test it now right? :D
2021-10-31 04:19:07 +0100 <aegon> thats an awesome idea though, if there were a tool to watch some manual integration tests and point at what functions are prolly worth unit-testing it'd save so much time in so many place
2021-10-31 04:19:11 +0100 <aegon> *places
2021-10-31 04:20:27 +0100 <aegon> you'd need some sort of valgrind like setup watching the bits
2021-10-31 04:21:10 +0100 <aegon> actually, does valgrind not already have the ability to point at funcitons used etc?
2021-10-31 04:21:13 +0100aegonruns to the docs
2021-10-31 04:21:17 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 04:22:02 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-10-31 04:24:38 +0100 <cads> something that watches and summarizes your debug sessions could be nice. If you have a debug sessions that you want to implement as unit tests, you haven't lost your precious work.
2021-10-31 04:24:44 +0100 <cads> I even bet it is now possible to train a transformer to watch you manually test a piece of code, and "guess" an equivalent unit or integration test
2021-10-31 04:26:51 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-31 04:29:07 +0100emf(~emf@2620:10d:c090:400::5:9927)
2021-10-31 04:30:19 +0100emf(~emf@2620:10d:c090:400::5:9927) (Client Quit)
2021-10-31 04:32:36 +0100 <aegon> yeah it looks like valgrand has enough tracking stuff to mess with the idea thats really neat, i wish there was more emphasis in code land on tools like flay / flog and metrics like those
2021-10-31 04:33:37 +0100 <aegon> cads: what do you mean by a transformer in that context?
2021-10-31 04:36:32 +0100 <cads> aegon, transformers are a kind of neural network that appeared in 2017. They are getting really good at taking a sequence of complex data - like a waveform in spoken english - and translating it directly into another complex sequence - like a waveform translated to spoken french.
2021-10-31 04:36:43 +0100justsomeguy(~justsomeg@user/justsomeguy)
2021-10-31 04:37:24 +0100 <euouae> cads how?
2021-10-31 04:37:45 +0100 <euouae> do they do something insane like look at the waveform in a basis and decide what the new coefficients are?
2021-10-31 04:38:12 +0100 <cads> aegon, and recently transformer models have been used to do code tasks. For example, you give it it text describing how to zip two lists together, and it gives you a python implementation of Zip
2021-10-31 04:38:17 +0100 <aegon> cads: interesting, yeah i've worked with em a little in doing some automatic music transcription
2021-10-31 04:38:22 +0100viluon(uid453725@id-453725.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 04:38:45 +0100 <aegon> i've never thought of using them on byte code or anthing or heard of them goign into code implementations
2021-10-31 04:38:56 +0100 <aegon> is that how githubs copilot stuff is working?
2021-10-31 04:39:45 +0100 <aegon> i'm lost on the jump from that type of stuff to looking at a binary run in memory and extracting symbol info but it sounds really interesting
2021-10-31 04:40:53 +0100 <cads> Copilot is powered by OpenAI's Codex, which is a code-trained version of the openAI GPT3 language transformer
2021-10-31 04:41:38 +0100 <cads> aegon, I haven't run into anything that really explain "how" we can take a complex signal and just zap it into another complex signal - especially something so complex as spoken speech
2021-10-31 04:41:51 +0100 <cads> let alone something as complex as code
2021-10-31 04:42:51 +0100 <cads> aegon, a fun thing is that it's not very good. A study showed that in security-sensitive coding tasks, Codex introduced buffer overflows and other security holes 40% of the time
2021-10-31 04:43:53 +0100 <cads> the reason why is hypothesized to be the training corpus - the engine was trained on the github corpus, which has a lot of low quality code and security bugs.
2021-10-31 04:45:31 +0100 <cads> aegon, so far, the best I can do is show you a colorful graph of neural network components put together in a novel way, wave my hands, slap the hood, and say "this baby is able to internally learn a latent representation covering the complexities of the underlying domain"
2021-10-31 04:45:46 +0100[_][itchyjunk]
2021-10-31 04:46:57 +0100 <cads> Hey all, is there any writing about how to clean up messy typeclasses?
2021-10-31 04:47:11 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 264 seconds)
2021-10-31 04:47:11 +0100 <cads> this looks like an example: http://h2.jaguarpaw.co.uk/posts/simplifying-typeclasses/
2021-10-31 04:48:59 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-10-31 04:50:04 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 04:55:38 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 05:06:24 +0100 <aegon> cads: aye thats really interesting though, never thoguht about using a net on an in memory representation fo something and trying to parse out a good sytactic version. If you haven't already you should check out hasktorch
2021-10-31 05:10:56 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2021-10-31 05:15:54 +0100natechan(~nate@108-233-125-227.lightspeed.sntcca.sbcglobal.net)
2021-10-31 05:18:18 +0100euouae(~euouae@user/euouae) (Quit: thank you for the help)
2021-10-31 05:22:36 +0100boxscape_(~boxscape_@i577BCB53.versanet.de) (Ping timeout: 245 seconds)
2021-10-31 05:23:22 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 05:26:08 +0100mbuf(~Shakthi@171.61.246.251)
2021-10-31 05:29:29 +0100mikoto-chan(~mikoto-ch@185.237.102.118)
2021-10-31 05:30:41 +0100 <dsal> if I have a `forall m. MonadIO m => m T` is there a way to get to the `m` type from within the body without a proxy? @m tells me it's not in scope.
2021-10-31 05:32:57 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net)
2021-10-31 05:37:51 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-10-31 05:38:01 +0100Guest19(~Guest19@2600:1700:31c0:3a10:81e2:cfe0:2015:d55b)
2021-10-31 05:41:11 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net) (Ping timeout: 264 seconds)
2021-10-31 05:42:10 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-31 05:43:20 +0100 <monochrom> ScopedTypeVariables
2021-10-31 05:45:19 +0100 <dsal> Oh weird. I thought that was on and/or implied. heh
2021-10-31 05:45:40 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 05:47:03 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 05:47:03 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 05:47:03 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 05:48:13 +0100machinedgod(~machinedg@24.105.81.50)
2021-10-31 05:50:02 +0100mvk(~mvk@2607:fea8:5cc1:300::d3fb)
2021-10-31 05:53:00 +0100Skyfire(~pyon@user/pyon) (Quit: brb broken config)
2021-10-31 05:53:21 +0100Skyfire(~pyon@user/pyon)
2021-10-31 05:57:08 +0100ghoulguy(x@libera/staff/glguy) (Quit: Quit)
2021-10-31 05:58:17 +0100glguy(x@libera/staff/glguy)
2021-10-31 05:58:43 +0100glguyghoulguy
2021-10-31 06:01:02 +0100Guest19(~Guest19@2600:1700:31c0:3a10:81e2:cfe0:2015:d55b) (Quit: Client closed)
2021-10-31 06:11:48 +0100 <cads> aegon, I haven't used it, but I might try to port a pytorch project for fun soon
2021-10-31 06:34:04 +0100manicennui(uid349235@id-349235.tinside.irccloud.com) (Quit: Keep firing, assholes!)
2021-10-31 06:45:24 +0100boxscape_(~boxscape_@mue-88-130-59-084.dsl.tropolys.de)
2021-10-31 06:48:51 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 245 seconds)
2021-10-31 06:50:28 +0100 <brainfreeze> Why do instance declarations always seem to be missing a type variable? It almost seems like it's currying the type variables.
2021-10-31 06:51:06 +0100 <c_wraith> type constructors are curried, yes
2021-10-31 06:51:22 +0100 <c_wraith> and instances have to have the right kind
2021-10-31 06:51:35 +0100 <c_wraith> If that means not fully applying type arguments, so be it
2021-10-31 06:56:06 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-10-31 06:57:44 +0100ec(~ec@gateway/tor-sasl/ec)
2021-10-31 06:59:30 +0100haritz(~hrtz@62.3.70.206)
2021-10-31 06:59:30 +0100haritz(~hrtz@62.3.70.206) (Changing host)
2021-10-31 06:59:30 +0100haritz(~hrtz@user/haritz)
2021-10-31 07:02:11 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 07:03:45 +0100mei(~mei@user/mei)
2021-10-31 07:05:17 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-31 07:06:22 +0100 <brainfreeze> Is there a formal name for what I mentioned?
2021-10-31 07:09:15 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-10-31 07:10:07 +0100img(~img@user/img)
2021-10-31 07:11:12 +0100haritz(~hrtz@user/haritz) (Quit: ZNC 1.7.2+deb3 - https://znc.in)
2021-10-31 07:14:22 +0100haritz(~hrtz@2a02:8010:65b5:0:6009:6384:e3cb:2220)
2021-10-31 07:14:22 +0100haritz(~hrtz@2a02:8010:65b5:0:6009:6384:e3cb:2220) (Changing host)
2021-10-31 07:14:22 +0100haritz(~hrtz@user/haritz)
2021-10-31 07:23:51 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 245 seconds)
2021-10-31 07:24:37 +0100slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-10-31 07:26:48 +0100vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2021-10-31 07:31:54 +0100fvr(uid503686@id-503686.uxbridge.irccloud.com)
2021-10-31 07:38:57 +0100proboscis(~proboscis@115-189-81-94.mobile.spark.co.nz) (Read error: Connection reset by peer)
2021-10-31 07:40:04 +0100proboscis(~proboscis@115-189-81-94.mobile.spark.co.nz)
2021-10-31 07:40:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 07:40:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 07:40:45 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 07:45:50 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-31 07:50:59 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-10-31 07:53:40 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Remote host closed the connection)
2021-10-31 07:54:38 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 07:56:52 +0100chomwitt(~chomwitt@ppp-2-85-245-90.home.otenet.gr)
2021-10-31 07:57:44 +0100ikke(~kevin@alpine/developer/ikke) (Quit: WeeChat 3.2)
2021-10-31 07:57:59 +0100ikke(~kevin@alpine/developer/ikke)
2021-10-31 08:01:45 +0100aegon(~mike@174.127.249.180) (Quit: leaving)
2021-10-31 08:08:02 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-10-31 08:11:40 +0100img_(~img@user/img)
2021-10-31 08:11:40 +0100MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com) (Read error: Connection reset by peer)
2021-10-31 08:14:47 +0100img(~img@user/img) (Ping timeout: 264 seconds)
2021-10-31 08:16:32 +0100fizzsegfaultbuzz(~segfaultf@135-180-0-138.static.sonic.net) (Ping timeout: 265 seconds)
2021-10-31 08:16:51 +0100MQ-17J(~MQ-17J@8.6.144.203)
2021-10-31 08:20:47 +0100mvk(~mvk@2607:fea8:5cc1:300::d3fb) (Ping timeout: 264 seconds)
2021-10-31 08:21:33 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d) (Remote host closed the connection)
2021-10-31 08:23:05 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-31 08:24:26 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2021-10-31 08:24:30 +0100chexum_(~quassel@gateway/tor-sasl/chexum) (Ping timeout: 276 seconds)
2021-10-31 08:29:04 +0100gehmehgeh(~user@user/gehmehgeh)
2021-10-31 08:30:15 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-10-31 08:30:16 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-10-31 08:46:34 +0100img_(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-31 08:54:02 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 08:55:27 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-10-31 08:56:52 +0100chomwitt(~chomwitt@ppp-2-85-245-90.home.otenet.gr) (Read error: Connection reset by peer)
2021-10-31 08:57:03 +0100img(~img@user/img)
2021-10-31 08:57:07 +0100chomwitt(~chomwitt@2a02:587:dc02:9f00:12c3:7bff:fe6d:d374)
2021-10-31 08:58:35 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Ping timeout: 264 seconds)
2021-10-31 09:05:27 +0100hendursa1(~weechat@user/hendursaga)
2021-10-31 09:08:01 +0100aliosablack(~chomwitt@2a02:587:dc02:9f00:12c3:7bff:fe6d:d374)
2021-10-31 09:08:29 +0100chomwitt(~chomwitt@2a02:587:dc02:9f00:12c3:7bff:fe6d:d374) (Read error: Connection reset by peer)
2021-10-31 09:09:19 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 09:09:21 +0100hendursaga(~weechat@user/hendursaga) (Ping timeout: 276 seconds)
2021-10-31 09:13:15 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 260 seconds)
2021-10-31 09:17:03 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2)
2021-10-31 09:22:04 +0100acidjnk_new3(~acidjnk@p200300d0c7441135e59462474fdf3062.dip0.t-ipconnect.de)
2021-10-31 09:22:48 +0100 <Franciman> tik tok tik tok, the time is running out. be prepared
2021-10-31 09:26:14 +0100Farzad(~FarzadBek@178.131.30.143)
2021-10-31 09:32:02 +0100fendor(~fendor@178.115.79.50.wireless.dyn.drei.com)
2021-10-31 09:39:40 +0100mikoto-chan(~mikoto-ch@185.237.102.118) (Read error: Connection reset by peer)
2021-10-31 09:40:36 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-10-31 09:41:12 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 276 seconds)
2021-10-31 09:43:22 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2021-10-31 09:43:51 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-10-31 09:44:11 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-10-31 09:45:31 +0100boxscape_(~boxscape_@mue-88-130-59-084.dsl.tropolys.de) (Ping timeout: 245 seconds)
2021-10-31 09:50:40 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Read error: Connection reset by peer)
2021-10-31 09:51:57 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2) (Remote host closed the connection)
2021-10-31 09:56:10 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-10-31 09:58:14 +0100c0c0(~coco@85.195.206.193)
2021-10-31 09:58:40 +0100c0c0(~coco@85.195.206.193) (Client Quit)
2021-10-31 09:58:49 +0100mc47(~mc47@xmonad/TheMC47)
2021-10-31 09:59:11 +0100guniberas(~guniberas@42.191.188.121) (Ping timeout: 264 seconds)
2021-10-31 10:00:06 +0100tsmc[m](~tsmcmatri@2001:470:69fc:105::1:7e1) (Quit: You have been kicked for being idle)
2021-10-31 10:00:08 +0100sam[m]12(~sammtopoi@2001:470:69fc:105::e887) (Quit: You have been kicked for being idle)
2021-10-31 10:03:34 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Ping timeout: 260 seconds)
2021-10-31 10:05:16 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-31 10:05:31 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-10-31 10:07:57 +0100 <[exa]> Franciman: what's the deal?
2021-10-31 10:14:56 +0100acidjnk_new3(~acidjnk@p200300d0c7441135e59462474fdf3062.dip0.t-ipconnect.de) (Read error: Connection reset by peer)
2021-10-31 10:15:34 +0100 <cads> Is halloween, am feeling spooky. https://gist.github.com/maxsu/65ee89f6306fe2e62c5e8e519b635399 Happy halloween!
2021-10-31 10:20:46 +0100acidjnk(~acidjnk@p200300d0c7441135e0a3c48788e32464.dip0.t-ipconnect.de)
2021-10-31 10:20:55 +0100 <Rembane_> Very spooky!
2021-10-31 10:21:04 +0100kenran(~kenran@200116b82b0d0a00e98487ecbf918c70.dip.versatel-1u1.de)
2021-10-31 10:21:40 +0100 <cads> I'm trying to get at least some of the ghosts out of it, lol
2021-10-31 10:23:26 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 245 seconds)
2021-10-31 10:29:45 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-31 10:39:38 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-10-31 10:41:00 +0100img(~img@user/img)
2021-10-31 10:45:13 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 10:46:29 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 10:50:11 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Ping timeout: 264 seconds)
2021-10-31 10:51:06 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 10:53:27 +0100Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-10-31 10:55:55 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 10:57:47 +0100zaquest(~notzaques@5.128.210.178) (Remote host closed the connection)
2021-10-31 10:57:52 +0100aliosablack(~chomwitt@2a02:587:dc02:9f00:12c3:7bff:fe6d:d374) (Ping timeout: 260 seconds)
2021-10-31 10:58:50 +0100zaquest(~notzaques@5.128.210.178)
2021-10-31 11:00:23 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Ping timeout: 265 seconds)
2021-10-31 11:05:26 +0100 <maerwald> Haskell is mentioned wrt "significant whitespace" in the "Worst Programming Language Ever" talk: https://www.youtube.com/watch?v=2mnYf7L7Amw
2021-10-31 11:14:47 +0100img(~img@user/img) (Ping timeout: 264 seconds)
2021-10-31 11:14:48 +0100 <Rembane_> Can't Haskell be written without significant whitespace?
2021-10-31 11:15:22 +0100mmhat(~mmh@55d4be88.access.ecotel.net)
2021-10-31 11:16:10 +0100 <maerwald> the point is that changing whitespaces to tabs can make your program not compile
2021-10-31 11:16:25 +0100 <maerwald> or not following alignment rules in general
2021-10-31 11:17:21 +0100Vq(half-jokingly) regards bad indentation in C worse than behavioural bugs
2021-10-31 11:17:45 +0100 <Rembane_> maerwald: Got it. I'm too used to Python and Haskell to see this as a problem.
2021-10-31 11:18:02 +0100 <Cale> Replacing whitespace with vertical tabs also can make your program not compile in many languages, but nobody cares
2021-10-31 11:18:18 +0100 <Rembane_> What's a vertical tab and how is it rendered?
2021-10-31 11:18:21 +0100 <Rembane_> I've never seen one.
2021-10-31 11:18:55 +0100 <Cale> It's an ancient character that was used to speed up vertical movement on printers
2021-10-31 11:19:01 +0100 <maerwald> :D
2021-10-31 11:19:08 +0100 <Cale> But it's still there as a form of whitespace
2021-10-31 11:19:34 +0100 <maerwald> the only time I printed out my code was to troll a professor
2021-10-31 11:19:44 +0100 <Vq> I don't see page-feed characters that often anymore, I wonder what languages accepts them...
2021-10-31 11:21:08 +0100 <Rembane_> Cale: Cool, doesn't sound too useful on a monitor but I can see why it was useful back in the day.
2021-10-31 11:21:18 +0100 <maerwald> and when you don't match the whitespaces in python, the error you get is "couldn't match colon"
2021-10-31 11:21:37 +0100 <Rembane_> I am not going to make an inappropriate joke about that.
2021-10-31 11:21:38 +0100 <maerwald> but I guess it would be kinda hard for the compiler figuring out what you meant
2021-10-31 11:22:18 +0100 <maerwald> it could try brute-force compilation
2021-10-31 11:22:52 +0100 <Rembane_> maerwald: Try all possible indentations and see what kinda makes sense?
2021-10-31 11:23:16 +0100 <maerwald> "compiles"
2021-10-31 11:23:21 +0100 <maerwald> "makes sense" is something else
2021-10-31 11:24:20 +0100 <Cale> Tab also isn't too useful on a monitor, but people still seem to care about interpreting tab characters for some reason. I would just ban them altogether.
2021-10-31 11:24:29 +0100notzmv(~zmv@user/notzmv)
2021-10-31 11:25:04 +0100 <Rembane_> maerwald: That's my point, it would be very easy to get "interesting" semantics from that. :)
2021-10-31 11:25:14 +0100 <Rembane_> I like to have the tab key but not the tab character.
2021-10-31 11:29:22 +0100kenran(~kenran@200116b82b0d0a00e98487ecbf918c70.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2021-10-31 11:29:38 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 11:30:19 +0100kenran(~kenran@200116b82b0d0a0094e57a89e1053ea4.dip.versatel-1u1.de)
2021-10-31 11:33:37 +0100kenran(~kenran@200116b82b0d0a0094e57a89e1053ea4.dip.versatel-1u1.de) (Client Quit)
2021-10-31 11:35:29 +0100 <maerwald> it's a great talk... he put all his sincere hatred and made something funny out of it
2021-10-31 11:35:44 +0100 <maerwald> and I can feel there's years of pain behind it
2021-10-31 11:37:00 +0100 <maerwald> the only conditional operator being `unless` is a great idea
2021-10-31 11:38:51 +0100 <maerwald> I must admit I can't stand that function in haskell either (especially when hlint suggests it to me)
2021-10-31 11:39:44 +0100 <maerwald> just because in my head `when (not ...)` sounds much more plausible
2021-10-31 11:39:50 +0100mmhat(~mmh@55d4be88.access.ecotel.net) (Quit: WeeChat 3.3)
2021-10-31 11:42:54 +0100f-a(f2a@f2a.jujube.ircnow.org) ()
2021-10-31 11:45:54 +0100mmhat(~mmh@55d4be88.access.ecotel.net)
2021-10-31 11:49:26 +0100xff0x(~xff0x@2001:1a81:5344:9700:7f1d:617d:8156:7d35) (Ping timeout: 260 seconds)
2021-10-31 11:49:55 +0100xff0x(~xff0x@2001:1a81:5344:9700:9e27:fb01:4b2b:d1ea)
2021-10-31 11:54:23 +0100mmhat(~mmh@55d4be88.access.ecotel.net) (Quit: WeeChat 3.3)
2021-10-31 11:55:15 +0100mmhat(~mmh@55d4be88.access.ecotel.net)
2021-10-31 12:00:53 +0100alx741(~alx741@181.196.69.253)
2021-10-31 12:07:51 +0100Guest31(~Guest31@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-10-31 12:09:02 +0100chomwitt(~chomwitt@ppp-2-85-245-90.home.otenet.gr)
2021-10-31 12:14:29 +0100Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-31 12:16:20 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 12:21:23 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 264 seconds)
2021-10-31 12:23:45 +0100DNH(~DNH@8.43.122.53)
2021-10-31 12:26:44 +0100__monty__(~toonn@user/toonn)
2021-10-31 12:37:31 +0100Lycurgus(~juan@98.4.112.204)
2021-10-31 12:40:13 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-10-31 12:41:56 +0100 <tomjaguarpaw> With OverloadedRecordDot in 9.2, if I want to write record.field then the field for my record must be in scope, at the very least in qualified form. Is that expected? Seems strange to me.
2021-10-31 12:42:51 +0100 <tomjaguarpaw> e.g. if I have module Foo where data Foo = Foo { field :: Int } and module Main where import (Foo(Foo)); main = print (Foo 1).field then it will not work.
2021-10-31 12:43:01 +0100 <tomjaguarpaw> I have to add at least import qualified Foo(field)
2021-10-31 12:43:10 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-10-31 12:43:32 +0100 <tomjaguarpaw> Why does it care that field is in scope? Doesn't the HasField instance do all that is required?
2021-10-31 12:50:31 +0100hippoid(~idris@184.105.6.88) (Ping timeout: 245 seconds)
2021-10-31 12:51:28 +0100hippoid(~idris@184.105.6.88)
2021-10-31 12:54:39 +0100Liudvikas(~Liudvikas@88.222.185.135)
2021-10-31 12:54:56 +0100 <zincy> davean: If you want to do timeouts with Machines can you use Wye machine which has one input that just just yields a Timeout action to the Wye?
2021-10-31 12:54:58 +0100jakalx(~jakalx@base.jakalx.net)
2021-10-31 12:55:14 +0100acidjnk(~acidjnk@p200300d0c7441135e0a3c48788e32464.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-10-31 12:57:13 +0100Farzad(~FarzadBek@178.131.30.143) (Quit: Leaving)
2021-10-31 13:00:35 +0100cheater(~Username@user/cheater) (Ping timeout: 246 seconds)
2021-10-31 13:01:11 +0100cheater(~Username@user/cheater)
2021-10-31 13:03:46 +0100 <amesgen[m]> tomjaguarpaw: HasField is compiler-solved, and the behavior you are seeing is exactly the reason why, as it would be impossible to "hide" fields otherwise.
2021-10-31 13:05:17 +0100 <amesgen[m]> See https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0023-overloaded-record-fields…
2021-10-31 13:06:17 +0100 <tomjaguarpaw> amesgen[m]: Thanks
2021-10-31 13:07:49 +0100xsperry(~xs@user/xsperry) ()
2021-10-31 13:11:49 +0100Lycurgus(~juan@98.4.112.204) (Quit: Exeunt)
2021-10-31 13:12:26 +0100 <zincy> Does using a tuple make sense over a fixed list when you know ahead of time exactly what you need?
2021-10-31 13:13:17 +0100 <zincy> For a card game there are different stages say 1,2,3,4,5 and we have (Card,Card,Card) and then the next stages just mean an N+1 tuple
2021-10-31 13:13:17 +0100 <geekosaur> it can. but if you need list operations, you lose those with a tuple
2021-10-31 13:13:40 +0100 <zincy> Convert to list? Maybe this is slow hmm
2021-10-31 13:13:58 +0100 <geekosaur> in particular with that case you would need to manually build the N+1-tuple
2021-10-31 13:14:10 +0100 <geekosaur> which means it won't generalize well for different Ns
2021-10-31 13:14:46 +0100 <zincy> Yeah generalisation wont be needed most probably
2021-10-31 13:21:54 +0100Liudvikas(~Liudvikas@88.222.185.135) (Ping timeout: 260 seconds)
2021-10-31 13:23:13 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2021-10-31 13:29:59 +0100xff0x(~xff0x@2001:1a81:5344:9700:9e27:fb01:4b2b:d1ea) (Ping timeout: 246 seconds)
2021-10-31 13:32:05 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-31 13:32:06 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2021-10-31 13:32:34 +0100proboscis(~proboscis@115-189-81-94.mobile.spark.co.nz) (Ping timeout: 260 seconds)
2021-10-31 13:35:23 +0100yin(~z@user/zero)
2021-10-31 13:36:07 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Client Quit)
2021-10-31 13:37:38 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-31 13:38:05 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 13:40:38 +0100xff0x(~xff0x@2001:1a81:5344:9700:9e27:fb01:4b2b:d1ea)
2021-10-31 13:41:47 +0100proboscis(~proboscis@115-189-83-206.mobile.spark.co.nz)
2021-10-31 13:42:50 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Ping timeout: 260 seconds)
2021-10-31 13:44:59 +0100 <yin> sortOn is defined as `map snd . sortBy (comparing fst) . map (\x -> let y = f x in seq y (y,x))`
2021-10-31 13:45:41 +0100 <yin> this is referred to as a Schwartzian transform
2021-10-31 13:46:09 +0100 <yin> the advantage beying that it only evaluates f once for each element
2021-10-31 13:46:17 +0100 <yin> s/beying/being
2021-10-31 13:47:07 +0100 <yin> my question is, can the compiler optimize sortBy . comparing to this?
2021-10-31 13:47:28 +0100thblt(~thblt@user/thblt) (ERC (IRC client for Emacs 28.0.50))
2021-10-31 13:53:48 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2021-10-31 13:54:54 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 13:56:41 +0100xsperry(~xs@user/xsperry)
2021-10-31 13:57:06 +0100Liudvikas(~Liudvikas@88.222.185.135)
2021-10-31 13:58:24 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 14:02:36 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Ping timeout: 245 seconds)
2021-10-31 14:02:52 +0100 <opqdonut> yin: I don't think so. It'd be a complex Common Subexpression Elimination optimization that GHC doesn't do even in simple cases (AFAIK)
2021-10-31 14:03:30 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-10-31 14:10:20 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-31 14:11:17 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Read error: Connection reset by peer)
2021-10-31 14:12:00 +0100Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Quit: Leaving)
2021-10-31 14:13:20 +0100Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-31 14:16:48 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be)
2021-10-31 14:20:25 +0100Liudvikas(~Liudvikas@88.222.185.135) (Quit: Konversation terminated!)
2021-10-31 14:21:00 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-10-31 14:21:58 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-31 14:22:31 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-10-31 14:22:54 +0100 <hippoid> :t repeat (:)
2021-10-31 14:22:55 +0100 <lambdabot> [a -> [a] -> [a]]
2021-10-31 14:23:11 +0100 <hippoid> I'm stuck on how repeat can accept (:) as an argument
2021-10-31 14:23:27 +0100 <hippoid> my brain hasn't grokked how the types can unify
2021-10-31 14:24:36 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-10-31 14:25:12 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 14:26:35 +0100 <Hecate> % :t repeat
2021-10-31 14:26:35 +0100 <yahb> Hecate: a -> [a]
2021-10-31 14:26:37 +0100 <xsperry> it just creates a list of (:) functions.. ie [(:), (:), ..)
2021-10-31 14:26:56 +0100 <Hecate> % :t (:)
2021-10-31 14:26:56 +0100 <yahb> Hecate: a -> [a] -> [a]
2021-10-31 14:27:33 +0100 <Hecate> the 'a' is not the same
2021-10-31 14:27:36 +0100 <hippoid> xsperry: thanks. now it seems obvious
2021-10-31 14:28:19 +0100 <hippoid> so i suppose that means you can apply repeat to any type
2021-10-31 14:28:55 +0100 <xsperry> to a value of any type, yes
2021-10-31 14:28:59 +0100 <xsperry> :t repeat repeat
2021-10-31 14:29:00 +0100 <lambdabot> [a -> [a]]
2021-10-31 14:29:58 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 14:33:22 +0100jollygood2(~bc8165b6@217.29.117.252)
2021-10-31 14:33:46 +0100 <jollygood2> :t repeat (repeat (repeat (:)))
2021-10-31 14:33:47 +0100 <lambdabot> [[[a -> [a] -> [a]]]]
2021-10-31 14:38:43 +0100 <hpc> now you can finally answer the question "how many arguments does id take?"
2021-10-31 14:42:41 +0100mc47(~mc47@xmonad/TheMC47)
2021-10-31 14:43:26 +0100 <jollygood2> one, just like all functions. :P
2021-10-31 14:43:35 +0100 <hpc> :P
2021-10-31 14:43:51 +0100Guest31(~Guest31@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Ping timeout: 256 seconds)
2021-10-31 14:46:50 +0100zero(~z@user/zero)
2021-10-31 14:48:32 +0100__monty__(~toonn@user/toonn)
2021-10-31 14:49:17 +0100yin(~z@user/zero) (Ping timeout: 268 seconds)
2021-10-31 14:49:28 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 14:49:41 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi) (Quit: Must not waste too much time here...)
2021-10-31 14:51:20 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-31 14:53:22 +0100__monty__(~toonn@user/toonn) (Client Quit)
2021-10-31 14:54:51 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi) (Client Quit)
2021-10-31 15:00:33 +0100Farzad(~FarzadBek@178.131.30.143)
2021-10-31 15:05:14 +0100dsrt^(~dsrt@wsip-98-188-242-6.mc.at.cox.net) (Remote host closed the connection)
2021-10-31 15:09:05 +0100frx(~bc8165b6@cerf.good1.com)
2021-10-31 15:09:17 +0100frxjacks4
2021-10-31 15:11:46 +0100sqrt2(~ben@80-108-18-7.cable.dynamic.surfer.at) (Ping timeout: 245 seconds)
2021-10-31 15:13:06 +0100sqrt2(~ben@80-108-18-7.cable.dynamic.surfer.at)
2021-10-31 15:15:30 +0100gdd(~gdd@129.199.146.230) (Ping timeout: 260 seconds)
2021-10-31 15:16:39 +0100__monty__(~toonn@user/toonn)
2021-10-31 15:17:06 +0100gdd(~gdd@129.199.146.230)
2021-10-31 15:20:23 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 15:22:00 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 15:22:06 +0100jollygood2(~bc8165b6@217.29.117.252) (Quit: http://www.okay.uz/ (Ping timeout))
2021-10-31 15:26:30 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 15:26:54 +0100shailangsa(~shailangs@host217-39-45-200.range217-39.btcentralplus.com) (Remote host closed the connection)
2021-10-31 15:31:10 +0100mikoto-chan(~mikoto-ch@ip-83-134-2-136.dsl.scarlet.be) (Ping timeout: 260 seconds)
2021-10-31 15:32:46 +0100max22-(~maxime@2a01cb0883359800143d8394a75c565e.ipv6.abo.wanadoo.fr)
2021-10-31 15:33:10 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Quit: Leaving)
2021-10-31 15:35:03 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net)
2021-10-31 15:48:28 +0100machinedgod(~machinedg@24.105.81.50)
2021-10-31 15:49:10 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-31 15:52:21 +0100neurocyte0132889(~neurocyte@45.93.111.195)
2021-10-31 15:52:21 +0100neurocyte0132889(~neurocyte@45.93.111.195) (Changing host)
2021-10-31 15:52:21 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-10-31 15:55:11 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-31 15:55:36 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2021-10-31 15:55:46 +0100nrl^(~nrl@wsip-98-188-242-6.mc.at.cox.net)
2021-10-31 15:59:52 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 16:01:31 +0100Farzad(~FarzadBek@178.131.30.143) (Quit: Leaving)
2021-10-31 16:02:27 +0100 <maerwald> the Haskell report talks about multipler function arguments in various places though, afair
2021-10-31 16:03:54 +0100sprout_(~quassel@2a02:a467:ccd6:1:8872:6fff:30a7:51e0)
2021-10-31 16:04:16 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Ping timeout: 245 seconds)
2021-10-31 16:07:25 +0100sprout(~quassel@2a02:a467:ccd6:1:21d2:19c0:e01b:f66c) (Ping timeout: 260 seconds)
2021-10-31 16:15:01 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894)
2021-10-31 16:19:35 +0100 <ksu> 'unless' always reminds me of this great scene: https://www.youtube.com/watch?v=q_vGN9R3c3k
2021-10-31 16:21:49 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 16:24:07 +0100shailangsa(~shailangs@host217-39-45-200.range217-39.btcentralplus.com)
2021-10-31 16:26:38 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 16:27:47 +0100DNH(~DNH@8.43.122.53) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-31 16:29:00 +0100akspecs__(~akspecs@user/akspecs) (Ping timeout: 260 seconds)
2021-10-31 16:29:35 +0100jil(~user@160.120.146.111)
2021-10-31 16:29:39 +0100 <jil> hello
2021-10-31 16:31:05 +0100DNH(~DNH@8.43.122.53)
2021-10-31 16:32:47 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-10-31 16:32:50 +0100 <jil> I'm quit happy with the way I solved the 6th exercices of the 10th chapter of Hutton but not with the formatting of the code. I was not able to factorise the code snipet `(prev_ ++ next_)`. Please show me how to do so ? https://paste.debian.net/1217480
2021-10-31 16:35:25 +0100hippoid(~idris@184.105.6.88) (Quit: Lost terminal)
2021-10-31 16:39:15 +0100mbuf(~Shakthi@171.61.246.251) (Quit: Leaving)
2021-10-31 16:48:04 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 16:50:09 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 268 seconds)
2021-10-31 16:51:08 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-10-31 16:51:42 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 16:53:13 +0100fendor_(~fendor@77.119.160.25.wireless.dyn.drei.com)
2021-10-31 16:56:02 +0100fendor(~fendor@178.115.79.50.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2021-10-31 16:58:20 +0100Jing_(~textual@103.121.208.115)
2021-10-31 17:05:32 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 17:05:32 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 17:05:32 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 17:07:41 +0100Null_A(~null_a@2601:645:8700:2290:714b:c982:dcb8:3f01)
2021-10-31 17:08:09 +0100 <Cale> jil: You could write something like let line = prev_ ++ next_ just above your if
2021-10-31 17:08:19 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-10-31 17:09:15 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-31 17:09:44 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 17:10:59 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 17:14:11 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Ping timeout: 264 seconds)
2021-10-31 17:18:56 +0100 <jil> Hecate: gave me some courage in another channel and I came up with this https://paste.debian.net/1217484/ but I curious to try the let line , thank you Cale.
2021-10-31 17:20:18 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 17:20:44 +0100 <jil> Great. Thank you Cale
2021-10-31 17:21:20 +0100 <kosmikus> it's not entirely clear to me why you need both prev_ and next_ at all. it doesn't seem like you're doing anything anywhere that would require them to be separate from each other.
2021-10-31 17:22:46 +0100 <jil> yep you are correct kosmikus... and I should correct that. Thank you.
2021-10-31 17:24:09 +0100fendor_(~fendor@77.119.160.25.wireless.dyn.drei.com) (Remote host closed the connection)
2021-10-31 17:24:53 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-10-31 17:25:22 +0100fendor(~fendor@77.119.160.25.wireless.dyn.drei.com)
2021-10-31 17:26:00 +0100__monty__(~toonn@user/toonn)
2021-10-31 17:27:34 +0100 <jil> this is better https://paste.debian.net/1217486/ Merci
2021-10-31 17:28:13 +0100Vajb(~Vajb@ndtzwggz0g23egfbw-2.v6.elisa-mobile.fi)
2021-10-31 17:30:40 +0100 <jil> Is the way I user `LANGUAGE MultiWayIf` ok with your own style of coding. Or is my case too simple for it ? I sometime see haskell code with a load of options at the top and coming from python I find it strange. What's your point of view on this coding options ?
2021-10-31 17:32:35 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-10-31 17:33:05 +0100 <dsal> You mean language extensions? You can choose the ones that are right for you. Some are sort of "this should be on" and some are a bit stranger. I don't think I've ever been tempted to use MultiWayIf, but GHC2021 looks like this: https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/control.html
2021-10-31 17:33:54 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 17:35:49 +0100 <jil> Thank you dsal
2021-10-31 17:36:52 +0100fizzsegfaultbuzz(~segfaultf@135-180-0-138.static.sonic.net)
2021-10-31 17:42:38 +0100alx741(~alx741@181.196.69.253) (Quit: alx741)
2021-10-31 17:49:53 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com)
2021-10-31 17:51:37 +0100econo(uid147250@user/econo)
2021-10-31 17:53:04 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Remote host closed the connection)
2021-10-31 17:56:39 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-31 17:56:43 +0100gehmehgeh(~user@user/gehmehgeh)
2021-10-31 17:59:47 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 264 seconds)
2021-10-31 18:00:41 +0100DNH(~DNH@8.43.122.53) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-10-31 18:03:01 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Ping timeout: 245 seconds)
2021-10-31 18:03:25 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-10-31 18:03:37 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-10-31 18:04:04 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 18:05:43 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-10-31 18:08:50 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 260 seconds)
2021-10-31 18:09:18 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 18:10:06 +0100mmhat(~mmh@55d4be88.access.ecotel.net) (Quit: WeeChat 3.3)
2021-10-31 18:15:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-10-31 18:15:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-10-31 18:15:55 +0100wroathe(~wroathe@user/wroathe)
2021-10-31 18:16:24 +0100Null_A(~null_a@2601:645:8700:2290:714b:c982:dcb8:3f01) (Remote host closed the connection)
2021-10-31 18:17:33 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d)
2021-10-31 18:20:16 +0100JimL(~quassel@89-162-2-132.fiber.signal.no) (Ping timeout: 260 seconds)
2021-10-31 18:20:34 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2021-10-31 18:23:08 +0100JimL(~quassel@89-162-2-132.fiber.signal.no)
2021-10-31 18:25:16 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d) (Quit: Leaving)
2021-10-31 18:36:03 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 18:41:30 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Ping timeout: 260 seconds)
2021-10-31 18:42:31 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 18:42:49 +0100jil(~user@160.120.146.111) (Remote host closed the connection)
2021-10-31 18:44:00 +0100lbseale(~lbseale@user/ep1ctetus)
2021-10-31 18:44:20 +0100akspecs__(~akspecs@136-24-214-166.cab.webpass.net)
2021-10-31 18:44:20 +0100akspecs__(~akspecs@136-24-214-166.cab.webpass.net) (Changing host)
2021-10-31 18:44:20 +0100akspecs__(~akspecs@user/akspecs)
2021-10-31 18:44:49 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:d4e:dbb8:1851:3894) (Remote host closed the connection)
2021-10-31 18:45:02 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2021-10-31 18:46:10 +0100lbseale_(~lbseale@user/ep1ctetus)
2021-10-31 18:46:41 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2021-10-31 18:47:34 +0100lbseale__(~lbseale@user/ep1ctetus)
2021-10-31 18:48:58 +0100xff0x(~xff0x@2001:1a81:5344:9700:9e27:fb01:4b2b:d1ea) (Ping timeout: 260 seconds)
2021-10-31 18:49:36 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2)
2021-10-31 18:49:49 +0100xff0x(~xff0x@2001:1a81:5344:9700:97c:3a82:54b0:a6da)
2021-10-31 18:49:58 +0100lbseale(~lbseale@user/ep1ctetus) (Ping timeout: 260 seconds)
2021-10-31 18:51:22 +0100lbseale_(~lbseale@user/ep1ctetus) (Ping timeout: 260 seconds)
2021-10-31 18:51:57 +0100peterhil(~peterhil@dsl-hkibng32-54fb56-2.dhcp.inet.fi)
2021-10-31 18:56:48 +0100mei(~mei@user/mei) (Read error: Connection reset by peer)
2021-10-31 18:57:59 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net) (Ping timeout: 264 seconds)
2021-10-31 19:00:30 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Read error: Connection reset by peer)
2021-10-31 19:00:35 +0100Midjak(~Midjak@82-65-111-221.subs.proxad.net) (Quit: Leaving)
2021-10-31 19:00:43 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net)
2021-10-31 19:01:11 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349)
2021-10-31 19:02:09 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-10-31 19:03:09 +0100DNH(~DNH@8.43.122.53)
2021-10-31 19:04:03 +0100aegon(~mike@174.127.249.180)
2021-10-31 19:04:36 +0100eco_eco
2021-10-31 19:04:45 +0100SethTisue__(sid14912@ilkley.irccloud.com) (Ping timeout: 260 seconds)
2021-10-31 19:06:23 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net) (Ping timeout: 264 seconds)
2021-10-31 19:07:56 +0100SethTisue__(sid14912@id-14912.ilkley.irccloud.com)
2021-10-31 19:18:35 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-31 19:22:17 +0100Midjak(~Midjak@82-65-111-221.subs.proxad.net)
2021-10-31 19:26:12 +0100catman(~catman@user/catman) (Quit: WeeChat 3.4-dev)
2021-10-31 19:26:36 +0100gehmehgeh(~user@user/gehmehgeh)
2021-10-31 19:37:44 +0100hendursa1(~weechat@user/hendursaga) (Quit: hendursa1)
2021-10-31 19:38:21 +0100hendursaga(~weechat@user/hendursaga)
2021-10-31 19:41:47 +0100euandreh(~euandreh@2804:14c:33:9fe5:eba7:95bb:d099:a7d8) (Ping timeout: 264 seconds)
2021-10-31 19:43:50 +0100alx741(~alx741@181.196.69.253)
2021-10-31 19:45:03 +0100hendursaga(~weechat@user/hendursaga) (Remote host closed the connection)
2021-10-31 19:45:30 +0100hendursaga(~weechat@user/hendursaga)
2021-10-31 19:47:28 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2021-10-31 19:51:18 +0100catman(~catman@user/catman)
2021-10-31 19:55:14 +0100lbseale__(~lbseale@user/ep1ctetus) (Ping timeout: 260 seconds)
2021-10-31 20:01:39 +0100fvr(uid503686@id-503686.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2021-10-31 20:05:00 +0100Sgeo(~Sgeo@user/sgeo)
2021-10-31 20:05:45 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 20:10:38 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 260 seconds)
2021-10-31 20:23:44 +0100jacks4(~bc8165b6@cerf.good1.com) (Quit: CGI:IRC (Session timeout))
2021-10-31 20:27:39 +0100notzmv(~zmv@user/notzmv) (Read error: Connection reset by peer)
2021-10-31 20:29:42 +0100notzmv(~zmv@user/notzmv)
2021-10-31 20:31:26 +0100acidsys(~LSD@2.lsd.systems) (Excess Flood)
2021-10-31 20:32:01 +0100acidsys(~LSD@2.lsd.systems)
2021-10-31 20:32:06 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-10-31 20:33:15 +0100xff0x(~xff0x@2001:1a81:5344:9700:97c:3a82:54b0:a6da) (Ping timeout: 260 seconds)
2021-10-31 20:33:34 +0100shailangsa(~shailangs@host217-39-45-200.range217-39.btcentralplus.com) (Remote host closed the connection)
2021-10-31 20:35:21 +0100xff0x(~xff0x@2001:1a81:5344:9700:97c:3a82:54b0:a6da)
2021-10-31 20:40:17 +0100proboscis(~proboscis@115-189-83-206.mobile.spark.co.nz) (Ping timeout: 264 seconds)
2021-10-31 20:40:49 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz)
2021-10-31 20:48:17 +0100yrlnry(~mjd@pool-74-109-22-90.phlapa.fios.verizon.net)
2021-10-31 20:50:27 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2) (Remote host closed the connection)
2021-10-31 20:52:18 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2)
2021-10-31 20:57:50 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349) (Remote host closed the connection)
2021-10-31 20:57:51 +0100neurocyte0132889(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-10-31 21:00:08 +0100 <maerwald> MultiWayIf and LambdaCase I usually enable globally
2021-10-31 21:02:24 +0100neurocyte0132889(~neurocyte@45.93.111.195)
2021-10-31 21:02:24 +0100neurocyte0132889(~neurocyte@45.93.111.195) (Changing host)
2021-10-31 21:02:24 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-10-31 21:05:11 +0100juhp(~juhp@128.106.188.220) (Ping timeout: 264 seconds)
2021-10-31 21:05:12 +0100Vajb(~Vajb@ndtzwggz0g23egfbw-2.v6.elisa-mobile.fi) (Read error: Connection reset by peer)
2021-10-31 21:05:46 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-10-31 21:06:17 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2021-10-31 21:07:35 +0100juhp(~juhp@128.106.188.220)
2021-10-31 21:07:42 +0100 <yushyin> curious to see how many will replace multiwayif with lambdacases
2021-10-31 21:08:59 +0100 <geekosaur> mm, thye're not really either/or, MultiWayIf doesn't consume a parameter whereas LambdaCase does
2021-10-31 21:09:31 +0100 <yushyin> lambdacases, plural
2021-10-31 21:09:54 +0100rick_feynmann(~nick_all@139.102.124.132)
2021-10-31 21:10:34 +0100 <yushyin> geekosaur: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0302-cases.rst yet another syntax extension :&
2021-10-31 21:12:03 +0100lambdap(~lambdap@static.167.190.119.168.clients.your-server.de) (Quit: lambdap)
2021-10-31 21:12:22 +0100lambdap(~lambdap@static.167.190.119.168.clients.your-server.de)
2021-10-31 21:14:38 +0100 <rick_feynmann> so is there like a rules list or anything like that? first time in a irc chat. learning haskell and just learned about this channel. thought it would be nice to get away from the toxic kids in discord and learn some haskell and see what other developers are up to
2021-10-31 21:15:23 +0100 <maerwald> toxic kids on discord? :D
2021-10-31 21:15:27 +0100 <juri_> rule #1: don't be as asshole. :)
2021-10-31 21:15:34 +0100alx741(~alx741@181.196.69.253) (Ping timeout: 260 seconds)
2021-10-31 21:15:47 +0100 <hpc> pretty much just the network rules
2021-10-31 21:16:09 +0100 <rick_feynmann> ok that makes sense. just checking
2021-10-31 21:16:40 +0100 <geekosaur> https://wiki.haskell.org/IRC_channel#Principles
2021-10-31 21:17:11 +0100 <geekosaur> and yes, basically "don't be a dick"
2021-10-31 21:17:24 +0100 <maerwald> good to see haskell wiki still exists
2021-10-31 21:17:45 +0100 <hpc> neat, that third bullet point is official rules
2021-10-31 21:18:34 +0100 <hololeap> anyone know of a way I can disable a line of doctest testing while keeping the same haddock formatting?
2021-10-31 21:19:21 +0100rick_feynmann(~nick_all@139.102.124.132) (Quit: Leaving)
2021-10-31 21:19:22 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz) (Read error: Connection reset by peer)
2021-10-31 21:19:32 +0100 <sm> >>> -- ... ?
2021-10-31 21:20:01 +0100 <maerwald> you could probably just shadow the function in the setup directive
2021-10-31 21:20:29 +0100 <maerwald> at least with cabal-docspec that's possible I think
2021-10-31 21:20:57 +0100 <hololeap> shadow the function?
2021-10-31 21:21:00 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-10-31 21:21:01 +0100 <maerwald> or make a dummy function with trailing underscore
2021-10-31 21:21:07 +0100 <maerwald> that does nothing
2021-10-31 21:21:27 +0100jinsun__(~quassel@user/jinsun)
2021-10-31 21:22:07 +0100rick_feynmann(~nick_all@139.102.124.132)
2021-10-31 21:22:17 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz)
2021-10-31 21:23:47 +0100MQ-17J(~MQ-17J@8.6.144.203) (Read error: Connection reset by peer)
2021-10-31 21:24:41 +0100jinsun(~quassel@user/jinsun) (Ping timeout: 245 seconds)
2021-10-31 21:24:41 +0100MQ-17J(~MQ-17J@8.6.144.203)
2021-10-31 21:24:54 +0100rick_feynmann(~nick_all@139.102.124.132) (Quit: Leaving)
2021-10-31 21:24:58 +0100 <maerwald> yes, works with cabal-docspec
2021-10-31 21:25:29 +0100 <maerwald> -- $setup
2021-10-31 21:25:30 +0100 <maerwald> >>> let shadowedFunct _ _ = False
2021-10-31 21:25:47 +0100 <maerwald> sth like that
2021-10-31 21:28:13 +0100alx741(~alx741@181.196.69.253)
2021-10-31 21:28:15 +0100shailangsa(~shailangs@host217-39-45-200.range217-39.btcentralplus.com)
2021-10-31 21:29:07 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz) (Read error: Connection reset by peer)
2021-10-31 21:29:55 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz)
2021-10-31 21:33:00 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Quit: FinnElija)
2021-10-31 21:34:56 +0100cjb(~cjbayliss@user/cjb)
2021-10-31 21:35:03 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 21:36:16 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-10-31 21:36:37 +0100 <hololeap> this is what fails: https://github.com/dhall-lang/dhall-haskell/blob/master/dhall-toml/src/Dhall/DhallToToml.hs#L218-L…
2021-10-31 21:37:47 +0100 <hololeap> this is the error I get: http://sprunge.us/nrvtl0
2021-10-31 21:38:40 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-10-31 21:39:04 +0100 <hololeap> I'm trying to package dhall-toml for gentoo and while I know it is silly to disable a test that isn't passing, as long as I have it well documented it makes sense, considering every other test passes.
2021-10-31 21:39:56 +0100 <sclv> if the test isn't passing you should file a ticket -- it seems like their error!
2021-10-31 21:40:16 +0100 <hololeap> yeah, but in the meantime, I want to package this
2021-10-31 21:41:05 +0100 <sclv> then remove the formatting from the block in the meantime, or change the test so it passes
2021-10-31 21:41:48 +0100catman(~catman@user/catman) (Read error: Connection reset by peer)
2021-10-31 21:42:03 +0100NoidedSuper(~manjaro-u@2601:280:5a81:520::f8be)
2021-10-31 21:42:04 +0100geekosaurwonders if the latter is reliably possible
2021-10-31 21:42:14 +0100 <sclv> afaik there's no way to leave the cmd exactly the same and fully disable the test.
2021-10-31 21:42:17 +0100 <sclv> er the haddock
2021-10-31 21:42:24 +0100mvk(~mvk@2607:fea8:5cc1:300::d3fb)
2021-10-31 21:42:28 +0100 <geekosaur> if it's say using HashMap is it guaranteed to use the same order every time?
2021-10-31 21:42:47 +0100 <Hecate> https://www.reddit.com/r/haskell/comments/qjxjh5/ann_jordan_abstract_inspectable_json/
2021-10-31 21:42:50 +0100 <Hecate> noice
2021-10-31 21:42:51 +0100 <sclv> i suspect in this case its swapped the hashmap for the ordmap in the latest, so its more reliable now!
2021-10-31 21:43:15 +0100 <sclv> (latest aeson)
2021-10-31 21:43:48 +0100 <hololeap> yeah, it's a hashmap, it seems: https://hackage.haskell.org/package/tomland-1.3.3.0/docs/Toml-Type-TOML.html#t:TOML
2021-10-31 21:44:06 +0100 <NoidedSuper> That Jordan library looks sick Hecate, I bet the guy who wrote it is smart and attractive
2021-10-31 21:44:31 +0100 <NoidedSuper> (I wrote it :D. You have no idea how hype I am that people are finding it cool enough to share)
2021-10-31 21:46:42 +0100econo(uid147250@user/econo)
2021-10-31 21:46:50 +0100 <hololeap> which explains why it fails with the inner list being out of order
2021-10-31 21:47:43 +0100fog(~fog@176-157-77-163.abo.bbox.fr)
2021-10-31 21:48:15 +0100catman(~catman@user/catman)
2021-10-31 21:50:16 +0100fog(~fog@176-157-77-163.abo.bbox.fr) (Client Quit)
2021-10-31 21:50:31 +0100fen(~fen@176-157-77-163.abo.bbox.fr)
2021-10-31 21:50:57 +0100euandreh(~euandreh@2804:14c:33:9fe5:af93:19b0:8b26:3fa2)
2021-10-31 21:51:17 +0100fen(~fen@176-157-77-163.abo.bbox.fr) (Client Quit)
2021-10-31 21:51:34 +0100motle(~motle@176-157-77-163.abo.bbox.fr)
2021-10-31 21:51:40 +0100motle(~motle@176-157-77-163.abo.bbox.fr) (Client Quit)
2021-10-31 21:52:10 +0100dartford(~dartford@176-157-77-163.abo.bbox.fr)
2021-10-31 21:52:20 +0100 <dartford> hi!
2021-10-31 21:52:45 +0100 <dartford> >700 users online! iv never seen it so busy
2021-10-31 21:52:52 +0100 <dartford> anyone active?
2021-10-31 21:52:59 +0100 <geekosaur> yes
2021-10-31 21:53:03 +0100 <dartford> woop!
2021-10-31 21:53:14 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349)
2021-10-31 21:53:17 +0100 <geekosaur> and we've been riding over 700 users for a couple of months now
2021-10-31 21:53:31 +0100chomwitt(~chomwitt@ppp-2-85-245-90.home.otenet.gr) (Read error: Connection reset by peer)
2021-10-31 21:53:40 +0100 <geekosaur> the move from fn did shake out a bunch of never-active folks though
2021-10-31 21:53:49 +0100 <dartford> awesome, i want to ask about probabilistic models in streaming space models as state traversals
2021-10-31 21:54:31 +0100 <sm> some of them moved to #haskell:matrix.org
2021-10-31 21:54:43 +0100 <dartford> geekosaur: i guess there are some more people learning haskell each year, or maybe people from other languages migrating
2021-10-31 21:55:46 +0100 <dartford> basically, im not too used to using nestings of monads - with "the probability monad" etc needing to go along with the "state applicative" in the traversal
2021-10-31 21:56:17 +0100 <dartford> if it were me, id just "partition" the state, but i gather that this isnt idomatic haskell, and monad transformers or something is
2021-10-31 21:56:38 +0100 <dartford> like, keep the random seed as "part" of the state
2021-10-31 21:56:41 +0100 <dartford> somehow...
2021-10-31 21:57:07 +0100 <dartford> but i dont want to get frustrated by trying to then have a nested datatype for the state that would need its own lesnses
2021-10-31 21:57:20 +0100 <dartford> does that make sense?
2021-10-31 21:57:45 +0100 <Rembane_> dartford: What stops you from having the state as an argument to the functions working on it?
2021-10-31 21:57:54 +0100 <dartford> pardon?
2021-10-31 21:58:09 +0100 <dartford> im not sure what you mean, or why you think im saying that
2021-10-31 21:58:53 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-10-31 21:59:24 +0100 <Rembane_> I don't think I'm understanding what the problem you are trying to solve is, which makes me ask the wrong question. Sorry about that.
2021-10-31 21:59:28 +0100 <dartford> :t mapAccumL
2021-10-31 21:59:29 +0100 <lambdabot> Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
2021-10-31 21:59:43 +0100 <dartford> the state is `a' there, the functions act on it just fine
2021-10-31 21:59:55 +0100 <dartford> this is the archetypal "state traversal"
2021-10-31 22:00:11 +0100 <dartford> ie, traverse, but where the applicative is chosen to be StateL
2021-10-31 22:01:01 +0100 <dartford> what im saying is i would replace the polymorphic type `a' by something with a lens into the "seed" for an RNG that allows PDFs to be worked with
2021-10-31 22:01:16 +0100mestre(~mestre@191.177.175.57)
2021-10-31 22:01:32 +0100 <dartford> so that on each encountered element, the new seed can be updated into its portion of the state
2021-10-31 22:02:11 +0100 <dartford> normally people use monad transformers for this partitioning of reader/writer/state monads
2021-10-31 22:02:28 +0100 <dartford> instead of lenses into the "seed part"
2021-10-31 22:02:36 +0100 <dartford> see what i mean?
2021-10-31 22:03:07 +0100 <dartford> im confused about if im supposed to use lenses or nested monads or what
2021-10-31 22:03:34 +0100 <hololeap> It seems like you just want a regular State monad to me
2021-10-31 22:03:52 +0100 <dartford> thats already factored into mapAccumL
2021-10-31 22:03:59 +0100 <dartford> really i should be using traverse, sorry
2021-10-31 22:04:02 +0100 <dartford> :t traverse
2021-10-31 22:04:03 +0100 <lambdabot> (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
2021-10-31 22:04:17 +0100zebrag(~chris@user/zebrag)
2021-10-31 22:04:41 +0100 <dartford> so thats `f' in the type signature, which should hold both the RNG seed, and anything else thats an "updated carry"
2021-10-31 22:05:10 +0100 <dartford> i guess its a question about composite data, and nested datatypes vs monad transformers
2021-10-31 22:05:53 +0100 <dartford> ie, it would be a composition of monads that would still have the applicative instance of StateL to allow it to scan properly
2021-10-31 22:06:00 +0100 <dartford> i think...
2021-10-31 22:07:50 +0100 <hololeap> % :t \f -> runState . traverse (state . f)
2021-10-31 22:07:50 +0100 <yahb> hololeap: Traversable t => (a -> s -> (b, s)) -> t a -> s -> (t b, s)
2021-10-31 22:07:55 +0100 <dartford> https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.Traversable.html#mapAccumL
2021-10-31 22:08:20 +0100 <dartford> ah, your implementation is much better, it doesnt use coerce
2021-10-31 22:08:22 +0100 <dartford> thanks
2021-10-31 22:08:23 +0100 <hololeap> so you are correct that mapAccum is the same as traverse over some State
2021-10-31 22:08:42 +0100 <dartford> thats why i was calling it a "state traversal" - basically a scanner
2021-10-31 22:09:02 +0100 <dartford> and im calling the `s' variable a "carried state"
2021-10-31 22:09:13 +0100 <dartford> and the whole thing is a "streaming state space model"
2021-10-31 22:09:20 +0100 <hololeap> but I think you might be overcomplicating things. what you're looking for doesn't need a huge monad transformer stack
2021-10-31 22:09:34 +0100 <dartford> since StateL is lazy, so it can work over infinite streams, unlike plain old traverse
2021-10-31 22:09:50 +0100 <dartford> i think theres a superclass proposal in their somewhere
2021-10-31 22:10:17 +0100 <dartford> hololeap: sure, i mean, i could use a lens, but thats more complicated right?
2021-10-31 22:10:23 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2021-10-31 22:10:37 +0100 <dartford> like, i was assuming the monad transformer stack way was actually easyer than the nested datatype way then
2021-10-31 22:10:53 +0100 <dartford> since there is some subtle handling of the algebra of monadic composition or something
2021-10-31 22:10:57 +0100 <hololeap> no, none of this stuff is complicated. it's quite basic really, perhaps more basic than you're expecting
2021-10-31 22:10:58 +0100 <dartford> i never fully understood it
2021-10-31 22:11:22 +0100 <dartford> ok, so that way you need the existance of a lens in the constraint
2021-10-31 22:11:29 +0100ec(~ec@gateway/tor-sasl/ec)
2021-10-31 22:11:47 +0100 <hololeap> @hoogle zoom
2021-10-31 22:11:47 +0100 <lambdabot> Control.Lens.Combinators zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c
2021-10-31 22:11:47 +0100 <lambdabot> Control.Lens.Zoom zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c
2021-10-31 22:11:47 +0100 <lambdabot> Diagrams.Prelude zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c
2021-10-31 22:12:00 +0100 <dartford> something like; CanUpdateTheSeed f,ApplicativesLikeStateL f =>
2021-10-31 22:12:34 +0100 <dartford> ok, lets not *actually* use lens
2021-10-31 22:12:35 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz) (Read error: Connection reset by peer)
2021-10-31 22:12:47 +0100 <dartford> i cant read those type signatures and id prefer not to have to learn how to
2021-10-31 22:12:50 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz)
2021-10-31 22:13:02 +0100 <dartford> i mean, this is the main reason im leaning towards the nested monads way
2021-10-31 22:13:14 +0100tabemann(~travisb@2600:1700:7990:24e0:95ab:c391:8962:61e4) (Remote host closed the connection)
2021-10-31 22:13:14 +0100 <hololeap> there's something that I'm looking for that you may be interested in
2021-10-31 22:13:26 +0100 <dartford> actually, i think the only way it would work is if they were both States
2021-10-31 22:13:33 +0100tabemann(~travisb@2600:1700:7990:24e0:25bd:a66c:dc78:d416)
2021-10-31 22:13:38 +0100 <hololeap> but really you will be passing some concrete state around and you should know how to modify it, with or without lenses
2021-10-31 22:13:40 +0100 <dartford> but i guess this could be relaxed to parts being only Reader or Writer
2021-10-31 22:14:44 +0100 <dartford> ok, so suppose the only thing i ever read+write is the RNG seed, but i also accumulate some data into a writer
2021-10-31 22:15:14 +0100 <dartford> like, i grow a list of accumulated elements
2021-10-31 22:15:27 +0100 <hololeap> do you even need a Writer here? do you have some monoidal data that you want to append to as a side-effect?
2021-10-31 22:15:31 +0100acidjnk(~acidjnk@p5487d843.dip0.t-ipconnect.de)
2021-10-31 22:15:45 +0100 <dartford> something like using cons to update the state, but not actually using it, in mapAccumL
2021-10-31 22:15:49 +0100 <dartford> :t mapAccumL
2021-10-31 22:15:50 +0100 <lambdabot> Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
2021-10-31 22:16:38 +0100 <dartford> i thought if you update it you need writer...
2021-10-31 22:17:04 +0100 <dartford> er, ok nvm lets just use full state
2021-10-31 22:17:15 +0100 <dartford> since it would need to be read to update it
2021-10-31 22:17:27 +0100 <dartford> :t mapAccumL (\_ b -> (b:?,undefined))
2021-10-31 22:17:28 +0100 <lambdabot> error:
2021-10-31 22:17:28 +0100 <lambdabot> A section must be enclosed in parentheses thus: (b :?)
2021-10-31 22:17:34 +0100 <dartford> oops!
2021-10-31 22:17:48 +0100 <hololeap> https://hackage.haskell.org/package/optics-extra-0.4/docs/Optics-Zoom.html
2021-10-31 22:17:50 +0100 <dartford> like, it needs the `a' not to be a wildcard above
2021-10-31 22:18:01 +0100 <dartford> hololeap: i really want to avoid lenses
2021-10-31 22:18:23 +0100 <hololeap> ok, it seemed like you were interested earlier
2021-10-31 22:18:50 +0100 <dartford> i was presenting 2 alternatives, and asking about the other
2021-10-31 22:19:05 +0100 <dartford> well, i kind of forgot how difficult i find lesnse
2021-10-31 22:19:20 +0100 <hololeap> you might like this optics library a little better
2021-10-31 22:19:29 +0100 <dartford> im sorry
2021-10-31 22:19:35 +0100Alleria(~textual@user/alleria) (Remote host closed the connection)
2021-10-31 22:19:41 +0100 <hololeap> just for future reference
2021-10-31 22:20:03 +0100 <dartford> its illegible, im sorry
2021-10-31 22:20:03 +0100proboscis(~proboscis@115-189-130-93.mobile.spark.co.nz) (Read error: Connection reset by peer)
2021-10-31 22:20:25 +0100 <hololeap> yeah it takes some getting used to, for sure, and the type signatures don't help much, unfortunately
2021-10-31 22:20:30 +0100 <dartford> even if it did exactly what i described, its impenetrable
2021-10-31 22:20:31 +0100proboscis(~proboscis@14.137.28.197)
2021-10-31 22:20:43 +0100 <dartford> none of it helps at all!
2021-10-31 22:21:08 +0100 <dartford> it has some inklings that its the right thing, suggesting you can "change part of the state"
2021-10-31 22:21:25 +0100 <dartford> but i can say that quite easily, "the rng would have its own lens"
2021-10-31 22:21:31 +0100 <dartford> i just use that term to comunicate
2021-10-31 22:21:41 +0100 <dartford> i have no intension of ever wrangling with its machinery
2021-10-31 22:22:29 +0100 <dartford> i use deep extensible generic containers instead of anything to do with records, is the actual reason for my hesitance
2021-10-31 22:22:36 +0100 <dartford> but this is an asside
2021-10-31 22:22:49 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349) (Remote host closed the connection)
2021-10-31 22:23:04 +0100 <dartford> the only relavence being, this is not yet something we have a unified approach too
2021-10-31 22:23:10 +0100 <dartford> "change that part of it"
2021-10-31 22:23:25 +0100 <dartford> easyer said than done!
2021-10-31 22:23:42 +0100 <dartford> my approach uses algebraic pointers instead of string symbol records
2021-10-31 22:23:52 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net)
2021-10-31 22:24:04 +0100 <dartford> "down 3 levels, along 2, down until the leaf" kind of thing
2021-10-31 22:24:29 +0100 <dartford> these directions are equivalent, and i spent years developing it. im not going to start on with symbolic records now
2021-10-31 22:24:49 +0100 <dartford> you cant add together records... thats why i bang on about mine being algebraic
2021-10-31 22:24:59 +0100 <dartford> navigations compose...
2021-10-31 22:25:24 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 22:25:26 +0100 <dartford> but then, when everything is an nd grid, where positions make a lot of sense,
2021-10-31 22:25:35 +0100 <dartford> and then *only one of them is special*
2021-10-31 22:25:40 +0100 <dartford> because its the RNG seed
2021-10-31 22:25:43 +0100 <dartford> i get scuppered
2021-10-31 22:26:11 +0100 <dartford> i figured the easyest way would just be to wrap it up in the probability monad
2021-10-31 22:26:24 +0100 <dartford> and do the monad transformer stack way instead
2021-10-31 22:26:51 +0100 <hololeap> what you're calling "the probability monad" is just State carrying around some random seed, right?
2021-10-31 22:27:02 +0100 <dartford> (instead, of having the seed as part of the datatype, and reserving that extensible domain for the euclidian grid)
2021-10-31 22:27:04 +0100 <hololeap> and perhaps some other info
2021-10-31 22:27:23 +0100 <dartford> hololeap: exactly, essentially just a tuple with an Int, nothing that should be too difficult...
2021-10-31 22:27:26 +0100proboscis(~proboscis@14.137.28.197) (Ping timeout: 260 seconds)
2021-10-31 22:27:43 +0100 <dartford> (Int,BigCrazyExtensibleGraphThing)
2021-10-31 22:27:45 +0100proboscis(~proboscis@14.137.28.197)
2021-10-31 22:27:53 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-10-31 22:28:17 +0100 <dartford> its just, this form of "extension", pairing it with the seed int, isnt the same way as the graph is extended
2021-10-31 22:28:20 +0100 <sclv> that seems very reasonable
2021-10-31 22:28:34 +0100 <dartford> cheers!
2021-10-31 22:28:35 +0100yauhsien(~yauhsien@61-231-61-245.dynamic-ip.hinet.net) (Ping timeout: 264 seconds)
2021-10-31 22:28:44 +0100 <dartford> so wtf do i do!?
2021-10-31 22:29:16 +0100 <sclv> what do you mean. you just described what you do
2021-10-31 22:29:24 +0100 <sclv> you have a state monad that has a pair in the state
2021-10-31 22:29:37 +0100 <dartford> i mean, i dont know how to work with monad transformers
2021-10-31 22:29:46 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Remote host closed the connection)
2021-10-31 22:29:50 +0100 <sclv> you don't need a transformer if you just have a single state with a pair in the state
2021-10-31 22:30:08 +0100 <dartford> i reccon to presereve the lazy StateL business, for the stream transduction, so i need a similar Applicative instance for the (Int,)
2021-10-31 22:30:32 +0100 <dartford> sclv: oh, i think i was anticipating its partial application
2021-10-31 22:30:37 +0100img(~img@user/img)
2021-10-31 22:30:47 +0100 <dartford> like, so i could do "probabilistic scanning"
2021-10-31 22:30:57 +0100 <dartford> as a thing that was already abstracted
2021-10-31 22:31:02 +0100 <dartford> if that makes any sense at all
2021-10-31 22:31:17 +0100 <dartford> like, handling this "top layer" already
2021-10-31 22:31:20 +0100 <sclv> just follow the types -- you can adapt any functions that worked over the old state to work over one component of the tuple
2021-10-31 22:31:25 +0100 <dartford> ie, having to partition it into layers
2021-10-31 22:31:38 +0100 <dartford> thats why i was considering the monad transformer stack to begin with
2021-10-31 22:32:11 +0100proboscis(~proboscis@14.137.28.197) (Ping timeout: 264 seconds)
2021-10-31 22:32:36 +0100 <dartford> sclv: i want to compose two lazy "StateL style" applicatives together to get a new lazy StateL applicative style thing
2021-10-31 22:32:48 +0100 <dartford> so the scanners work
2021-10-31 22:32:55 +0100 <sclv> what is a StateL
2021-10-31 22:33:00 +0100 <sclv> also applicatives compose directly
2021-10-31 22:33:02 +0100 <dartford> if the applicative instances dont *compose* then this wont work
2021-10-31 22:33:13 +0100 <dartford> they are different instances
2021-10-31 22:33:20 +0100 <dartford> and a new instance is required for their nesting
2021-10-31 22:33:27 +0100 <sclv> https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Functor-Compose.html#t:Compose
2021-10-31 22:33:30 +0100 <dartford> thats the kind of composition i mean. not <*>
2021-10-31 22:34:05 +0100 <dartford> oh, sorry, you were talking about the same form of composition...
2021-10-31 22:34:15 +0100 <dartford> im just concerned it wont preserve the lazyness
2021-10-31 22:34:29 +0100 <sclv> if you don't need monad composition, just applicative composition, it comes via Compose, no transformers necessary
2021-10-31 22:34:29 +0100 <dartford> not all applicatives end up producing lazy traversals, but StateL does...
2021-10-31 22:34:39 +0100 <dartford> nice!
2021-10-31 22:34:41 +0100 <dartford> thanks
2021-10-31 22:34:49 +0100 <dartford> what about the lazyness consideration though?
2021-10-31 22:35:01 +0100 <dartford> i guess they are both StateL actually...
2021-10-31 22:35:18 +0100 <dartford> does that have its own rule for how it forms a new applicative via use of Compose?
2021-10-31 22:35:44 +0100 <dartford> like, StateL is basically just a tuple at the end of the day, iirc
2021-10-31 22:36:00 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 22:36:07 +0100 <dartford> so it should work for how i want it to handle the RNG seed
2021-10-31 22:36:10 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349)
2021-10-31 22:36:15 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 22:36:21 +0100 <sclv> your description is both very specific and vague
2021-10-31 22:36:22 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-10-31 22:36:31 +0100 <sclv> take a look at the source and try it out and see if it works how you expect https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Functor-Compose.html#t:Compose
2021-10-31 22:36:41 +0100 <dartford> basically, this describes an extensible deep datatype equivalent, instead of nested pairs, as nested StateL applicatives
2021-10-31 22:37:01 +0100 <dartford> motivated by its use for scanning
2021-10-31 22:37:05 +0100 <dartford> (!)
2021-10-31 22:37:14 +0100 <dartford> (seems like a result, right?)
2021-10-31 22:37:41 +0100 <dartford> Q"which kind of extensible generic lens thingy do i need" ?
2021-10-31 22:37:52 +0100 <dartford> A: nested StateL applicatives using Compose
2021-10-31 22:38:00 +0100 <dartford> peer review?#
2021-10-31 22:38:35 +0100 <dartford> what do you reccon?
2021-10-31 22:39:03 +0100 <sclv> i genuinely can't follow. just try what i suggested and post some much more specific actual code in a pastebin if you need more advice.
2021-10-31 22:39:18 +0100 <dartford> peer review denied.
2021-10-31 22:39:23 +0100 <dartford> ok, thanks for the help
2021-10-31 22:40:10 +0100 <dartford> really hate it when that happens!
2021-10-31 22:40:31 +0100 <dartford> anyone that understood could chip in?
2021-10-31 22:41:14 +0100 <geekosaur> I don't think any of us really understood
2021-10-31 22:42:02 +0100 <dartford> well, regardless of that assertion, im not going to be roped into another explanation if this one would do
2021-10-31 22:42:11 +0100 <dartford> like, maybe you just cant be bothered, idk!
2021-10-31 22:42:25 +0100 <dartford> this is bat country
2021-10-31 22:42:39 +0100 <dartford> rabbit holes must be avoided
2021-10-31 22:43:14 +0100 <geekosaur> it's not that we can't be bothered, it's that your attempts at describing what you're doing is really confusing. like you're not quite speaking the same language we do
2021-10-31 22:44:03 +0100 <geekosaur> I've been sitting here trying to follow the discussion and just getting more and more confused as it went on
2021-10-31 22:46:54 +0100Jing_(~textual@103.121.208.115) (Remote host closed the connection)
2021-10-31 22:47:09 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349) (Remote host closed the connection)
2021-10-31 22:47:31 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d)
2021-10-31 22:49:34 +0100 <dartford> hmm, thats quite bad
2021-10-31 22:50:14 +0100nickkkkk_all(~nick_all@139.102.124.132)
2021-10-31 22:50:39 +0100 <dartford> i thought the conclusion that the compositional thing i was after, wasnt a monad transformer stack, or a deep nested record, but was Applicatives - specifically StateL, composed using Data.Functor.Compose - seemed like a really good result
2021-10-31 22:50:56 +0100 <dartford> and then your like "dude, i cant follow, spoonfeed us"
2021-10-31 22:51:39 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:54f0:825c:9f33:c349)
2021-10-31 22:51:44 +0100 <dsal> Sometimes when communication isn't effective, the communicator needs to do a better job.
2021-10-31 22:51:47 +0100 <dartford> erm, oh right, maybe you dont understand why StateL is motivated by scanners, aka "state traversals" - for lazy compositional stream transduction
2021-10-31 22:52:24 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-10-31 22:52:35 +0100 <dartford> dsal: great advice, in general. but totally useless in an actual setting where specific inquisitiveness would be required to try to fathom what was so apparently difficult to understand
2021-10-31 22:52:49 +0100 <dartford> otherwise im just left guessing
2021-10-31 22:52:57 +0100 <dartford> maybe thats direction enough, but not for me
2021-10-31 22:53:15 +0100 <geekosaur> well, for one example you keep saying "lens" but I keep getting the impression you don't mean the same thing we do when we say it
2021-10-31 22:53:17 +0100 <dsal> When nobody understands you, it's not everyone else who's at fault.
2021-10-31 22:53:24 +0100 <dartford> "frustrate them towards their goal" being, like, kind of, suboptimal from *my* perspective
2021-10-31 22:53:26 +0100 <hololeap> it seems to me that you are over-abstracting the problem which leads to overly-complex ideas like BigCrazyExtensibleGraphThing and "probabilistic scanning". work on refining it until you have NiceEasyToUnderstandAndExplainThing
2021-10-31 22:53:36 +0100ksu(~ksu@user/prtr) (End of Transmission Block)
2021-10-31 22:53:56 +0100 <dartford> geekosaur: seems like lens "means" - i can get at part of it
2021-10-31 22:54:26 +0100 <hololeap> lens is really just a convenience thing. they don't do anything that you couldn't already do without them
2021-10-31 22:54:34 +0100 <dartford> if thats a confusing way to use the word ill opt for a disambiguation, but since this seems like what we understand it to mean, i dont think thats nesacary
2021-10-31 22:54:52 +0100 <dartford> i just have to explain that i dont want to actually use someone elses machinery since im developing my own
2021-10-31 22:54:54 +0100tabemann(~travisb@2600:1700:7990:24e0:25bd:a66c:dc78:d416) (Quit: Leaving)
2021-10-31 22:55:10 +0100 <dartford> well, its motivated by scanning
2021-10-31 22:55:11 +0100 <geekosaur> "lens" describes a specific data access mechanism based on van Laarhoven lenses
2021-10-31 22:55:25 +0100 <dartford> we wouldnt have arived at Comosed StateL applicatives without that as the specifying thing
2021-10-31 22:55:40 +0100 <dartford> and basically, what we end up constructing is a "BIGCRAZYEXTENSIBLETHING"
2021-10-31 22:55:48 +0100 <dartford> so no, i dont think those are superflous notions
2021-10-31 22:55:55 +0100 <dartford> they are infact, almost all of the actual thing
2021-10-31 22:56:04 +0100 <geekosaur> there are some other varieties but they all do the same basic thing, they're a specific way to access data, not a general/vague description of accessing data
2021-10-31 22:56:32 +0100 <dartford> geekosaur: yeah exactly, a getter and a setter, being able to access part of the thing
2021-10-31 22:56:41 +0100 <dartford> "access"
2021-10-31 22:56:41 +0100tabemann(~tabemann@2600:1700:7990:24e0:25bd:a66c:dc78:d416)
2021-10-31 22:56:54 +0100 <dartford> "lens" into it
2021-10-31 22:57:09 +0100 <dartford> its a common term and im using it correctly
2021-10-31 22:57:33 +0100 <dartford> but, no records, please
2021-10-31 22:58:04 +0100 <dartford> if the RNG seed is on the outer layer, i will use this *positional* information only
2021-10-31 22:58:13 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2) (Remote host closed the connection)
2021-10-31 22:58:16 +0100 <dartford> layered pairs essentially
2021-10-31 22:58:19 +0100 <dartford> everything is
2021-10-31 22:58:34 +0100 <dartford> thats why its what your true love gives to you on the first day of christmas
2021-10-31 22:58:42 +0100 <dartford> "part"ridges, in *pair* trees
2021-10-31 22:58:53 +0100mestre(~mestre@191.177.175.57) (Quit: Lost terminal)
2021-10-31 22:59:00 +0100 <dartford> deep theorm there, but just a mnemonic
2021-10-31 23:00:02 +0100 <dartford> im just contesting having to write carrot underscore RNG_ update zoom underscore
2021-10-31 23:00:19 +0100 <dartford> which i dont believe is at all legible
2021-10-31 23:00:32 +0100 <dartford> "update the outer layer, remember which layer is which"
2021-10-31 23:00:39 +0100 <dartford> is my preferred approach
2021-10-31 23:01:19 +0100 <dartford> anyway, this is why i refuse to be gauded into further explanations, my first one was fine
2021-10-31 23:01:26 +0100 <dartford> now im just getting pissed
2021-10-31 23:01:30 +0100 <dartford> i appologise
2021-10-31 23:03:01 +0100 <dartford> i guess really my problem is that in an ND cartesian domain, which has easily interpretable "dimension" as the layers, having the outer layer as a plain Int is totally different, so doesnt fit into my usual abstraction as every nesting being wrapping in a list
2021-10-31 23:03:23 +0100 <dartford> now its pairing with an int instead of wrapping with a list, so i get confused, but i guess the notion of position is still good
2021-10-31 23:03:29 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 23:03:31 +0100 <dartford> how deep it is, being what im calling position
2021-10-31 23:04:39 +0100 <dartford> ahhh
2021-10-31 23:04:55 +0100 <dartford> yeah its quite reasonable im concerned, a pair is essentially a length restricted list
2021-10-31 23:05:13 +0100 <dartford> im used to always being able to say "go down a bit, go along a bit, go down a bit more" etc
2021-10-31 23:05:21 +0100 <dartford> but with a pair there is no "going along a bit"
2021-10-31 23:05:35 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2)
2021-10-31 23:05:40 +0100 <dartford> i suppose if i have extent restricted layers, it would just throw a type error if i tried to "go along"
2021-10-31 23:05:42 +0100nickkkkk_all(~nick_all@139.102.124.132) (Ping timeout: 260 seconds)
2021-10-31 23:05:45 +0100 <dartford> on the Int level
2021-10-31 23:06:10 +0100 <dsal> You're gonna have a pretty hard time in general if you continue to assert that you're good at explaining things while ignoring evidence from people who fail to understand your explanations.
2021-10-31 23:06:30 +0100 <hololeap> I think Data.Tree (rose trees) would model an n-dimensional cartesian domain just fine, wouldn't they?
2021-10-31 23:06:31 +0100 <dartford> er, actually yeah, you do have the option to "go along" either the first or second element, so i can just use the same concept of typesafe navigation
2021-10-31 23:06:50 +0100dsalgoes to play with chainsaws instead
2021-10-31 23:06:53 +0100lavaman(~lavaman@98.38.249.169)
2021-10-31 23:07:31 +0100 <dartford> thanks for that. im just saying, when i ask for help, you say "do more work - we cant understand" and im like "that wouldnt actually help"
2021-10-31 23:07:43 +0100 <dartford> see what i mean...
2021-10-31 23:07:49 +0100 <dartford> "no, we dont"
2021-10-31 23:08:03 +0100 <dartford> and im like "dsal, wait for me, i want to play too"
2021-10-31 23:08:11 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk) (Ping timeout: 264 seconds)
2021-10-31 23:08:27 +0100 <dartford> hololeap: this is the theorem
2021-10-31 23:08:34 +0100 <dartford> all is trees
2021-10-31 23:08:36 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-10-31 23:09:00 +0100 <dartford> even if some of the branches are just pairs
2021-10-31 23:09:22 +0100 <dartford> i guess the point is youd better remember how wide the branches are everywhere
2021-10-31 23:09:32 +0100zebrag(~chris@user/zebrag)
2021-10-31 23:09:43 +0100 <dartford> which is what you get for doing away with string symbol labels, aka records
2021-10-31 23:09:53 +0100 <dartford> which is what edkmet lenses use
2021-10-31 23:10:05 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-10-31 23:10:11 +0100 <dartford> right, i finally said that comprehensibly
2021-10-31 23:10:15 +0100 <dartford> so sorry
2021-10-31 23:11:10 +0100 <hololeap> so at each node, you have zero or more child nodes, correct? and you want to memoize the number of children for each node? and also an RNG for some reason? haha
2021-10-31 23:11:27 +0100 <hololeap> trying to piece it together
2021-10-31 23:11:47 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 264 seconds)
2021-10-31 23:11:51 +0100 <dartford> one or more
2021-10-31 23:11:55 +0100 <dartford> nonempty lists
2021-10-31 23:11:59 +0100 <dartford> no "shaped empty"
2021-10-31 23:12:11 +0100 <dartford> [[],[]] is disalowed for example
2021-10-31 23:12:28 +0100 <dartford> just for the sake of it, it was a glitch i kept encountering
2021-10-31 23:12:46 +0100 <dartford> hololeap
2021-10-31 23:12:55 +0100 <dartford> its for probabalistic scanning
2021-10-31 23:13:07 +0100 <dartford> thats why we ended up with StateL where pairs used to be
2021-10-31 23:13:32 +0100 <dartford> to get the lazyness of mapAccumL
2021-10-31 23:13:44 +0100 <dartford> for lazy stream transduction
2021-10-31 23:13:49 +0100 <hololeap> ok, what would the termination state be for a each node, to say "the tree stops here". if it is required to have at least one child it would be infinite, which sounds like why you are trying to figure out this laziness thing
2021-10-31 23:14:16 +0100 <dartford> no, the length of the rose trees branches can be infinite
2021-10-31 23:14:22 +0100 <dartford> its not strictly infinite in depth
2021-10-31 23:14:26 +0100 <dartford> it can terminate at a value
2021-10-31 23:14:37 +0100 <dartford> though it can be recursive
2021-10-31 23:14:54 +0100 <dartford> but thats handled slightly differently since it has to be labled, not really whats being discussed here
2021-10-31 23:15:08 +0100 <dartford> we can stick to just considering scanning over a list for simplicity
2021-10-31 23:15:17 +0100 <dartford> a strictly infinite stream rather
2021-10-31 23:15:24 +0100 <dartford> for instance an IOList
2021-10-31 23:15:45 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-10-31 23:16:12 +0100 <dartford> like, the server can just keep returning requests, no real notion of the "end of the list"
2021-10-31 23:16:18 +0100 <dartford> so it *needs* to be lazy
2021-10-31 23:16:22 +0100 <dartford> you *cant* use traverse
2021-10-31 23:16:33 +0100 <dartford> well, unless its restricted to StateL as the applicative
2021-10-31 23:16:42 +0100 <dartford> or some other "lazy applicative"
2021-10-31 23:16:52 +0100 <dartford> some applicatives would force evaluation of the whole thing
2021-10-31 23:17:07 +0100 <dartford> thats why i talk about mapAccumL and scanners as if they are a seperate thing to traverse
2021-10-31 23:17:32 +0100 <dartford> traverse + StateL = scanners, basically
2021-10-31 23:17:52 +0100 <dartford> scanners, being always lazy, form an algebra for stream transduction
2021-10-31 23:18:10 +0100 <dartford> anyway, i forgot the question, i hope that clears something up at least
2021-10-31 23:18:18 +0100 <dartford> i dont really want to just keep explaining that point
2021-10-31 23:18:22 +0100 <dartford> but thats the central point
2021-10-31 23:18:29 +0100 <dartford> about the lazy stream algebra
2021-10-31 23:18:49 +0100 <dartford> offered by scanners, as a distinction from the rest of Traversable
2021-10-31 23:19:17 +0100 <hololeap> I wonder if something like conduit might fit your use case
2021-10-31 23:19:33 +0100 <dartford> yeah, this replaces that
2021-10-31 23:19:41 +0100 <dartford> with actual theorems
2021-10-31 23:19:45 +0100 <dartford> in idomatic haskell
2021-10-31 23:19:53 +0100 <dartford> acording to the class hierarchy of the prelude
2021-10-31 23:20:05 +0100 <dartford> scanners beat conduits!
2021-10-31 23:20:16 +0100NoidedSuper(~manjaro-u@2601:280:5a81:520::f8be) (Remote host closed the connection)
2021-10-31 23:20:49 +0100burnsidesLlama(~burnsides@dhcp168-013.wadham.ox.ac.uk)
2021-10-31 23:21:22 +0100 <dartford> its not hard to understand why. its because of that point about lazyness, that allows them to be scanned repeatedly, since each of them actually returns
2021-10-31 23:21:41 +0100 <dartford> so notionally, its as if it does one element at a time, passing it through *each* scanner applied
2021-10-31 23:21:49 +0100 <dartford> as if the scanners were algebraically composed
2021-10-31 23:22:15 +0100 <dartford> this compositionality being what conduit does, but in a much less direct way
2021-10-31 23:22:43 +0100zebrag(~chris@user/zebrag)
2021-10-31 23:22:45 +0100 <dartford> the lazyness of StateL means mapAccumL has a rewrite rule essentially
2021-10-31 23:23:18 +0100 <hololeap> so you are reading from an infinite stream, threading a random seed through, creating this tree structure along the way, and doing some sort of sliding-window calculation with each new chunk of data that comes in?
2021-10-31 23:23:46 +0100 <dartford> erp, im kind of wanting to not be concerned with the "shape" of the state
2021-10-31 23:23:56 +0100 <dartford> other than to say, it has a lens into the RNG seed
2021-10-31 23:24:13 +0100 <dartford> so never mind about if the carry is a grid or not
2021-10-31 23:24:31 +0100 <dartford> the point is that whatever the carry is, it should have part of it be the seed
2021-10-31 23:24:40 +0100 <dartford> so that the update function can be probablistic
2021-10-31 23:24:47 +0100 <dartford> .
2021-10-31 23:25:26 +0100 <hololeap> that's fine. you can write something that transforms `State RandomSeed a` to `State (RandomSeed, s) a`, generically. that way you can have your functions that only deal with the seed and ignore the rest of the state
2021-10-31 23:26:47 +0100MQ-17J(~MQ-17J@8.6.144.203) (Ping timeout: 264 seconds)
2021-10-31 23:27:05 +0100 <hololeap> that's what the zoom thing from lens does... it "zooms" into part of a State so that you can think about it in isolation. but, you don't have to use the implementation from lens specifically, you can write it "by hand" as well
2021-10-31 23:28:09 +0100proboscis(~proboscis@14.137.28.197)
2021-10-31 23:30:11 +0100 <dartford> essentially commuting part of it into the pair and back again, as in a getter and a setter of the van larhoven lens
2021-10-31 23:30:17 +0100 <dartford> yeah "i can lens into the seed"
2021-10-31 23:30:21 +0100 <dartford> being the spec
2021-10-31 23:30:33 +0100 <dartford> i get that this library seems to achieve this
2021-10-31 23:30:55 +0100 <dartford> but i just want to use StateL and Compose, so i preserve the lazyness of its applicative when used with traverse
2021-10-31 23:31:00 +0100 <dartford> you understand this part?
2021-10-31 23:31:17 +0100 <dartford> the lazy compositionality of StateL?
2021-10-31 23:31:23 +0100 <dartford> for the scanner...
2021-10-31 23:31:33 +0100 <dartford> its all about that applicative instance
2021-10-31 23:31:41 +0100 <dartford> to give something like mapAccumL
2021-10-31 23:31:49 +0100MQ-17J(~MQ-17J@d192-24-122-179.try.wideopenwest.com)
2021-10-31 23:32:08 +0100 <dartford> otherwise i dont get my rewrite rule that expresses the algebra
2021-10-31 23:32:11 +0100proboscis(~proboscis@14.137.28.197) (Ping timeout: 245 seconds)
2021-10-31 23:32:51 +0100 <hololeap> what is StateL? Control.Monad.State.Lazy?
2021-10-31 23:33:11 +0100 <dartford> L for left
2021-10-31 23:33:16 +0100 <dartford> :t mapAccumL
2021-10-31 23:33:17 +0100 <lambdabot> Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
2021-10-31 23:33:26 +0100 <dartford> no good traversing from the right in an infinite stream!
2021-10-31 23:33:37 +0100 <dartford> so yeah, maybe left and lazy are synonimous in this case
2021-10-31 23:33:42 +0100 <dartford> not sure what module its in, sorry
2021-10-31 23:33:59 +0100 <dartford> oh, its herer
2021-10-31 23:34:00 +0100 <dartford> https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.Functor.Utils.html#StateL
2021-10-31 23:34:18 +0100son0p-(~ff@181.136.122.143)
2021-10-31 23:34:32 +0100 <dartford> right above the all essential applicative instance
2021-10-31 23:34:40 +0100 <hololeap> oh, that's new. I don't have that in my base
2021-10-31 23:34:55 +0100 <dartford> well, you dont need it if you use scanners
2021-10-31 23:35:08 +0100 <dartford> basically you wouldnt be using traverse in the streaming setting
2021-10-31 23:35:12 +0100 <dartford> it would be dangerous to
2021-10-31 23:35:33 +0100 <dartford> should be strictly restricted to using scanners to avoid the pottential for composing with a non-lazy applicative
2021-10-31 23:36:07 +0100 <dartford> but then i guess you couldnt be able to use this compose machinery to get the composed applicative instance
2021-10-31 23:36:15 +0100 <hololeap> the only problem I see is that you probably want this thing to emit some sort of status periodically, right? so you would need it to have access to IO?
2021-10-31 23:36:20 +0100 <dartford> but then, the scanner implementation makes do without that anyway..
2021-10-31 23:36:38 +0100 <dartford> huh, IO in the monad transformer stack
2021-10-31 23:36:40 +0100 <dartford> yeah
2021-10-31 23:36:41 +0100 <dartford> could be
2021-10-31 23:36:57 +0100 <dartford> but, can be avoided, like, using a carried seed instead of an IO RNG.
2021-10-31 23:37:01 +0100 <dartford> its determanistic then too
2021-10-31 23:37:07 +0100 <dartford> important for reproducability
2021-10-31 23:37:08 +0100proboscis(~proboscis@14.137.28.197)
2021-10-31 23:37:24 +0100 <dartford> theres a link to a github for the scanners over IOList if you like i can find it
2021-10-31 23:37:39 +0100 <dartford> but really i just want to use a pure infinite list
2021-10-31 23:37:47 +0100 <dartford> to avoid the additional complexity
2021-10-31 23:37:54 +0100 <dartford> and any pottential for runtime errors
2021-10-31 23:38:12 +0100 <hololeap> if it runs indefinitely, you would not have access to any of the output unless it was emitted through IO
2021-10-31 23:38:35 +0100 <dartford> scanner f (repeat ())
2021-10-31 23:38:38 +0100 <dartford> for example
2021-10-31 23:38:47 +0100 <dartford> clock = repeat ()
2021-10-31 23:38:56 +0100 <dartford> in the IO setting you can add a thread delay
2021-10-31 23:39:14 +0100 <dartford> so its more like an actual clock, but the pure versions fine
2021-10-31 23:39:30 +0100 <dartford> oh yeah sure, but main being the only IO
2021-10-31 23:39:49 +0100 <dartford> hmm, your right though, that puts IO into the monad stack
2021-10-31 23:40:20 +0100 <dartford> it ends up like Compose IO (Compose (StateL Int) (whatever the rest of the carry is))
2021-10-31 23:40:46 +0100 <dartford> it ends up like Compose IO (Compose (StateL Int) (StateL `whatever the rest of the carry is'))
2021-10-31 23:41:06 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 260 seconds)
2021-10-31 23:41:15 +0100 <hololeap> probably just `Compose (StateL (RandomSeed,s)) IO`
2021-10-31 23:41:35 +0100 <dartford> where you can rewrite that to use just one StateL, i think like Compose IO (StateL (Int,restOfCarry))
2021-10-31 23:41:35 +0100 <hololeap> and then, yeah you would be restricted to the Applicative instance of IO, but that doesn't sound like it would be a problem
2021-10-31 23:42:08 +0100 <hololeap> because you wouldn't need arbitrary input from IO, just the ability to emit
2021-10-31 23:42:13 +0100 <dartford> yeah it rewrites to what you wrote, but im not sure if the applicative instance is the same
2021-10-31 23:42:48 +0100 <dartford> ahh, ok, i think i understand that consideration, so IO input could mess it up somehow? wouldnt make it not lazy though
2021-10-31 23:42:56 +0100 <dartford> all the lazy streaming works in IO just fine
2021-10-31 23:43:02 +0100 <dartford> well, when its an IO list
2021-10-31 23:43:12 +0100 <dartford> and all the functions acting over it have option for IO too,
2021-10-31 23:43:20 +0100 <dartford> im going to find the gist, hang on
2021-10-31 23:43:48 +0100 <hololeap> this is getting into territory I'm not very familiar with, namely the technical details on laziness, IO, etc, but at least we're getting to the meat of your question
2021-10-31 23:43:58 +0100proboscis(~proboscis@14.137.28.197) (Ping timeout: 260 seconds)
2021-10-31 23:43:59 +0100 <dartford> this version is tested working https://github.com/fog-hs/streaming-binary-files-take2/tree/master/Stream
2021-10-31 23:44:14 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-10-31 23:44:24 +0100 <dartford> hololeap: sorry it took so long
2021-10-31 23:44:34 +0100 <dartford> i was busy
2021-10-31 23:44:37 +0100 <dartford> ...
2021-10-31 23:44:38 +0100 <hololeap> no worries
2021-10-31 23:44:59 +0100 <dartford> try telling her that!
2021-10-31 23:45:56 +0100 <dartford> anyway, its in the public domain now, so i can get hit by a bus safely without it being redacted from reality
2021-10-31 23:46:04 +0100 <dartford> unless you get hit by a bus at the same time
2021-10-31 23:46:16 +0100 <dartford> so we probably need to ride different buses or something
2021-10-31 23:46:18 +0100 <hololeap> what if the whole world gets hit by a bus :o
2021-10-31 23:46:21 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 245 seconds)
2021-10-31 23:46:23 +0100 <dartford> or do more work or road safety
2021-10-31 23:46:37 +0100 <dartford> hololeap: you cant crash a tesla!
2021-10-31 23:47:03 +0100 <dartford> but you can spill drinks on your structured access memory
2021-10-31 23:47:30 +0100 <hololeap> anway, I'm not sure if using the Monad interface for IO would mess up laziness somehow, but I think it's safe to say that restricting the domain to Applicative makes sense in this case
2021-10-31 23:47:32 +0100 <dartford> not that i can remember where i put my drink
2021-10-31 23:47:36 +0100 <dartford> or my glasses!
2021-10-31 23:48:26 +0100 <dartford> https://alchetron.com/cdn/professor-branestawm-3dd7e260-7142-4b63-962a-be473023b6c-resize-750.jpeg
2021-10-31 23:48:56 +0100 <dartford> go on go on go on go on - its got cocain in it!
2021-10-31 23:49:09 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-10-31 23:49:42 +0100 <dartford> hololeap: it will be fine, its out of my hands now
2021-10-31 23:50:01 +0100fendor(~fendor@77.119.160.25.wireless.dyn.drei.com) (Read error: Connection reset by peer)
2021-10-31 23:50:14 +0100 <dartford> thanks for your help - confirming you understand at least dissuades geekosaurs asserion that nobody understands and therefore that i have to explain any more
2021-10-31 23:50:56 +0100 <dartford> aka im satisfied im off the hook, and look forwards to living in a world where more than just me knows my results
2021-10-31 23:51:14 +0100 <dartford> dont worry - im not going to be taking any buses any time soon
2021-10-31 23:51:47 +0100 <hololeap> well, you have to understand that this is a support channel, so the assumption is that there is a specific problem you're trying to solve and you're looking for a concrete answer
2021-10-31 23:52:23 +0100zincy_(~zincy@2a00:23c8:970c:4801:e5fe:6e8c:c240:1bb2) (Remote host closed the connection)
2021-10-31 23:52:26 +0100 <dartford> yes, your right, i totally forgot i actually quite need these probabalistic scanners up and running
2021-10-31 23:52:32 +0100 <dartford> damn
2021-10-31 23:52:45 +0100jinsun__jinsun
2021-10-31 23:52:58 +0100 <hololeap> I mean, hook one up to an SDR and you might find something cool... IDK
2021-10-31 23:53:12 +0100son0p-(~ff@181.136.122.143) (Remote host closed the connection)
2021-10-31 23:53:23 +0100 <dartford> i meant just in terms of the "result" that the crazy composable thing is an applicative stack using compose which preserves lazyness when used with traverse - ie, that its just ensted StateL with an IO in there somewere somehow
2021-10-31 23:54:07 +0100 <dartford> whats an SDR?
2021-10-31 23:54:17 +0100 <hololeap> software defined radio
2021-10-31 23:54:23 +0100euandreh(~euandreh@2804:14c:33:9fe5:af93:19b0:8b26:3fa2) (Ping timeout: 260 seconds)
2021-10-31 23:54:31 +0100 <dartford> yeah, and aim it at your dog
2021-10-31 23:55:04 +0100 <dartford> its ok, my dog drives a tesla
2021-10-31 23:55:19 +0100 <hololeap> it's a good source for infinite data streams, since it's really just a analogue-digital converter hooked up to an antenna and a tuner
2021-10-31 23:56:06 +0100son0p-(~ff@181.136.122.143)
2021-10-31 23:56:10 +0100 <dartford> better than hooking it up to the stock market, where there are robots evolved to conduct adversarial privacy preserving system inference and control
2021-10-31 23:56:27 +0100 <dartford> optimally
2021-10-31 23:56:42 +0100 <dartford> "dont use that socket!!!" ... "noooo"
2021-10-31 23:57:05 +0100 <dartford> "hey, whats up with your dog, it cant trade for shit!"
2021-10-31 23:57:23 +0100 <dartford> "its been hacked by trading robots!!!"
2021-10-31 23:57:34 +0100 <dartford> hide your wife...
2021-10-31 23:58:16 +0100 <dartford> taxi!
2021-10-31 23:58:20 +0100dartford(~dartford@176-157-77-163.abo.bbox.fr) (Quit: Connection closed)