2024/02/20

2024-02-20 00:01:30 +0100acidjnk(~acidjnk@p200300d6e737e7078172c370cd7bd683.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2024-02-20 00:03:07 +0100pavonia_(~user@user/siracusa)
2024-02-20 00:03:35 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 264 seconds)
2024-02-20 00:04:55 +0100pavonia(~user@user/siracusa) (Read error: Connection reset by peer)
2024-02-20 00:05:06 +0100pavonia_pavonia
2024-02-20 00:11:44 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2024-02-20 00:11:59 +0100euphores(~SASL_euph@user/euphores) (Read error: Connection reset by peer)
2024-02-20 00:12:55 +0100CiaoSen(~Jura@2a05:5800:2d5:3400:e6b9:7aff:fe80:3d03) (Ping timeout: 256 seconds)
2024-02-20 00:13:07 +0100euphores(~SASL_euph@user/euphores)
2024-02-20 00:14:15 +0100euleritian(~euleritia@77.22.252.56)
2024-02-20 00:16:17 +0100sroso(~sroso@user/SrOso)
2024-02-20 00:19:09 +0100sudden(~cat@user/sudden) (Ping timeout: 268 seconds)
2024-02-20 00:21:22 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection)
2024-02-20 00:21:40 +0100adanwan(~adanwan@gateway/tor-sasl/adanwan)
2024-02-20 00:30:03 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-02-20 00:33:19 +0100phma(~phma@host-67-44-208-180.hnremote.net) (Read error: Connection reset by peer)
2024-02-20 00:33:51 +0100sudden(~cat@user/sudden)
2024-02-20 00:33:57 +0100phma(phma@2001:5b0:211f:17e8:9781:bf89:87ee:5c)
2024-02-20 00:39:07 +0100destituion(~destituio@2a02:2121:626:f551:4ac:cbaa:8513:cc79) (Ping timeout: 256 seconds)
2024-02-20 00:39:12 +0100Tuplanolla(~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) (Quit: Leaving.)
2024-02-20 00:50:55 +0100destituion(~destituio@2a02:2121:6b0:945a:2d6a:154b:f3d4:a642)
2024-02-20 00:53:12 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 256 seconds)
2024-02-20 00:53:31 +0100euleritian(~euleritia@dynamic-176-006-180-132.176.6.pool.telefonica.de)
2024-02-20 01:01:05 +0100rvalue(~rvalue@user/rvalue) (Ping timeout: 256 seconds)
2024-02-20 01:04:47 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2024-02-20 01:11:42 +0100rvalue(~rvalue@user/rvalue)
2024-02-20 01:24:51 +0100sroso(~sroso@user/SrOso) (Read error: Connection reset by peer)
2024-02-20 01:27:21 +0100 <dmj`> c_wraith: ping
2024-02-20 01:27:34 +0100 <c_wraith> hey, I'm around
2024-02-20 01:29:23 +0100sroso(~sroso@user/SrOso)
2024-02-20 01:29:58 +0100sroso(~sroso@user/SrOso) (Max SendQ exceeded)
2024-02-20 01:34:55 +0100werneta(~werneta@024-205-076-158.res.spectrum.com)
2024-02-20 01:36:34 +0100sroso(~sroso@user/SrOso)
2024-02-20 01:37:09 +0100sroso(~sroso@user/SrOso) (Max SendQ exceeded)
2024-02-20 01:38:01 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2024-02-20 01:42:49 +0100sroso(~sroso@user/SrOso)
2024-02-20 01:46:15 +0100dodoyada(~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed)
2024-02-20 01:56:17 +0100puke(~puke@user/puke)
2024-02-20 01:59:52 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Quit: ZNC 1.8.2 - https://znc.in)
2024-02-20 02:01:48 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2024-02-20 02:03:49 +0100werneta(~werneta@024-205-076-158.res.spectrum.com) (Quit: Lost terminal)
2024-02-20 02:05:55 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2024-02-20 02:07:37 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2024-02-20 02:17:49 +0100dodoyada(~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net)
2024-02-20 02:24:25 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com)
2024-02-20 02:32:30 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 02:37:17 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 268 seconds)
2024-02-20 02:40:11 +0100 <dmj`> c_wraith: still thinking about recovering polymorphic recursion amidst whole program monomorphization (specializing and inlining). Thinking maybe defining a recursive AST (encoding the type cases) and a mini interpreter for it in cases where polymorphic recursion exists, could be a path forward.
2024-02-20 02:42:43 +0100 <c_wraith> that's close enough to what GHC does when it compiles code with polymorphic recursion.
2024-02-20 02:43:33 +0100 <dmj`> isn't this called "intensional type analysis"
2024-02-20 02:44:37 +0100 <c_wraith> I don't know the topic. a quick skim tells me it's at least related.
2024-02-20 02:45:18 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 268 seconds)
2024-02-20 02:48:13 +0100caesrmt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2024-02-20 02:48:48 +0100 <c_wraith> but I've got a terminological nitpick. whole-program monomorphization says to me that it's finding a monomorphic type in the surface language for every expression. what you're suggesting still isn't capable of that, because it's logically inconsistent with polymorphic recursion.
2024-02-20 02:48:56 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2024-02-20 02:49:28 +0100 <c_wraith> what you're suggesting is a kind of rewriting of the surface language to an intermediate form where everything is monomorphic
2024-02-20 02:49:53 +0100 <c_wraith> which is great, but I think it needs a slightly different term. at least by my understanding
2024-02-20 02:49:55 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds)
2024-02-20 02:50:45 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2024-02-20 02:51:37 +0100bilegeek(~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817)
2024-02-20 02:52:05 +0100xff0x(~xff0x@ai082039.d.east.v6connect.net) (Ping timeout: 268 seconds)
2024-02-20 03:01:16 +0100 <carter> I assume whole program monomorphization is always in the compiler ir
2024-02-20 03:01:32 +0100 <dmj`> Well, the surface language wouldn't be rewritten per se (I think). There would type checking, where when polymorphic recursion is encountered, a type signature would expected to exist in the typing env to allow things to infer and be decidable. But desugaring, instead of the dictionary passing, a whole program pass would analyze all call sites and provide monomorphic types for everything (all type variables get specialized).
2024-02-20 03:02:45 +0100 <dmj`> c_wraith: but what you're saying is correct because in order to encode the recursion we'd have to scrutinize the types and provide a mini interpreter on this type language. This seems to work well with the "pure type systems" approach where types and terms are identical. This is what JHC does.
2024-02-20 03:02:47 +0100peterbecich(~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 260 seconds)
2024-02-20 03:03:03 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2024-02-20 03:04:17 +0100 <dmj`> c_wraith: maybe this is the "intensional type analysis" part, in laymens terms
2024-02-20 03:07:46 +0100otto_s(~user@p5b044a25.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
2024-02-20 03:08:10 +0100 <dmj`> layman's?
2024-02-20 03:09:28 +0100otto_s(~user@p4ff27fbc.dip0.t-ipconnect.de)
2024-02-20 03:15:48 +0100 <geekosaur> the latter
2024-02-20 03:20:15 +0100 <dmj`> thanks :)
2024-02-20 03:26:12 +0100jargon(~jargon@157.sub-174-205-162.myvzw.com) (Remote host closed the connection)
2024-02-20 03:31:10 +0100benkard(~mulk@p5b2dcb88.dip0.t-ipconnect.de)
2024-02-20 03:32:03 +0100mulk(~mulk@pd95148d1.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2024-02-20 03:32:03 +0100benkardmulk
2024-02-20 03:32:22 +0100euphores(~SASL_euph@user/euphores) (Ping timeout: 260 seconds)
2024-02-20 03:41:15 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2024-02-20 03:51:21 +0100dodoyada(~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed)
2024-02-20 03:53:08 +0100Xe(~cadey@perl/impostor/xe) (Ping timeout: 268 seconds)
2024-02-20 03:53:08 +0100notzmv(~daniel@user/notzmv)
2024-02-20 03:56:54 +0100sysadm1nH(~sysadm1nH@115.55.85.79.rev.sfr.net)
2024-02-20 03:56:56 +0100sysadm1nH(~sysadm1nH@115.55.85.79.rev.sfr.net) (Client Quit)
2024-02-20 03:59:59 +0100Xe(~cadey@perl/impostor/xe)
2024-02-20 04:00:33 +0100phma(phma@2001:5b0:211f:17e8:9781:bf89:87ee:5c) (Read error: Connection reset by peer)
2024-02-20 04:01:14 +0100phma(~phma@host-67-44-208-78.hnremote.net)
2024-02-20 04:01:46 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 268 seconds)
2024-02-20 04:02:15 +0100sroso(~sroso@user/SrOso) (Remote host closed the connection)
2024-02-20 04:02:36 +0100sroso(~sroso@user/SrOso)
2024-02-20 04:03:12 +0100sroso(~sroso@user/SrOso) (Max SendQ exceeded)
2024-02-20 04:03:20 +0100Xe(~cadey@perl/impostor/xe) (Excess Flood)
2024-02-20 04:03:29 +0100jbalint(~jbalint@071-090-119-177.res.spectrum.com) (Remote host closed the connection)
2024-02-20 04:03:37 +0100caesrmt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 255 seconds)
2024-02-20 04:03:40 +0100jbalint(~jbalint@2600-6c44-117f-e98a-816a-9488-0fb1-07b7.inf6.spectrum.com)
2024-02-20 04:06:19 +0100Xe(~cadey@perl/impostor/xe)
2024-02-20 04:11:45 +0100sysadm1nH(~sysadm1nH@115.55.85.79.rev.sfr.net)
2024-02-20 04:12:05 +0100 <sysadm1nH> Good morning or good evening. You are welcome on https://twitter.com/PLocataire: #hacking #exploits #shellcodes #coding #OSINT #Tools #Papers :>
2024-02-20 04:13:17 +0100sysadm1nH(~sysadm1nH@115.55.85.79.rev.sfr.net) (K-Lined)
2024-02-20 04:18:36 +0100 <tinjamin> idk how y'all do it haskell is so damn hard
2024-02-20 04:19:43 +0100 <jackdk> tinjamin: honestly, by learning to outsource my thinking to the typechecker
2024-02-20 04:22:47 +0100 <jackdk> tinjamin: and by taking things one step at a time
2024-02-20 04:23:14 +0100td_(~td@i53870935.versanet.de) (Ping timeout: 252 seconds)
2024-02-20 04:23:26 +0100 <tinjamin> Yeah, i've taken a three weeks hiatus and just got started again today
2024-02-20 04:23:40 +0100 <tinjamin> learning about lists and types
2024-02-20 04:24:55 +0100td_(~td@i5387090B.versanet.de)
2024-02-20 04:27:05 +0100average(uid473595@user/average) (Quit: Connection closed for inactivity)
2024-02-20 04:27:08 +0100 <jackdk> There's also a bunch of tricks that you pick out along the way, like when you're starting out writing patterns, you often write one pattern for each constructor of a data type
2024-02-20 04:28:34 +0100tri(~tri@2607:fb90:b1a5:6d6:4df9:1a60:ef06:5b8b)
2024-02-20 04:29:16 +0100 <jackdk> tinjamin: This site is fun to play with, to evaluate simple-ish expressions step-by-step and see what they're doing: https://pbv.github.io/haskelite/site/index.html . I have used step-by-step eval on a notebook to understand thorny code in the past, I find it a very helpful idea
2024-02-20 04:29:50 +0100 <jackdk> I'm about to head out, so I'm sorry I can't give much more than platitudes. But if you have specific questions I think there will be a few other people in the channel who are awake and can help
2024-02-20 04:47:46 +0100 <zwro> https://www.reddit.com/r/haskell/s/Qud77rzrPo
2024-02-20 04:51:11 +0100caesrmt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net)
2024-02-20 04:58:37 +0100Lycurgus(~georg@user/Lycurgus)
2024-02-20 05:00:22 +0100tri(~tri@2607:fb90:b1a5:6d6:4df9:1a60:ef06:5b8b) (Remote host closed the connection)
2024-02-20 05:02:47 +0100 <tinjamin> definitely, thanks jackdk!
2024-02-20 05:08:25 +0100 <dmj`> tinjamin: write Semigroup, Monoid, Functor, Applicative, Monad for [], State, (,), Reader, Writer, (->), Either, Maybe (where applicable) and then implement Data.List and Control.Monad by hand. Implementing all the instances is key. O/w when you see all the overloaded functions it will always be confusing, your brain can only inline them if you've implemented the instances already
2024-02-20 05:09:24 +0100 <jackdk> I second the advice to write instances by hand, to see how things work
2024-02-20 05:11:39 +0100 <jackdk> https://github.com/system-f/fp-course can help here
2024-02-20 05:18:14 +0100dodoyada(~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net)
2024-02-20 05:22:31 +0100rosco(~rosco@175.136.156.77)
2024-02-20 05:28:17 +0100euleritian(~euleritia@dynamic-176-006-180-132.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-02-20 05:28:34 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-02-20 05:29:19 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection)
2024-02-20 05:29:23 +0100Katarushisu1(~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) (Quit: Ping timeout (120 seconds))
2024-02-20 05:29:36 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2024-02-20 05:30:49 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 05:31:37 +0100Ranhir(~Ranhir@157.97.53.139) (Ping timeout: 264 seconds)
2024-02-20 05:32:49 +0100m1dnight(~christoph@78-22-2-15.access.telenet.be) (Ping timeout: 264 seconds)
2024-02-20 05:32:49 +0100APic(apic@apic.name) (Ping timeout: 264 seconds)
2024-02-20 05:35:33 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 260 seconds)
2024-02-20 05:37:39 +0100aforemny(~aforemny@2001:9e8:6cc8:100:42ef:f733:c482:5119) (Ping timeout: 255 seconds)
2024-02-20 05:37:53 +0100aforemny_(~aforemny@2001:9e8:6cec:d900:9d72:673f:b1f3:dc04)
2024-02-20 05:49:27 +0100Katarushisu1(~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net)
2024-02-20 05:49:49 +0100heartburn(~gass@81.4.123.134)
2024-02-20 05:49:51 +0100igemnace(~ian@user/igemnace)
2024-02-20 05:52:35 +0100Ranhir(~Ranhir@157.97.53.139)
2024-02-20 05:52:57 +0100Katarushisu1(~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) (Client Quit)
2024-02-20 05:59:36 +0100m1dnight(~christoph@78-22-2-15.access.telenet.be)
2024-02-20 06:00:51 +0100hueso(~root@user/hueso) (Ping timeout: 256 seconds)
2024-02-20 06:03:07 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2024-02-20 06:04:31 +0100caesrmt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2024-02-20 06:08:49 +0100Katarushisu1(~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net)
2024-02-20 06:09:05 +0100Square3(~Square4@user/square)
2024-02-20 06:09:16 +0100michalz(~michalz@185.246.207.221)
2024-02-20 06:11:37 +0100Square(~Square@user/square) (Ping timeout: 256 seconds)
2024-02-20 06:14:18 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 06:14:38 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2024-02-20 06:14:55 +0100APic(apic@apic.name)
2024-02-20 06:17:16 +0100thegeekinside(~thegeekin@189.217.83.221) (Read error: Connection reset by peer)
2024-02-20 06:17:55 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 246 seconds)
2024-02-20 06:18:12 +0100actioninja8(~actioninj@user/actioninja)
2024-02-20 06:19:50 +0100actioninja(~actioninj@user/actioninja) (Ping timeout: 252 seconds)
2024-02-20 06:19:51 +0100actioninja8actioninja
2024-02-20 06:26:17 +0100michalz(~michalz@185.246.207.221) (Quit: ZNC 1.8.2 - https://znc.in)
2024-02-20 06:26:38 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2024-02-20 06:29:04 +0100michalz(~michalz@185.246.207.197)
2024-02-20 06:44:25 +0100bilegeek(~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817) (Quit: Leaving)
2024-02-20 06:47:27 +0100dodoyada(~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed)
2024-02-20 06:54:59 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2024-02-20 07:03:35 +0100mulk(~mulk@p5b2dcb88.dip0.t-ipconnect.de) (Ping timeout: 272 seconds)
2024-02-20 07:03:59 +0100Vq(~vq@90-225-115-195-no122.tbcn.telia.com) (Ping timeout: 268 seconds)
2024-02-20 07:05:31 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2024-02-20 07:10:19 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection)
2024-02-20 07:22:07 +0100mulk(~mulk@pd95142c7.dip0.t-ipconnect.de)
2024-02-20 07:23:15 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2024-02-20 07:25:23 +0100acidjnk(~acidjnk@p200300d6e737e723f1d9672538a89ef2.dip0.t-ipconnect.de)
2024-02-20 07:27:07 +0100mulk(~mulk@pd95142c7.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2024-02-20 07:34:12 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2024-02-20 07:41:41 +0100 <tinjamin> thanks guys!
2024-02-20 07:41:52 +0100 <tinjamin> i'll definitely take a look in the morning
2024-02-20 07:53:51 +0100coot(~coot@89-69-206-216.dynamic.chello.pl)
2024-02-20 07:54:36 +0100bilegeek(~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817)
2024-02-20 08:00:57 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2024-02-20 08:18:18 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 08:22:31 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 256 seconds)
2024-02-20 08:27:48 +0100mulk(~mulk@pd951406a.dip0.t-ipconnect.de)
2024-02-20 08:30:19 +0100tromp(~textual@92.110.219.57)
2024-02-20 08:34:57 +0100mulk(~mulk@pd951406a.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2024-02-20 08:35:24 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2024-02-20 08:36:00 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com)
2024-02-20 08:37:36 +0100mulk(~mulk@pd9514a85.dip0.t-ipconnect.de)
2024-02-20 08:55:38 +0100tromp(~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-02-20 09:00:09 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c)
2024-02-20 09:08:30 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2024-02-20 09:09:41 +0100tromp(~textual@92.110.219.57)
2024-02-20 09:14:03 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 272 seconds)
2024-02-20 09:15:08 +0100euleritian(~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de)
2024-02-20 09:23:11 +0100kuribas(~user@2a02:1808:80:3ece:5b45:c128:11b7:97c5)
2024-02-20 09:35:35 +0100AlexZenon(~alzenon@178.34.161.13) (Ping timeout: 272 seconds)
2024-02-20 09:36:13 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 272 seconds)
2024-02-20 09:38:25 +0100euleritian(~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-02-20 09:38:42 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-02-20 09:46:16 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Quit: WeeChat 4.1.2)
2024-02-20 09:46:53 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 09:47:00 +0100enoq(~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650)
2024-02-20 09:47:10 +0100AlexZenon(~alzenon@178.34.161.13)
2024-02-20 09:48:33 +0100 <enoq> let's say you've got a list of numbers, e.g. [1, 2, 3, 4] and you want to build a new list that adds the number to all previous numbers, e.g. [1, 3, 6, 10], what's the function called?
2024-02-20 09:48:46 +0100 <enoq> started with a naive implementation that has factorial runtime which is kinda bad xD
2024-02-20 09:49:40 +0100 <enoq> (as in: summing up all numbers to the current index)
2024-02-20 09:50:13 +0100 <enoq> hm, wait, kinda looks like a classic reduce?
2024-02-20 09:50:14 +0100 <dminuoso> > scanl (+) 0 [1..]
2024-02-20 09:50:18 +0100 <lambdabot> [0,1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,2...
2024-02-20 09:50:22 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03)
2024-02-20 09:51:01 +0100 <dminuoso> Or, if you dont want that first element
2024-02-20 09:51:07 +0100 <dminuoso> > scanl1 (+) [1..]
2024-02-20 09:51:08 +0100 <lambdabot> [1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276...
2024-02-20 09:51:18 +0100 <tomsmeding> enoq: "prefix sums", or "a scan"
2024-02-20 09:51:29 +0100 <enoq> thanks!
2024-02-20 09:52:08 +0100 <dminuoso> enoq: Your observation that it looks "like" a reduce is quite right though, the umbrella term here is recursion schemes
2024-02-20 09:52:32 +0100 <enoq> it reduces to a list, not a singular value
2024-02-20 09:52:50 +0100 <tomsmeding> a scan is essentially a fold that remembers all the intermediate values
2024-02-20 09:53:46 +0100 <enoq> I remember implementing that in CUDA in university, forgot the name :)
2024-02-20 09:54:12 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-02-20 09:55:03 +0100 <dminuoso> enoq: how is "list" different from "singular value"?
2024-02-20 09:55:14 +0100 <dminuoso> Is a "list" not a "singular value"?
2024-02-20 09:55:23 +0100 <dminuoso> Matter of perspective, I would say.
2024-02-20 09:55:30 +0100 <enoq> reduce goes from a List<T> to T
2024-02-20 09:55:45 +0100 <dminuoso> Not quite.
2024-02-20 09:55:48 +0100 <dminuoso> :t foldr
2024-02-20 09:55:49 +0100 <lambdabot> Foldable t => (a -> b -> b) -> b -> t a -> b
2024-02-20 09:55:51 +0100 <enoq> scan goes from List<T> to List<T> I think
2024-02-20 09:56:00 +0100 <dminuoso> enoq: ^- look at that type signature.
2024-02-20 09:56:13 +0100 <dminuoso> enoq: Note that eventually you can take a `t a` to `b`
2024-02-20 09:56:18 +0100 <dminuoso> Not `t a` to `a`
2024-02-20 09:56:19 +0100kuribas(~user@2a02:1808:80:3ece:5b45:c128:11b7:97c5) (Ping timeout: 246 seconds)
2024-02-20 09:56:34 +0100 <dminuoso> > foldr (:) [] [1..]
2024-02-20 09:56:35 +0100 <lambdabot> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,...
2024-02-20 09:56:39 +0100 <dminuoso> See, folded into a list.
2024-02-20 09:56:42 +0100gmg(~user@user/gehmehgeh)
2024-02-20 09:57:00 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2024-02-20 09:57:14 +0100 <tomsmeding> the "state" of the fold can be different from the element
2024-02-20 09:57:18 +0100 <enoq> I think Haskell's abstraction is just a bit more generic
2024-02-20 09:57:18 +0100 <dminuoso> enoq: A better intuition of `fold f z` is not that it "reduces/folds", but that it replaces (:) with f and [] with z in the list structure.
2024-02-20 09:57:44 +0100 <tomsmeding> which is different from the thing you implemented in CUDA: there you want the state to be the same type as the array element, so that the combination function can be associative, so that you can implement the fold/scan in parallel
2024-02-20 10:03:56 +0100cfricke(~cfricke@user/cfricke)
2024-02-20 10:04:42 +0100kuribas(~user@2a02:1808:80:3ece:18b4:369:3465:6cb1)
2024-02-20 10:10:13 +0100kuribas(~user@2a02:1808:80:3ece:18b4:369:3465:6cb1) (Ping timeout: 268 seconds)
2024-02-20 10:10:43 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2024-02-20 10:11:55 +0100 <kuribas> tomsmeding: doing it non-locally makes much more sense IMO, then I can
2024-02-20 10:12:04 +0100 <kuribas> tomsmeding: doing it non-locally makes much more sense IMO, then the side effects are clear.
2024-02-20 10:12:12 +0100 <tomsmeding> (wrong channel?)
2024-02-20 10:12:18 +0100 <kuribas> right :)
2024-02-20 10:12:32 +0100NSFAF__(~NSFAF@105.232.14.71)
2024-02-20 10:13:57 +0100tromp(~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-02-20 10:16:33 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Quit: WeeChat 4.1.2)
2024-02-20 10:19:06 +0100danse-nr3(~danse@151.43.214.115)
2024-02-20 10:19:53 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 10:23:50 +0100danse-nr3(~danse@151.43.214.115) (Ping timeout: 256 seconds)
2024-02-20 10:28:24 +0100raym(~ray@user/raym) (Quit: Upgrading to FreeBSD 14.0-RELEASE-p5)
2024-02-20 10:31:52 +0100pastly(~pastly@gateway/tor-sasl/pastly) (Remote host closed the connection)
2024-02-20 10:32:11 +0100NSFAF__(~NSFAF@105.232.14.71) (Ping timeout: 260 seconds)
2024-02-20 10:35:00 +0100pastly(~pastly@gateway/tor-sasl/pastly)
2024-02-20 10:38:53 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 260 seconds)
2024-02-20 10:40:31 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2024-02-20 10:43:26 +0100ft(~ft@p508db2e6.dip0.t-ipconnect.de) (Quit: leaving)
2024-02-20 10:47:09 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2024-02-20 10:53:27 +0100danse-nr3(~danse@151.57.223.96)
2024-02-20 10:56:07 +0100NSFAF(~NSFAF@105.232.14.71)
2024-02-20 11:02:23 +0100lortabac(~lortabac@37.97.111.147)
2024-02-20 11:04:29 +0100xff0x(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 240 seconds)
2024-02-20 11:05:29 +0100sympt(~sympt@user/sympt) (Quit: Ping timeout (120 seconds))
2024-02-20 11:06:23 +0100sympt(~sympt@user/sympt)
2024-02-20 11:07:47 +0100mmhat(~mmh@p200300f1c70b449eee086bfffe095315.dip0.t-ipconnect.de)
2024-02-20 11:07:58 +0100chele(~chele@user/chele)
2024-02-20 11:12:00 +0100NSFAF(~NSFAF@105.232.14.71) (Ping timeout: 255 seconds)
2024-02-20 11:12:49 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2024-02-20 11:17:38 +0100chele(~chele@user/chele) (Remote host closed the connection)
2024-02-20 11:23:14 +0100raym(~ray@user/raym)
2024-02-20 11:24:08 +0100chele(~chele@user/chele)
2024-02-20 11:28:02 +0100Lycurgus(~georg@user/Lycurgus)
2024-02-20 11:28:29 +0100ubert(~Thunderbi@2a02:8109:ab8a:5a00:ce61:4d12:7531:ec69)
2024-02-20 11:36:13 +0100polux6(~polux@51-15-169-172.rev.poneytelecom.eu)
2024-02-20 11:36:18 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2024-02-20 11:37:15 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 11:37:17 +0100polux(~polux@51-15-169-172.rev.poneytelecom.eu) (Ping timeout: 240 seconds)
2024-02-20 11:37:17 +0100polux6polux
2024-02-20 11:37:48 +0100NSFAF(~NSFAF@105.232.14.71)
2024-02-20 11:38:16 +0100rosco(~rosco@175.136.156.77) (Quit: Lost terminal)
2024-02-20 11:38:35 +0100NSFAF_(~NSFAF@105.232.14.71)
2024-02-20 11:39:38 +0100NSFAF__(~NSFAF@105.232.14.71)
2024-02-20 11:40:12 +0100euleritian(~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de)
2024-02-20 11:42:22 +0100NSFAF(~NSFAF@105.232.14.71) (Ping timeout: 246 seconds)
2024-02-20 11:42:31 +0100NSFAF(~NSFAF@105.232.14.71)
2024-02-20 11:43:25 +0100NSFAF(~NSFAF@105.232.14.71) (Max SendQ exceeded)
2024-02-20 11:43:25 +0100NSFAF_(~NSFAF@105.232.14.71) (Ping timeout: 246 seconds)
2024-02-20 11:44:59 +0100NSFAF__(~NSFAF@105.232.14.71) (Ping timeout: 260 seconds)
2024-02-20 11:45:22 +0100NSFAF(~NSFAF@130.185.144.25)
2024-02-20 11:45:49 +0100bilegeek(~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817) (Quit: Leaving)
2024-02-20 11:52:29 +0100[_________](~oos95GWG@user/oos95GWG) (Quit: [_________])
2024-02-20 11:54:32 +0100[_________](~oos95GWG@user/oos95GWG)
2024-02-20 11:56:22 +0100NSFAF(~NSFAF@130.185.144.25) (Ping timeout: 246 seconds)
2024-02-20 11:59:59 +0100euleritian(~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-02-20 12:00:16 +0100euleritian(~euleritia@77.22.252.56)
2024-02-20 12:02:24 +0100lortabac(~lortabac@37.97.111.147) (Ping timeout: 255 seconds)
2024-02-20 12:07:42 +0100xff0x(~xff0x@ai082039.d.east.v6connect.net)
2024-02-20 12:08:42 +0100igemnace(~ian@user/igemnace) (Read error: Connection reset by peer)
2024-02-20 12:26:26 +0100igemnace(~ian@user/igemnace)
2024-02-20 12:36:45 +0100kaskal(~kaskal@213-147-167-18.nat.highway.webapn.at) (Quit: ZNC - https://znc.in)
2024-02-20 12:37:19 +0100kaskal(~kaskal@2001:4bb8:2c3:39c1:ff3f:d58:4fd9:e10c)
2024-02-20 12:40:40 +0100__monty__(~toonn@user/toonn)
2024-02-20 12:43:44 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 12:45:10 +0100califax(~califax@user/califx)
2024-02-20 12:50:28 +0100fen78(~fen@84.68.80.95)
2024-02-20 12:50:43 +0100 <fen78> hi, im having trouble using haskell
2024-02-20 12:50:54 +0100 <fen78> i cant get the things i call to be evaluated
2024-02-20 12:51:15 +0100 <fen78> can anyone help, thanks
2024-02-20 12:51:54 +0100m1dnight(~christoph@78-22-2-15.access.telenet.be) (Ping timeout: 255 seconds)
2024-02-20 12:52:11 +0100 <danse-nr3> maybe do some tests from the interpreter (ghci) to get acquainted with it fen78
2024-02-20 12:52:17 +0100 <fen78> im thinking it might be a ghc issue, but maybe not
2024-02-20 12:52:35 +0100 <fen78> danse, i think ou misunderstand
2024-02-20 12:52:52 +0100 <danse-nr3> how long is your code? You could paste it in a pastebin and link that to us
2024-02-20 12:52:53 +0100 <fen78> i cant get *the things i call* to *be evaluated*
2024-02-20 12:53:01 +0100 <fen78> its a language issue
2024-02-20 12:53:16 +0100 <fen78> purelt theoretic, of course
2024-02-20 12:53:53 +0100 <fen78> i can use a bang pattern to ensure a bound variable is certainly evaluated
2024-02-20 12:54:05 +0100 <fen78> but i cant ask this condition be satisfied by an argument
2024-02-20 12:54:22 +0100 <fen78> i can say something has to be available via a class, but this could trigger reevaluation
2024-02-20 12:54:36 +0100 <fen78> idk how to express the condition within haskell
2024-02-20 12:55:58 +0100 <fen78> i have some random numbers that are universal, and used by many objects, i cant keep them in scope somehow without risking reevaluation, symantically its impossible, and this makes it risky, and lacking the ability to express it feels clunky
2024-02-20 12:56:41 +0100 <fen78> perhaps this can be acheived with linear types?
2024-02-20 12:57:20 +0100 <fen78> isnt that a way to annotate the type signature to ask that variables are uniquely calculated?
2024-02-20 12:57:28 +0100 <fen78> am i wrong to think that?
2024-02-20 12:57:32 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2024-02-20 12:58:18 +0100 <fen78> or is it that they are uniquely consumed? i forget
2024-02-20 12:58:41 +0100 <fen78> rrg, seems like i want a kind of opposite kind of linear types
2024-02-20 12:59:12 +0100 <fen78> anyone make sense of this, like formerly somehow?
2024-02-20 13:00:03 +0100 <fen78> basically, does it make sense about how i cannot demand of the argument that it is not going to trigger reevaluation
2024-02-20 13:01:12 +0100 <fen78> i was thinking there might be a hack with reflection and local instantiation somehow but i have no idea how
2024-02-20 13:02:36 +0100 <fen78> i think like, the fact you get to load up the class with an instance partway through the code means you can hove applied a bang pattern first!
2024-02-20 13:03:29 +0100lortabac(~lortabac@37.97.111.147)
2024-02-20 13:03:39 +0100 <fen78> ok so cool i can almost basically semantically express it, if there are these local instances involved somehow
2024-02-20 13:04:30 +0100 <fen78> this is basically then seems to be about not being able to put a bang pattern on a the binding in a class
2024-02-20 13:05:11 +0100 <sprout> haskell is lazy, just give it time until it gets out of bed
2024-02-20 13:05:48 +0100 <sprout> anyway, jokes aside. you shouldn't have this problem
2024-02-20 13:06:09 +0100 <sprout> pastebin your problem
2024-02-20 13:06:15 +0100 <fen78> reflection allows the binding to be made after a bang pattern is applied to a binding *not* in a class, and has to take place here rather in the class headder, in order to have the bang pattern binding preceding the class instantiation which uses it
2024-02-20 13:06:25 +0100 <fen78> no problem
2024-02-20 13:07:17 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03) (Ping timeout: 240 seconds)
2024-02-20 13:07:27 +0100 <fen78> nono, the question is about if there is understanding about this bang patterns in classes and the relevency of reflection at least in explaining it, could help thoerise a way to incorperate it into the semantics of the language properly
2024-02-20 13:07:59 +0100 <fen78> we already have some weird ? symbol
2024-02-20 13:08:34 +0100 <fen78> which i think was involved in some kind of semantics of reflection
2024-02-20 13:10:22 +0100 <fen78> i guess the comment is something about with this language extension that because it allows bang patterns to preceed reflectins to constraint based scope, that it solves this glitch i was describing
2024-02-20 13:11:16 +0100 <fen78> variables in constraints, using these ? symbols, *can* be bang pattern guarded by the user so the consumption from scope is guarantied not to cause reevaluation
2024-02-20 13:11:29 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 13:12:10 +0100 <fen78> ? constraints being bindable within code
2024-02-20 13:12:18 +0100 <fen78> but anyway, this way of expressing it sucks
2024-02-20 13:12:28 +0100 <fen78> and it only results from no bang patterns in classes
2024-02-20 13:12:38 +0100califax(~califax@user/califx)
2024-02-20 13:12:42 +0100lortabac(~lortabac@37.97.111.147) (Ping timeout: 256 seconds)
2024-02-20 13:13:00 +0100 <fen78> this must be a thing that should make sense enough to encorperate into the language in a less obscure way
2024-02-20 13:13:58 +0100 <fen78> i guess a code question which stems from this is how to demonstrate this in action
2024-02-20 13:14:50 +0100 <fen78> ? scope referencing with some way of wrapping the bang pattern guarding in some functions to make it cinvinient to load into scope these strict variables
2024-02-20 13:14:59 +0100m1dnight(~christoph@78-22-14-161.access.telenet.be)
2024-02-20 13:15:33 +0100lortabac(~lortabac@37.97.111.147)
2024-02-20 13:16:46 +0100 <fen78> and btw, i have no idea why this is something i have only just encountered, and is so insanely bizzare, but could be a real language niggle, that is worth contending with
2024-02-20 13:17:22 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 13:17:48 +0100 <fen78> as in how much this serupticiously affects us, given its obscurity in terms of langage considerations resulting in a strange paradigm
2024-02-20 13:18:13 +0100 <fen78> "im never sure anything is strict"
2024-02-20 13:18:48 +0100 <danse-nr3> anything is non-strict. You are exaggerating things, just get acquainted with the evaluation model
2024-02-20 13:18:53 +0100 <fen78> enormous variables you dont even realise your afraid to reference
2024-02-20 13:19:08 +0100 <danse-nr3> or keep on with your monologue
2024-02-20 13:19:50 +0100 <fen78> i was trying to say you can notionally hijack the reflection tooling to bring about a strict referencing paradigm
2024-02-20 13:20:22 +0100 <fen78> and i want someone to help me with these ? things cos iv never used them
2024-02-20 13:21:06 +0100califax(~califax@user/califx)
2024-02-20 13:21:41 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:59a1:9e62:4e88:7daa) (Read error: Connection reset by peer)
2024-02-20 13:21:50 +0100 <fen78> description was variable bound from constrait scope, having been reflected from within the main body of code (not top level constraint binding)
2024-02-20 13:22:51 +0100chele(~chele@user/chele) (Ping timeout: 256 seconds)
2024-02-20 13:23:11 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99)
2024-02-20 13:23:38 +0100 <fen78> examination of the type of the function doing the call to the function in the constraint with the ?
2024-02-20 13:24:30 +0100 <danse-nr3> apologies i need to go now but if you can come up with some more down-to-earth question of example of unexpected behaviour, possibly someone else can help
2024-02-20 13:24:34 +0100 <fen78> this is the examination of the "could be strict" constraint as a scope
2024-02-20 13:25:06 +0100 <fen78> yeah, anyone online
2024-02-20 13:25:08 +0100[Leary](~Leary]@user/Leary/x-0910699) (Remote host closed the connection)
2024-02-20 13:25:14 +0100 <fen78> danse has to go
2024-02-20 13:25:26 +0100[Leary](~Leary]@user/Leary/x-0910699)
2024-02-20 13:26:17 +0100 <fen78> tldr ? in constraints could be strict!
2024-02-20 13:26:41 +0100 <fen78> and, how stupid is that as a formalism, helpf
2024-02-20 13:27:11 +0100 <danse-nr3> if you don't like non-strict just use ocaml by the way
2024-02-20 13:27:47 +0100 <fen78> i can express potentially strict...
2024-02-20 13:28:03 +0100 <fen78> in *this* language, thank you
2024-02-20 13:28:28 +0100 <fen78> as in, i mean, your welcome, somehow
2024-02-20 13:29:23 +0100 <fen78> ok, heres a good question. is this the only way we have of even doing anything about strictness at type level?
2024-02-20 13:29:45 +0100 <fen78> that, use of ?, might be strict. cos thats lame
2024-02-20 13:30:13 +0100 <fen78> i want, certainly is strict!
2024-02-20 13:30:16 +0100 <fen78> i think...
2024-02-20 13:30:35 +0100 <__monty__> What non-strictness is there at type level? Types are checked at compile time, they're not part of Haskell's evaluation model are they?
2024-02-20 13:30:35 +0100 <fen78> and linear types totally fails in this? i never got a response on that
2024-02-20 13:30:58 +0100 <fen78> no, not in terms of type level computation
2024-02-20 13:31:11 +0100 <fen78> about strictness at term level, expressed at type level
2024-02-20 13:31:38 +0100 <__monty__> Because your questions don't make sense. Linear types only apply within a function and you're talking about globally available random numbers.
2024-02-20 13:32:08 +0100 <fen78> that is that the emession of data that can only be used once?
2024-02-20 13:32:23 +0100 <fen78> thats like literally the opposite of what i want
2024-02-20 13:33:36 +0100 <fen78> bascally constraints dont serve all that well for values that *can* be strictly evaluated
2024-02-20 13:34:09 +0100 <fen78> like, class definitions with no arguments
2024-02-20 13:34:12 +0100 <__monty__> Linear types don't restrict how many times the output of a function is used.
2024-02-20 13:34:29 +0100danse-nr3(~danse@151.57.223.96) (Ping timeout: 240 seconds)
2024-02-20 13:34:59 +0100 <__monty__> I assume you're talking about type class constraints? Can you give an example?
2024-02-20 13:35:39 +0100 <fen78> i think what im saying is that it should be expressible within the type semantics, to differentiate strictly bindable terms.
2024-02-20 13:36:35 +0100 <fen78> ie those without arguments
2024-02-20 13:36:36 +0100 <__monty__> What are "terms," and what is "strictly bindable?"
2024-02-20 13:36:47 +0100 <fen78> things at term level are terms?
2024-02-20 13:37:17 +0100 <fen78> strictly bindable terms can be bound using a bang pattern
2024-02-20 13:37:31 +0100 <fen78> cant do that on a function, doesnt make sense
2024-02-20 13:37:44 +0100 <__monty__> Why not?
2024-02-20 13:37:56 +0100 <fen78> wouldnt trigger its evaluation
2024-02-20 13:37:56 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 13:38:26 +0100 <fen78> some kind of totally evaluatedness of a thing that doesnt take arguments, that a thing that takes arguments quite obviously doesnt also
2024-02-20 13:38:42 +0100 <__monty__> You very well can want a function argument to be evaluated up to its arguments.
2024-02-20 13:39:19 +0100 <fen78> you cant do that#
2024-02-20 13:39:32 +0100 <kuribas> fen78: haskells type system doesn't track strictness
2024-02-20 13:39:39 +0100 <fen78> the latter arguments can appear in the computation using the previous arguments
2024-02-20 13:39:43 +0100 <kuribas> It doesn't track totality either.
2024-02-20 13:40:06 +0100 <fen78> argument provision order has nothing to do witht the inner computations partitioning
2024-02-20 13:40:18 +0100 <kuribas> everything is lazy by default in haskell anyway.
2024-02-20 13:40:48 +0100gentauro(~gentauro@user/gentauro) (Read error: Connection reset by peer)
2024-02-20 13:40:49 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 268 seconds)
2024-02-20 13:40:53 +0100 <fen78> lazyness does not apply to function argument application
2024-02-20 13:41:04 +0100 <__monty__> Can't do what? You can evaluate any expression to WHNF.
2024-02-20 13:41:16 +0100 <fen78> not if it still requires arguments!
2024-02-20 13:41:24 +0100 <kuribas> fen78: idris has a "Lazy" type to designate a value lazy.
2024-02-20 13:41:29 +0100 <fen78> gona do like half the computation somehow
2024-02-20 13:42:06 +0100 <__monty__> `if True then id else const` can be evaluated to `id`. And `id` still takes an argument.
2024-02-20 13:42:37 +0100 <fen78> we have lazy by default but no strictness annotation in the type system unless you count ? as could be strict as actually aslmost a reasonable solution
2024-02-20 13:43:31 +0100 <fen78> monty: there exist functions where the lack of arguments yet to be applied will prevent the use of the arguments already applied.
2024-02-20 13:44:29 +0100 <__monty__> fen78: I don't see how such a function couldn't be evaluated to WHNF, which is all bang patterns do.
2024-02-20 13:44:35 +0100 <fen78> ou cant annotate a function type with strictness indications, because you cant stipulate about the partial completeness of any computation yet to recieve arguments
2024-02-20 13:44:41 +0100 <haskellbridge> <m​auke> `undefined :: a -> b` requires an argument (says its type), but it still explodes if you force it
2024-02-20 13:45:31 +0100 <fen78> imagine a net without its neuron provided, what are you going to do with the numbers to try and do half the computation while you wait for the neuron. nothing!
2024-02-20 13:45:34 +0100m1dnight(~christoph@78-22-14-161.access.telenet.be) (Ping timeout: 256 seconds)
2024-02-20 13:46:14 +0100 <fen78> i cant have the type of my net with the neuron yet to be provided demanding the net is already evaluated
2024-02-20 13:46:53 +0100 <fen78> strict functions by partial application dont make any sense!
2024-02-20 13:47:07 +0100gentauro(~gentauro@user/gentauro)
2024-02-20 13:47:30 +0100m1dnight(~christoph@78-22-2-15.access.telenet.be)
2024-02-20 13:47:33 +0100 <fen78> the innards of the function have nothing to do with the order of the arguments
2024-02-20 13:47:43 +0100 <__monty__> I don't see why not. Every argument a strict function is applied to (partially or otherwise) will be evaluated first.
2024-02-20 13:47:50 +0100 <fen78> strictness only on value like things plz
2024-02-20 13:48:32 +0100 <fen78> oh thats just using the function like a bang pattern on all its arguments
2024-02-20 13:48:52 +0100 <fen78> and its not what im saying
2024-02-20 13:48:58 +0100 <fen78> your function could cause recomputation
2024-02-20 13:49:05 +0100 <__monty__> ELI5
2024-02-20 13:49:12 +0100 <fen78> it just says that it is evaluated
2024-02-20 13:49:16 +0100 <haskellbridge> <m​auke> `hmm :: a -> b -> b; hmm x = seq x undefined`
2024-02-20 13:49:37 +0100 <haskellbridge> <m​auke> How strict is this function?
2024-02-20 13:50:28 +0100 <fen78> your version says, its evaluated, mine said, it was only ever evaluated once
2024-02-20 13:50:46 +0100 <haskellbridge> <m​auke> Actually, make that hmm x _ = ...
2024-02-20 13:50:48 +0100 <fen78> strict before binding to a constraint
2024-02-20 13:51:36 +0100 <fen78> thats what ? allows you to do with class instantiation in the body and not in the class head where strict evaluation is precluded
2024-02-20 13:51:36 +0100 <dminuoso> fen78: You mentioned ? as strictness annotation in Haskell, what are you referring to?
2024-02-20 13:51:47 +0100 <fen78> the class reflection thing
2024-02-20 13:52:00 +0100 <fen78> x ? :: Int =>
2024-02-20 13:52:04 +0100 <fen78> something like that
2024-02-20 13:52:22 +0100 <dminuoso> I have not seen that before
2024-02-20 13:52:34 +0100 <dminuoso> Which extension is that from? Or do you know of any package that uses it?
2024-02-20 13:52:53 +0100 <fen78> language extension i think
2024-02-20 13:53:01 +0100 <fen78> cant remember trying to find
2024-02-20 13:53:12 +0100 <dminuoso> What does ? do here?
2024-02-20 13:53:59 +0100m1dnight(~christoph@78-22-2-15.access.telenet.be) (Ping timeout: 272 seconds)
2024-02-20 13:54:14 +0100 <fen78> there is presumably some associated syntax at value level that reflects the instance up
2024-02-20 13:54:37 +0100 <dminuoso> Also, what does `Int =>` denote here?
2024-02-20 13:54:46 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 13:55:01 +0100 <fen78> just that the "class instance" being reffered to in the constraint was locally instantiated and not at top level in the class head, so allowing it io be a strict reference unlike a regular constraint
2024-02-20 13:55:08 +0100danse-nr3(~danse@151.43.209.161) (Remote host closed the connection)
2024-02-20 13:55:26 +0100 <fen78> could be:
2024-02-20 13:55:31 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 13:55:33 +0100 <fen78> ? x :: Int =>
2024-02-20 13:55:34 +0100 <dminuoso> I dont understand any of that.
2024-02-20 13:55:57 +0100 <dminuoso> Are you talking about ImplicitParams?
2024-02-20 13:56:04 +0100 <haskellbridge> <m​auke> Implicit parameters?
2024-02-20 13:56:05 +0100 <fen78> costraints usually refer to instanctiations made in instance blocks at top level
2024-02-20 13:56:11 +0100 <fen78> in classes defined at top level
2024-02-20 13:56:15 +0100 <fen78> this is not the same
2024-02-20 13:56:23 +0100 <fen78> yes, thank you
2024-02-20 13:56:56 +0100 <fen78> ImplicitParams is "our" workaround for "might be strict"
2024-02-20 13:57:02 +0100 <dminuoso> 13:56:05 fen78 │ costraints usually refer to instanctiations made in instance blocks at top level
2024-02-20 13:57:08 +0100 <dminuoso> I dont even understand what that means, either.
2024-02-20 13:57:24 +0100 <fen78> instance Myclass where
2024-02-20 13:57:35 +0100 <fen78> no bang patterns here
2024-02-20 13:57:47 +0100 <fen78> implicitparams gives a workaround thereon
2024-02-20 13:58:01 +0100 <dminuoso> What do ImplicitParams have to do with typeclass instances, here?
2024-02-20 13:58:12 +0100 <fen78> they provide local instantiation
2024-02-20 13:58:20 +0100 <fen78> as well as presumably local class declaration
2024-02-20 13:59:04 +0100 <dminuoso> Well yes, ImplicitParams makes uses of the constraint system.
2024-02-20 13:59:11 +0100 <fen78> reification syntax at value level basically gives a place for tokens relating to the class function definition
2024-02-20 13:59:14 +0100 <dminuoso> But beyond that, I dont see any relation to strictness.
2024-02-20 13:59:55 +0100 <fen78> you cant have a bang pattern in an Instance binding
2024-02-20 13:59:59 +0100 <fen78> !
2024-02-20 14:00:10 +0100 <fen78> you can reflect strict things!
2024-02-20 14:00:28 +0100 <dminuoso> Sorry, I fail to understand what you are saying here.
2024-02-20 14:00:55 +0100 <fen78> when reflection syntax is used at type level, the terms it references might be strict
2024-02-20 14:01:17 +0100 <fen78> while the terms referenced by regular class based constraints, do not share this property
2024-02-20 14:02:05 +0100 <fen78> ie the reflection syntax is actually ending up allowing us to make a statement about the increased pottentiality (from 0 to possible) of the thing being referenced being strict
2024-02-20 14:03:25 +0100 <fen78> the thing that related ImplicitParams to strictness, is that by allowing instantiation away from top level, that a definately no strictness, inhereted from usually constraints are instantiated at top level and so are definately not strict mindset...
2024-02-20 14:03:54 +0100NSFAF(~NSFAF@105.232.14.71)
2024-02-20 14:04:15 +0100 <fen78> is lifted... sorry garbled
2024-02-20 14:04:25 +0100NSFAF_(~NSFAF@105.232.14.71)
2024-02-20 14:04:54 +0100 <fen78> definately no strictness is lifted when constraints might not be instantiated at top level and so be without bangpatterns
2024-02-20 14:06:07 +0100 <fen78> local instances allow strict reflections to constraints which nolonger only contain non-strict variables
2024-02-20 14:06:10 +0100raym(~ray@user/raym) (Quit: leaving)
2024-02-20 14:06:29 +0100NSFAF_(~NSFAF@105.232.14.71) (Read error: Connection reset by peer)
2024-02-20 14:06:46 +0100NSFAF_(~NSFAF@105.232.14.71)
2024-02-20 14:07:04 +0100 <fen78> i mean, sure this isnt enough to uinderstand what it might look like done properly?
2024-02-20 14:07:38 +0100 <fen78> bang patterns at top level is what iv got my money on
2024-02-20 14:07:47 +0100 <fen78> any reason why not
2024-02-20 14:07:50 +0100 <fen78> in instances i mean
2024-02-20 14:08:10 +0100 <fen78>  #BangPatternInstances proposal
2024-02-20 14:08:49 +0100 <fen78> which im sure gives suitable motivation for strictness annotation for non function types
2024-02-20 14:08:53 +0100NSFAF(~NSFAF@105.232.14.71) (Ping timeout: 256 seconds)
2024-02-20 14:10:01 +0100 <fen78> i guess we need a different symbol to annotate strict terms
2024-02-20 14:10:31 +0100 <fen78> bangs in types is taken
2024-02-20 14:10:52 +0100 <fen78> i mean, is there any reason we *dont* have strictness annotations?
2024-02-20 14:11:00 +0100 <fen78> because instances have no bang patterns!?
2024-02-20 14:11:01 +0100lortabac(~lortabac@37.97.111.147) (Ping timeout: 256 seconds)
2024-02-20 14:11:20 +0100 <fen78> its a limiatation in terms of the syntax of *binding* uniform binding syntax is essential!
2024-02-20 14:11:31 +0100 <fen78> bang patterns didnt make it deep enough into the language
2024-02-20 14:11:51 +0100 <fen78> and if they did, then we would be encountering strict variables all the time! enough to bother annotating them
2024-02-20 14:12:37 +0100 <fen78> theres no top level strictenss at all!
2024-02-20 14:12:47 +0100 <fen78> presumably you could have top level strict functions?
2024-02-20 14:13:35 +0100 <fen78> maybe this messes with evaluation order of the program
2024-02-20 14:13:41 +0100 <fen78> weird!
2024-02-20 14:13:57 +0100 <fen78> so you kind of cant have that or it tries to compute something before you tell it to
2024-02-20 14:14:35 +0100 <fen78> ok then, you could have special syntax for stric reflection
2024-02-20 14:14:48 +0100 <fen78> like not ?, so maybe ??
2024-02-20 14:15:10 +0100 <fen78> so its stronger than could be strict, and is strict, and then you get an associated strict reflector at term level
2024-02-20 14:15:28 +0100 <fen78> that was the code example i wanted
2024-02-20 14:15:31 +0100 <fen78> this strict reflector
2024-02-20 14:15:46 +0100 <fen78> and the type signature of the thing it interacts with
2024-02-20 14:15:47 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 14:16:01 +0100 <fen78> to see the ? in scope
2024-02-20 14:16:36 +0100 <fen78> just with some id biolerplate which uses a bang pattern or seq or whatever to make the reflected thing strict
2024-02-20 14:16:45 +0100shapr(~user@2603:3005:b31:e100:7e64:336c:bc17:801d)
2024-02-20 14:16:47 +0100 <fen78> and the language proposal would then be to make this item a language construct
2024-02-20 14:17:19 +0100 <fen78> you did the strict reflection, you can use the ?? symbol to ask for the strict variable for you to reference
2024-02-20 14:17:32 +0100 <fen78> weird how it ends up being by use of is implicit params
2024-02-20 14:17:33 +0100califax(~califax@user/califx)
2024-02-20 14:18:13 +0100mulk(~mulk@pd9514a85.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2024-02-20 14:18:15 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03)
2024-02-20 14:18:17 +0100 <fen78> basically in lew of the language extension you just have ? and this construct and have to remember if you used it or not, and have no way to actually demand that it was
2024-02-20 14:18:27 +0100 <fen78> so it would strictly strngthen the language in this sense
2024-02-20 14:18:57 +0100 <fen78> a normally reflected implicit parameter, would fail to satisfy the stronger ?? of a constraint
2024-02-20 14:19:37 +0100 <fen78> the type system rejecting the use of the weaker reflector, when the stronger is required
2024-02-20 14:19:52 +0100 <fen78> in terms of strictness
2024-02-20 14:20:31 +0100 <fen78> ?? in constriants would give a significantly different extra structure to the types comprising a program
2024-02-20 14:20:32 +0100 <lambdabot> in constriants would give a significantly different extra structure to the types comprising a program
2024-02-20 14:20:41 +0100mulk(~mulk@pd9514af5.dip0.t-ipconnect.de)
2024-02-20 14:20:42 +0100 <fen78> thanks lambdabot
2024-02-20 14:22:24 +0100 <fen78> it allows the program graph to propegate clauses about strictness, which equate to guarantees within functions that a valriable can be referenced without triggering recomputation
2024-02-20 14:23:09 +0100 <danse-nr3> you are talking by yourself. Maybe you want to write a book or an article instead
2024-02-20 14:23:15 +0100 <fen78> it kind of says, if your going to all the effort of ensuring something is strict with a bang pattern, why is that data not apparent also at type level
2024-02-20 14:23:31 +0100 <fen78> danse: maybe you coulod help me understand
2024-02-20 14:24:01 +0100 <danse-nr3> it seems demanding considering your ambitions, and i have got to work
2024-02-20 14:24:09 +0100 <fen78> currently im trying to express what a strict annotation as a constraint would indicate
2024-02-20 14:24:41 +0100 <fen78> its not demanding. language extensions are easy for people that are not me
2024-02-20 14:24:46 +0100 <fen78> i just have to convey it
2024-02-20 14:24:51 +0100 <fen78> and think of it!
2024-02-20 14:25:01 +0100 <fen78> bloody, asking me to write him a book a seccond ago!
2024-02-20 14:25:17 +0100oneeyedalien(~oneeyedal@user/oneeyedalien)
2024-02-20 14:25:26 +0100 <fen78> probably only reason implicitparams is a worthy theoretical structure at all
2024-02-20 14:25:31 +0100 <danse-nr3> did not write "write /me/ a book"
2024-02-20 14:25:44 +0100 <fen78> noqw he doenst even want the book!
2024-02-20 14:26:17 +0100 <danse-nr3> you might be someone who enjoys trolling subtly. I am jealous for all the time you have got to waste
2024-02-20 14:26:40 +0100 <fen78> im not taking book writing requests from the type of person that comissions books without then accepting reciept of the commision, that is a no commission of books scenario
2024-02-20 14:27:03 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 14:27:34 +0100 <danse-nr3> be careful to not make your trolling too plain
2024-02-20 14:27:36 +0100 <fen78> its just an extra ? its not too much to ask
2024-02-20 14:27:49 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Read error: Connection reset by peer)
2024-02-20 14:27:52 +0100 <fen78> cant i get some help with that though, i cant understand the implications
2024-02-20 14:27:55 +0100 <haskellbridge> <J​ade> Why can I not write `data Foo a where X :: Foo a` using `-XGADTSyntax`?
2024-02-20 14:27:55 +0100 <haskellbridge> <J​ade> It tells me to enable `-XGADT`
2024-02-20 14:28:11 +0100califax(~califax@user/califx)
2024-02-20 14:28:18 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 268 seconds)
2024-02-20 14:28:39 +0100 <fen78> you gota have the ::
2024-02-20 14:28:56 +0100 <fen78> just omit X ::
2024-02-20 14:29:09 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 14:29:17 +0100 <fen78> erp what, no its the Foo a
2024-02-20 14:29:31 +0100 <fen78> and the where!
2024-02-20 14:29:31 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Read error: Connection reset by peer)
2024-02-20 14:29:59 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net)
2024-02-20 14:30:14 +0100 <fen78> data Foo a = X (x :: Foo a)
2024-02-20 14:30:17 +0100 <fen78> or
2024-02-20 14:30:39 +0100 <haskellbridge> <J​ade> yes, but those should work with `GADTSyntax` alone, right? The user guide gives the example of `newtype Down a where Down :: a -> Down a` which also doesn't work
2024-02-20 14:30:49 +0100 <fen78> data Foo a where X :: Foo a
2024-02-20 14:31:32 +0100 <fen78> dafuq
2024-02-20 14:31:42 +0100 <fen78> i didnt even know of this
2024-02-20 14:31:56 +0100 <fen78> well apparently not
2024-02-20 14:32:09 +0100 <fen78> maybe less maintained
2024-02-20 14:32:50 +0100 <fen78> i would just go ahead and use the correct extension
2024-02-20 14:33:06 +0100lortabac(~lortabac@37.97.111.147)
2024-02-20 14:34:19 +0100 <fen78> anyway, i much prefer the constraints way to eg datatypes or anything at term level for strictness
2024-02-20 14:34:28 +0100tri(~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 268 seconds)
2024-02-20 14:34:36 +0100 <haskellbridge> <J​ade> I figured out my mistake ... I wrote `-XGADTSyntax -XNoGADTs` and the latter disabled `-XGADTSyntax` ...
2024-02-20 14:34:46 +0100 <fen78> i dont care if your functions output strict values, or your datatypes have strict values in their fancy constructors, or anything.
2024-02-20 14:34:52 +0100 <haskellbridge> <J​ade> I think there's an open ticket for flags interferring with each other
2024-02-20 14:35:10 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 14:35:18 +0100 <fen78> pointless to me if a function somewhere inside makes a strict call with a bang pattern.
2024-02-20 14:35:50 +0100 <fen78> now, you reflect something up as an argument, and now i know its strict cos its not supplied *as a function argument* anymopre
2024-02-20 14:35:56 +0100 <fen78> now you have my attention
2024-02-20 14:36:10 +0100califax(~califax@user/califx)
2024-02-20 14:37:02 +0100 <fen78> this means you could basically prefix an arrow with a ?, but via the constraints it becomes order independent which is sometimes nice
2024-02-20 14:37:51 +0100 <fen78> ah, right, thats why implicit params binds the variable name at the type level, because there is no place to bind it when its not an argument
2024-02-20 14:38:06 +0100targetdisk(~daemonchi@45-33-4-162.ip.linodeusercontent.com) (Remote host closed the connection)
2024-02-20 14:38:58 +0100 <fen78> so, if you have a function argument that *is* strict, instead, supply it as an implicit parameter, this way using the syntax as a placeholder for strictness indicatiopn
2024-02-20 14:39:08 +0100 <lortabac> fen78: if I understand correctly you want to express strictness in types via constraints on argument names
2024-02-20 14:39:12 +0100 <fen78> this should be way more of a thing than it is!
2024-02-20 14:40:49 +0100 <fen78> lortabec: yeah. the syntax is like fun :: ? x :: Int,y~Int => y, instead of fun :: (x~Int,y~Int) => x -> y -> ...
2024-02-20 14:41:14 +0100 <fen78>  fun :: ? x :: Int,y~Int => y -> ...
2024-02-20 14:41:22 +0100 <fen78> fun :: (x~Int,y~Int) => x -> y -> ...
2024-02-20 14:41:46 +0100 <fen78> fun :: (? x :: Int,y~Int) => y -> ...
2024-02-20 14:42:04 +0100 <fen78> and that also says that x appears bound at term level
2024-02-20 14:42:12 +0100 <fen78> like if the class function was called x
2024-02-20 14:42:23 +0100 <fen78> and existed vian an instance as indicated in the constraint
2024-02-20 14:42:46 +0100 <lortabac> maybe you can start from some library like 'named'
2024-02-20 14:42:50 +0100 <lortabac> @hackage named
2024-02-20 14:42:50 +0100 <lambdabot> https://hackage.haskell.org/package/named
2024-02-20 14:43:01 +0100 <lortabac> and add support for strictness constraints
2024-02-20 14:44:22 +0100 <lortabac> to be honest it doesn't look like a simple task, but with enough effort it may be doable
2024-02-20 14:45:11 +0100 <fen78> i think that relies on singletons
2024-02-20 14:45:14 +0100 <fen78> my way doesnt
2024-02-20 14:45:21 +0100 <fen78> no weird text coversion
2024-02-20 14:45:36 +0100 <fen78> actually i have no idea how it tries to bind variables to scope by their name
2024-02-20 14:45:43 +0100 <fen78> but implicait parameters does it perfectly
2024-02-20 14:45:48 +0100 <lortabac> what do you mean by "my way"? do you already have a library that does this?
2024-02-20 14:46:02 +0100 <fen78> implicit parameters presumbaly exists for this reason
2024-02-20 14:46:29 +0100 <fen78> i was working on it ages ago with some unsafecoece thing
2024-02-20 14:46:39 +0100 <fen78> the original reflection stuff
2024-02-20 14:46:42 +0100 <lortabac> oh ok
2024-02-20 14:46:47 +0100 <fen78> but the only reason for the syntax is the theory
2024-02-20 14:46:58 +0100 <lortabac> today you don't need unsafeCoerce anymore for that kind of reflection
2024-02-20 14:47:04 +0100 <lortabac> there is withDict
2024-02-20 14:47:16 +0100 <fen78> im on about the richness it brings to the syntax
2024-02-20 14:47:28 +0100 <lortabac> https://hackage.haskell.org/package/base-4.19.0.0/docs/GHC-Exts.html#t:WithDict
2024-02-20 14:47:30 +0100 <fen78> indicating instantiation occurs away from top level allows for strictness to have occured
2024-02-20 14:47:38 +0100 <lortabac> withDict allows you to create local instances
2024-02-20 14:47:52 +0100 <fen78> yes this is the way id go
2024-02-20 14:47:54 +0100m1dnight(~christoph@82.146.125.185)
2024-02-20 14:47:59 +0100 <fen78> that with the strictness
2024-02-20 14:48:12 +0100 <lortabac> the problem with this kind of reflection is that you can't override the local instances
2024-02-20 14:48:15 +0100 <fen78> but the implicit parameters basically replaces that, and id go for the language proposal really
2024-02-20 14:48:57 +0100 <fen78> i think there could be a lot of good theory work done on how these strictness guaranties percolating on the types gives users assurances such as costless databasing
2024-02-20 14:49:30 +0100 <lortabac> I'm pretty sure there is already a lot of literature on strictness annotations in types
2024-02-20 14:49:40 +0100 <fen78> lortabac: iirc you have to pass around the scope in which the instances hold
2024-02-20 14:49:43 +0100 <lortabac> there may even be something on Hackage
2024-02-20 14:50:04 +0100 <fen78> ahh, yes, it was constraint continuations
2024-02-20 14:50:18 +0100 <fen78> ((a->b)->b) encodes a
2024-02-20 14:50:45 +0100 <fen78> ((? _ :: a=>b)->b) encodes a
2024-02-20 14:51:36 +0100 <fen78> give me a function which needs an a
2024-02-20 14:51:55 +0100 <lortabac> ah nice
2024-02-20 14:52:12 +0100 <lortabac> this may solve a problem that I have with one of my projects :)
2024-02-20 14:52:28 +0100 <fen78> ((?? x :: a=>b)->b) encodes !x :: a
2024-02-20 14:53:43 +0100 <fen78> i guess since the ? at term level, then you could use !?
2024-02-20 14:54:06 +0100 <fen78> !? x :: a=>
2024-02-20 14:55:13 +0100shapr(~user@2603:3005:b31:e100:7e64:336c:bc17:801d) (Ping timeout: 256 seconds)
2024-02-20 14:57:09 +0100 <fen78> so at term level its like let ?x :: a = ...
2024-02-20 14:57:30 +0100 <fen78> so you could have ??x :: a or !?x :: a
2024-02-20 15:00:45 +0100 <fen78> you could use ?? for linear types that are locally instantiated but not nesacarily strict
2024-02-20 15:01:14 +0100 <fen78> destroy after using anywhere variables are guarantied not to be used anywhere else
2024-02-20 15:01:43 +0100 <fen78> if they were strictly created, ie the point where there started being a linear object that can only be used once
2024-02-20 15:02:12 +0100 <fen78> reflection serves as a great point to interject information about strictness and linearness
2024-02-20 15:02:58 +0100 <fen78> i think there is actually a redundancy between linear and strict
2024-02-20 15:03:09 +0100 <fen78> i dont really care if you have computed it or not if its linear
2024-02-20 15:03:17 +0100 <fen78> because i will be the only place that uses it
2024-02-20 15:03:25 +0100 <fen78> doesnt matter when its computed so
2024-02-20 15:03:45 +0100 <fen78> normally you care if something is strict before it gets to you because of copies
2024-02-20 15:03:57 +0100 <fen78> linear types circumvents this, sionce there are no copies
2024-02-20 15:04:03 +0100thegeekinside(~thegeekin@189.217.83.221)
2024-02-20 15:04:16 +0100 <fen78> i think linear types in the way it relates to strictness like this, again pips us to the post
2024-02-20 15:04:35 +0100 <fen78> by bypassing strictness concerns completely!
2024-02-20 15:04:46 +0100 <fen78> so lazy!
2024-02-20 15:04:51 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03) (Ping timeout: 256 seconds)
2024-02-20 15:05:26 +0100 <fen78> i guess in that way a linearity declaratin basically makes a statement equivalent to strictness, but the other way round by making it redundant that its not strict
2024-02-20 15:05:48 +0100 <fen78> renders stric meaningless as an annotation is what we opted for *facepalm*
2024-02-20 15:06:31 +0100 <fen78> in which case i think its a shame that linear types didnt go for the reflection syntax based approach
2024-02-20 15:06:45 +0100 <fen78> a function arrow is kind of crap
2024-02-20 15:06:46 +0100thegeekinside(~thegeekin@189.217.83.221) (Read error: Connection reset by peer)
2024-02-20 15:07:04 +0100 <fen78> i mean, there is always going to be both options, via constraint or argument
2024-02-20 15:07:23 +0100 <fen78> variables in scope by constraint environment or function argument provision
2024-02-20 15:08:01 +0100 <fen78> does linear haskell have linear constraints?
2024-02-20 15:11:04 +0100 <fen78>  !(A ⊸ B) ⇒!A ⊸!B
2024-02-20 15:12:39 +0100troydm(~troydm@user/troydm) (Ping timeout: 260 seconds)
2024-02-20 15:12:44 +0100 <fen78> Linear types and uniqueness types are, at their core, dual: whereas a linear type is a contract that
2024-02-20 15:12:44 +0100 <fen78> a function uses its argument exactly once even if the call’s context can share a linear argument as
2024-02-20 15:12:45 +0100 <fen78> many times as it pleases, a uniqueness type ensures that the argument of a function is not used
2024-02-20 15:12:45 +0100 <fen78> anywhere else in the expression’s context even if the callee can work with the argument as it pleases.
2024-02-20 15:12:49 +0100 <fen78> i got that wrong...
2024-02-20 15:15:23 +0100 <fen78> aha! so the linear types paper discusses this
2024-02-20 15:15:37 +0100 <fen78> basically, they opted for a linear type system because linear logic exists
2024-02-20 15:15:42 +0100 <fen78> and uniquesness types are hard
2024-02-20 15:16:02 +0100 <fen78> what i was saying is that when you have strictness maybe you dont care so much about uniqueness
2024-02-20 15:16:10 +0100 <fen78> you have uniquesness of evlauation, so thats ok
2024-02-20 15:16:21 +0100mmhat(~mmh@p200300f1c70b449eee086bfffe095315.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2024-02-20 15:16:40 +0100 <fen78> both idioms permit copying
2024-02-20 15:16:52 +0100 <fen78> linear types can be copied but are consumed once each
2024-02-20 15:17:21 +0100 <fen78> uniquesness type preclude copying, but strictness permits it, all thats unique is the computation
2024-02-20 15:17:28 +0100 <fen78> copying then infact is favoured
2024-02-20 15:17:53 +0100 <fen78> dont use uniquesness, use strictness, then you can copy as much as you like
2024-02-20 15:20:45 +0100fen78(~fen@84.68.80.95) (Quit: Connection closed)
2024-02-20 15:21:47 +0100thegeekinside(~thegeekin@189.217.83.221)
2024-02-20 15:22:08 +0100oneeyedalien_(~oneeyedal@user/oneeyedalien)
2024-02-20 15:22:32 +0100NSFAF_(~NSFAF@105.232.14.71) (Read error: Connection reset by peer)
2024-02-20 15:25:01 +0100oneeyedalien(~oneeyedal@user/oneeyedalien) (Ping timeout: 264 seconds)
2024-02-20 15:25:55 +0100szkl(uid110435@uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2024-02-20 15:29:51 +0100mmhat(~mmh@p200300f1c70b44daee086bfffe095315.dip0.t-ipconnect.de)
2024-02-20 15:35:27 +0100lortabac(~lortabac@37.97.111.147) (Ping timeout: 256 seconds)
2024-02-20 15:36:42 +0100chele(~chele@user/chele)
2024-02-20 15:50:25 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com) (Remote host closed the connection)
2024-02-20 15:50:37 +0100actioninja(~actioninj@user/actioninja) (Quit: Ping timeout (120 seconds))
2024-02-20 15:50:41 +0100Square(~Square@user/square)
2024-02-20 15:51:00 +0100actioninja(~actioninj@user/actioninja)
2024-02-20 15:52:50 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds)
2024-02-20 15:53:23 +0100Square3(~Square4@user/square) (Ping timeout: 264 seconds)
2024-02-20 15:53:23 +0100myxos(~myxos@065-028-251-121.inf.spectrum.com)
2024-02-20 15:53:40 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 15:54:02 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 252 seconds)
2024-02-20 15:54:41 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2024-02-20 15:54:59 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2024-02-20 15:58:20 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 268 seconds)
2024-02-20 15:59:51 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2024-02-20 16:00:35 +0100danse-nr3(~danse@151.43.209.161) (Remote host closed the connection)
2024-02-20 16:01:30 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 16:03:21 +0100shapr(~user@c-24-218-186-89.hsd1.ma.comcast.net)
2024-02-20 16:04:16 +0100lortabac(~lortabac@37.97.111.147)
2024-02-20 16:06:25 +0100lortabac(~lortabac@37.97.111.147) (Client Quit)
2024-02-20 16:07:07 +0100lottaquestions_(~nick@2607:fa49:503d:b200:a224:6171:dcbc:3474) (Quit: Konversation terminated!)
2024-02-20 16:16:40 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03)
2024-02-20 16:30:53 +0100mulk(~mulk@pd9514af5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2024-02-20 16:31:54 +0100mulk(~mulk@pd95147b3.dip0.t-ipconnect.de)
2024-02-20 16:34:05 +0100xff0x(~xff0x@ai082039.d.east.v6connect.net) (Ping timeout: 240 seconds)
2024-02-20 16:34:12 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 16:35:45 +0100Vq(~vq@2001:2043:1c58:ea00:ca7f:54ff:fe6a:fd48)
2024-02-20 16:36:20 +0100xff0x(~xff0x@178.255.149.135)
2024-02-20 16:38:31 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 260 seconds)
2024-02-20 16:41:11 +0100xff0x(~xff0x@178.255.149.135) (Ping timeout: 256 seconds)
2024-02-20 16:41:52 +0100CiaoSen(~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03) (Ping timeout: 255 seconds)
2024-02-20 16:42:07 +0100danse-nr3(~danse@151.43.209.161) (Ping timeout: 268 seconds)
2024-02-20 16:42:39 +0100xff0x(~xff0x@ai082039.d.east.v6connect.net)
2024-02-20 16:45:57 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2024-02-20 16:47:39 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 16:49:35 +0100todi(~todi@p4fd1a2f5.dip0.t-ipconnect.de)
2024-02-20 16:52:01 +0100euphores(~SASL_euph@user/euphores)
2024-02-20 16:52:36 +0100danse-nr3(~danse@151.43.209.161) (Ping timeout: 268 seconds)
2024-02-20 16:54:06 +0100oneeyedalien_(~oneeyedal@user/oneeyedalien) (Quit: Leaving)
2024-02-20 16:54:27 +0100Square(~Square@user/square) (Ping timeout: 255 seconds)
2024-02-20 16:55:32 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 16:55:49 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 16:59:58 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 264 seconds)
2024-02-20 17:00:07 +0100ubert(~Thunderbi@2a02:8109:ab8a:5a00:ce61:4d12:7531:ec69) (Remote host closed the connection)
2024-02-20 17:02:13 +0100danse-nr3(~danse@151.43.209.161) (Ping timeout: 264 seconds)
2024-02-20 17:11:12 +0100 <tinjamin> geez fen78 really had a monologue
2024-02-20 17:14:14 +0100danse-nr3(~danse@151.43.209.161)
2024-02-20 17:15:58 +0100 <shapr> srk: nice to see activity on haskellEmbedded!
2024-02-20 17:20:44 +0100 <tinjamin> very vague and common question but like in general, what is haskell specialized for? Like C and Rust are good for systems programming, but idk what haskell is good for
2024-02-20 17:22:30 +0100cfricke(~cfricke@user/cfricke) (Ping timeout: 268 seconds)
2024-02-20 17:25:00 +0100 <sm> tinjamin: it's a language good for many things but people usually get most benefit when you need high quality/high assurance; high expressiveness for implementing complex logic; and/or high maintainability for medium/large codebases over medium/long term
2024-02-20 17:26:36 +0100 <sm> currently it's often seen in fintech, as the backend for web apps, and for implementing/processing languages
2024-02-20 17:27:11 +0100 <sm> also, of course, it's very good for teaching and research
2024-02-20 17:29:03 +0100 <sm> some people learn it early but I think it is most appreciated by experienced software developers
2024-02-20 17:32:36 +0100 <EvanR> are C and rust really good for systems programming
2024-02-20 17:33:12 +0100 <EvanR> C was originally for programming in a more abstract way when you weren't worried about numeric performance and didn't want fortran
2024-02-20 17:33:26 +0100 <EvanR> like ruby might be used for today
2024-02-20 17:33:46 +0100 <EvanR> haskell describes itself as a general purpose language
2024-02-20 17:34:13 +0100euleritian(~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de)
2024-02-20 17:34:34 +0100euleritian(~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-02-20 17:34:57 +0100euleritian(~euleritia@77.22.252.56)
2024-02-20 17:37:01 +0100ski(~ski@ext-1-033.eduroam.chalmers.se) (Ping timeout: 260 seconds)
2024-02-20 17:37:18 +0100 <haskellbridge> <s​m> "an expressive, powerful language for building high quality long lasting software at low cost"
2024-02-20 17:38:44 +0100 <EvanR> the long lasting part is interesting
2024-02-20 17:38:52 +0100 <tinjamin> sm: so if I want to get more into systems programming is it worth it to study haskell? don't get me wrong, ik it's worth it to study haskell because it's a new perspective and extraordinarily elegant but I wanna do some systems programming and wonder if haskell is the right tool.
2024-02-20 17:40:11 +0100 <haskellbridge> <s​m> "as long as the sponsors and spare time volunteers work to keep old GHC versions and deps building on your platform"....
2024-02-20 17:41:26 +0100 <sm> tinjamin: got an example of the kind of systems programming you have in mind ? Rust is used in linux kernel these days and Zig is also a fun place to be
2024-02-20 17:43:39 +0100ski(~ski@ext-1-033.eduroam.chalmers.se)
2024-02-20 17:44:15 +0100 <tinjamin> sm: not in particular since I am a noob lol but I like writing shell scripts and want to write my own http-server with aspirations of learning OS stuff from Operating System Three Easy Pieces which is in C but i wanna do it in a more modern language
2024-02-20 17:44:28 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2024-02-20 17:45:17 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2024-02-20 17:45:27 +0100 <tinjamin> My gut tells me rust might be better and actually help get my hands dirty but haskell is so elegant and foreign
2024-02-20 17:45:30 +0100 <sm> cool. For shell scripting you just can't beat shell, it's designed for that. I recommend oil shell which will replace bash.
2024-02-20 17:45:51 +0100 <sm> for experimenting with a http server haskell is good, but go is also designed for that
2024-02-20 17:46:23 +0100 <tinjamin> yeah i talked to some of my folks at uni and the talk revolved around go vs rust
2024-02-20 17:47:59 +0100igemnace(~ian@user/igemnace) (Quit: WeeChat 4.2.1)
2024-02-20 17:48:32 +0100 <sm> write something small in all of them and see how it goes ?
2024-02-20 17:48:42 +0100 <sm> perhaps the same thing
2024-02-20 17:51:50 +0100 <tinjamin> hmm I think I am just not mature enough programming wise yet to see the benefits of haskell.
2024-02-20 17:53:46 +0100 <sm> people often say that knowing a little haskell helps them think/program more clearly in any language
2024-02-20 17:54:56 +0100danse-nr3(~danse@151.43.209.161) (Read error: Connection reset by peer)
2024-02-20 17:55:49 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2024-02-20 17:56:05 +0100 <sm> that's true for me certainly. Haskell is perhaps the best place to learn the functional programming style
2024-02-20 17:56:09 +0100danse-nr3(~danse@151.43.160.252)
2024-02-20 17:56:44 +0100euleritian(~euleritia@77.22.252.56) (Ping timeout: 268 seconds)
2024-02-20 17:57:18 +0100euleritian(~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de)
2024-02-20 17:57:58 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (Ping timeout: 268 seconds)
2024-02-20 17:58:40 +0100Maxdamantus(~Maxdamant@user/maxdamantus)
2024-02-20 18:01:11 +0100jjhoo(~jahakala@user/jjhoo) (Ping timeout: 264 seconds)
2024-02-20 18:03:57 +0100 <kuribas> tinjamin: haskell is quite far from system programming, as it tries to abstract away from the hardware. Still, it offers enough tools for allowing low level code.
2024-02-20 18:05:28 +0100 <kuribas> If "systems programming" means low level drivers, network protocols, or embedded hardware, then probably haskell is not a good choice.
2024-02-20 18:05:57 +0100 <kuribas> Though a lot of "embedded hardware" is powerful enough for haskell these days (raspberry pi's etc...)
2024-02-20 18:06:35 +0100enoq(~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650) (Remote host closed the connection)
2024-02-20 18:06:35 +0100 <EvanR> garbage collector in your drivers would be "interesting"
2024-02-20 18:07:33 +0100ulthuan23456(~ulthuan23@2a09:bac3:3116:191::28:90)
2024-02-20 18:10:01 +0100ulthuan23456(~ulthuan23@2a09:bac3:3116:191::28:90) (Client Quit)
2024-02-20 18:10:23 +0100kaskal(~kaskal@2001:4bb8:2c3:39c1:ff3f:d58:4fd9:e10c) (Quit: ZNC - https://znc.in)
2024-02-20 18:10:31 +0100 <geekosaur> there's always https://github.com/dls/house
2024-02-20 18:10:37 +0100danse-nr3(~danse@151.43.160.252) (Ping timeout: 264 seconds)
2024-02-20 18:11:28 +0100kaskal(~kaskal@2001:4bb8:2c3:39c1:ff3f:d58:4fd9:e10c)
2024-02-20 18:12:49 +0100jjhoo(jahakala@user/jjhoo)
2024-02-20 18:16:49 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 272 seconds)
2024-02-20 18:18:19 +0100jjhoo(jahakala@user/jjhoo) (Ping timeout: 268 seconds)
2024-02-20 18:18:33 +0100euleritian(~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) (Read error: Connection reset by peer)
2024-02-20 18:18:51 +0100euleritian(~euleritia@77.22.252.56)
2024-02-20 18:20:37 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 18:22:05 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 18:24:06 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2024-02-20 18:24:54 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds)
2024-02-20 18:27:34 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 268 seconds)
2024-02-20 18:28:14 +0100penteract(~penteract@cpc80271-blbn12-2-0-cust449.10-1.cable.virginm.net)
2024-02-20 18:29:16 +0100 <mauke> <EvanR> garbage collector in your drivers would be "interesting" <- that would rule out Go as well (re: <tinjamin> yeah i talked to some of my folks at uni and the talk revolved around go vs rust)
2024-02-20 18:31:00 +0100Lycurgus(~georg@user/Lycurgus) (Quit: leaving)
2024-02-20 18:32:34 +0100rvalue(~rvalue@user/rvalue) (Ping timeout: 255 seconds)
2024-02-20 18:33:37 +0100 <probie> EvanR: Avoid garbage collection by just not allocating
2024-02-20 18:33:57 +0100 <EvanR> in haskell? I heard this can happen
2024-02-20 18:34:18 +0100 <mauke> avoid garbage collection by introducing space leaks
2024-02-20 18:34:22 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2024-02-20 18:35:29 +0100 <EvanR> each call into the driver spawns a process which never reclaims memory, and provably dies and completes mission before it runs out of memory xD
2024-02-20 18:39:55 +0100rvalue(~rvalue@user/rvalue)
2024-02-20 18:40:27 +0100 <monochrom> JHC didn't have garbage collection for a long time. >:D
2024-02-20 18:40:52 +0100 <monochrom> (That's right, it simply let space leak happen.)
2024-02-20 18:42:01 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2024-02-20 18:48:00 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2024-02-20 18:52:41 +0100 <EvanR> move fast, brk instruction
2024-02-20 18:54:02 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2024-02-20 18:54:03 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 18:57:07 +0100 <noctux> where is the problem in gc-ing in kernel space?
2024-02-20 18:58:05 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 240 seconds)
2024-02-20 18:59:09 +0100 <noctux> I mean, at the end of the day, there is your allocator, and there are your kernel stacks and your globals. as long as you can identify all those, there shouldn't be to much difference between kernel and userspace probably?
2024-02-20 19:05:16 +0100penteract(~penteract@cpc80271-blbn12-2-0-cust449.10-1.cable.virginm.net) (Ping timeout: 250 seconds)
2024-02-20 19:09:36 +0100 <geekosaur> interrupt handlers and near-realtime-response drivers
2024-02-20 19:10:08 +0100 <noctux> so don't gc in time-sensitive codepatha
2024-02-20 19:10:20 +0100 <noctux> *codepaths
2024-02-20 19:10:28 +0100 <geekosaur> the former are a problem even in normal kernels, for example linux's network interrupt handlers keep around preallocated buffers
2024-02-20 19:11:11 +0100 <noctux> so do so with your gc as well?
2024-02-20 19:12:56 +0100 <geekosaur> the problem with this is your compiler needs to generate different code for those paths. ghc, for example, assumes allocation and gc is always cheap (which it usually is because of the nursery)
2024-02-20 19:13:03 +0100 <noctux> that's more of a latency (and consistency/synchronisation, in case of concurrent alloc in the handler) issue... not so much a fundamental problem
2024-02-20 19:15:01 +0100 <noctux> a, sure, and potentially you want to tune your gc a bit... there was a bit of research into realtime-compatible GCs from the real-time java crowd
2024-02-20 19:15:42 +0100 <noctux> (back when java was a thing)
2024-02-20 19:16:08 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-02-20 19:23:35 +0100son0p(~ff@167.0.172.211) (Ping timeout: 252 seconds)
2024-02-20 19:23:47 +0100wootehfoot(~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer)
2024-02-20 19:30:14 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2024-02-20 19:30:33 +0100 <EvanR> my desktop is running like windows 95, better open up the hood and tune my gc
2024-02-20 19:30:47 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2024-02-20 19:35:44 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99) (Read error: Connection reset by peer)
2024-02-20 19:36:35 +0100 <noctux> :D
2024-02-20 19:36:57 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99)
2024-02-20 19:37:01 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752)
2024-02-20 19:37:40 +0100ski(~ski@ext-1-033.eduroam.chalmers.se) (Remote host closed the connection)
2024-02-20 19:40:02 +0100cfricke(~cfricke@user/cfricke)
2024-02-20 19:43:49 +0100ski(~ski@ext-1-033.eduroam.chalmers.se)
2024-02-20 19:52:45 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 19:54:26 +0100Taneb(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (Quit: I seem to have stopped.)
2024-02-20 19:57:09 +0100Taneb(~Taneb@runciman.hacksoc.org)
2024-02-20 20:06:12 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection)
2024-02-20 20:07:55 +0100target_i(~target_i@217.175.14.39)
2024-02-20 20:11:08 +0100oo_miguel(~Thunderbi@78-11-181-16.static.ip.netia.com.pl) (Quit: oo_miguel)
2024-02-20 20:11:56 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2024-02-20 20:15:28 +0100derpyxdhs(~Thunderbi@user/derpyxdhs)
2024-02-20 20:17:32 +0100derpyxdhs(~Thunderbi@user/derpyxdhs) (Client Quit)
2024-02-20 20:19:48 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2024-02-20 20:21:35 +0100danse-nr3(~danse@151.43.155.200)
2024-02-20 20:22:36 +0100gabriel_sevecek(~gabriel@188-167-229-200.dynamic.chello.sk) (Quit: WeeChat 4.1.1)
2024-02-20 20:24:14 +0100gabriel_sevecek(~gabriel@188-167-229-200.dynamic.chello.sk)
2024-02-20 20:24:44 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Quit: _ht)
2024-02-20 20:24:54 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2024-02-20 20:27:40 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2024-02-20 20:28:30 +0100 <srk> shapr: <3, finally got a bit unstuck \o/
2024-02-20 20:32:39 +0100ski(~ski@ext-1-033.eduroam.chalmers.se) (Remote host closed the connection)
2024-02-20 20:32:48 +0100ski(~ski@ext-1-033.eduroam.chalmers.se)
2024-02-20 20:33:43 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 260 seconds)
2024-02-20 20:35:02 +0100euleritian(~euleritia@77.22.252.56) (Read error: Connection reset by peer)
2024-02-20 20:35:22 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2024-02-20 20:37:14 +0100ulvarref`(~user@188.124.56.153) (Remote host closed the connection)
2024-02-20 20:52:23 +0100Vq(~vq@2001:2043:1c58:ea00:ca7f:54ff:fe6a:fd48) (Ping timeout: 260 seconds)
2024-02-20 20:54:07 +0100Vq(~vq@81-231-76-8-no600.tbcn.telia.com)
2024-02-20 20:54:23 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 20:55:03 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer)
2024-02-20 20:56:45 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 20:58:49 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds)
2024-02-20 20:59:28 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer)
2024-02-20 20:59:52 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 21:00:55 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Remote host closed the connection)
2024-02-20 21:01:23 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 21:02:50 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer)
2024-02-20 21:03:11 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 21:03:39 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 4.1.2)
2024-02-20 21:04:01 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer)
2024-02-20 21:04:25 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 21:04:52 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca) (Remote host closed the connection)
2024-02-20 21:05:15 +0100sam113101(~sam@modemcable146.137-200-24.mc.videotron.ca)
2024-02-20 21:06:43 +0100fendor(~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection)
2024-02-20 21:15:20 +0100euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2024-02-20 21:15:40 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-02-20 21:20:54 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 21:25:15 +0100euphores(~SASL_euph@user/euphores)
2024-02-20 21:27:06 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 21:31:39 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds)
2024-02-20 21:34:28 +0100son0p(~ff@167.0.172.211)
2024-02-20 21:38:26 +0100chele(~chele@user/chele) (Remote host closed the connection)
2024-02-20 21:42:59 +0100ft(~ft@p508db2e6.dip0.t-ipconnect.de)
2024-02-20 21:46:09 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2024-02-20 21:57:04 +0100danse-nr3(~danse@151.43.155.200) (Read error: Connection reset by peer)
2024-02-20 21:57:39 +0100danse-nr3(~danse@151.57.200.9)
2024-02-20 21:59:01 +0100 <shapr> ski: yay!
2024-02-20 21:59:17 +0100 <shapr> ski: what were you stuck on?
2024-02-20 21:59:26 +0100 <shapr> oops, misreply
2024-02-20 21:59:31 +0100 <shapr> srk: what were you stuck on?
2024-02-20 21:59:35 +0100shaprfacepalms
2024-02-20 21:59:58 +0100 <mauke> I don't know that combinator
2024-02-20 22:00:05 +0100califax(~califax@user/califx) (Remote host closed the connection)
2024-02-20 22:01:09 +0100califax(~califax@user/califx)
2024-02-20 22:01:45 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2024-02-20 22:08:11 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752)
2024-02-20 22:14:44 +0100 <shapr> :-P
2024-02-20 22:15:21 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2024-02-20 22:19:11 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2024-02-20 22:21:01 +0100phma(~phma@host-67-44-208-78.hnremote.net) (Read error: Connection reset by peer)
2024-02-20 22:22:25 +0100phma(phma@2001:5b0:211c:c1d8:e754:54f0:2658:655)
2024-02-20 22:23:34 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2024-02-20 22:27:11 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 22:28:11 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Remote host closed the connection)
2024-02-20 22:28:15 +0100gorignak(~gorignak@user/gorignak)
2024-02-20 22:28:44 +0100shapr(~user@c-24-218-186-89.hsd1.ma.comcast.net) (Remote host closed the connection)
2024-02-20 22:30:45 +0100euphores(~SASL_euph@user/euphores) (Quit: Leaving.)
2024-02-20 22:35:48 +0100euphores(~SASL_euph@user/euphores)
2024-02-20 22:36:29 +0100danse-nr3(~danse@151.57.200.9) (Ping timeout: 272 seconds)
2024-02-20 22:37:10 +0100fen53(~fen@84.68.80.95)
2024-02-20 22:37:54 +0100fen53fen_
2024-02-20 22:38:10 +0100 <fen_> i can give a code example
2024-02-20 22:38:24 +0100 <fen_> its of the random numbers thing
2024-02-20 22:38:31 +0100 <fen_> global strict scope
2024-02-20 22:38:43 +0100 <fen_> which i want help a workaround with
2024-02-20 22:40:03 +0100 <fen_> https://paste.tomsmeding.com/Ty2UIMmo
2024-02-20 22:40:24 +0100euphores(~SASL_euph@user/euphores) (Client Quit)
2024-02-20 22:40:45 +0100 <fen_> newRough :: Parametric a init => Int -> [Double] -> init -> Rough a init
2024-02-20 22:41:02 +0100 <fen_> data Rough a init where
2024-02-20 22:41:03 +0100 <fen_>      Rough :: Parametric a init
2024-02-20 22:41:03 +0100 <fen_>            => (Seed,Length)
2024-02-20 22:41:04 +0100 <fen_>            -> (Length,Length)
2024-02-20 22:41:04 +0100 <fen_>            -> [[Double]]
2024-02-20 22:41:05 +0100 <fen_>            -> [Double]
2024-02-20 22:41:05 +0100 <fen_>            -> a
2024-02-20 22:41:06 +0100 <fen_>            -> Rough a init
2024-02-20 22:41:22 +0100 <fen_>  [[Double]] is the random numbers
2024-02-20 22:42:03 +0100euphores(~SASL_euph@user/euphores)
2024-02-20 22:42:47 +0100 <fen_> lengths pertain to the length of a random mask given from the seed
2024-02-20 22:43:19 +0100 <[exa]> fen_: please do not copypaste to here, it gets very ugly on cellphones etc.
2024-02-20 22:43:26 +0100 <fen_> erp sorry
2024-02-20 22:43:29 +0100 <[exa]> np
2024-02-20 22:43:32 +0100 <fen_> it reads ok on my screen
2024-02-20 22:43:53 +0100 <fen_> length of the parameters of the parametric object etc.
2024-02-20 22:44:27 +0100 <EvanR> @where paste
2024-02-20 22:44:27 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2024-02-20 22:44:47 +0100 <fen_> so there is no guarantee that these randoms are not recualculated in different values of this datatype
2024-02-20 22:45:04 +0100 <[exa]> fen_: where's the Parametric from?
2024-02-20 22:45:09 +0100miumiu(~miumiu@45-181-100-129.plugartelecom.net.br)
2024-02-20 22:45:10 +0100 <fen_> EvanR: the paste above is https://paste.tomsmeding.com/Ty2UIMmo
2024-02-20 22:46:03 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection)
2024-02-20 22:46:05 +0100miumiu(~miumiu@45-181-100-129.plugartelecom.net.br) (Client Quit)
2024-02-20 22:46:08 +0100 <fen_> parametric; https://paste.tomsmeding.com/tLezIM9t
2024-02-20 22:47:00 +0100 <fen_> support: https://paste.tomsmeding.com/EHQtfCha
2024-02-20 22:47:00 +0100miumiu(~miumiu@45-181-100-129.plugartelecom.net.br)
2024-02-20 22:47:10 +0100 <fen_> (that algo is nuts btw, never been checked!)
2024-02-20 22:47:31 +0100 <fen_> binary tree with a random hack to make it one item extendible
2024-02-20 22:47:56 +0100 <fen_> all the parametric objects get convinient random support coefs of any length
2024-02-20 22:48:11 +0100 <fen_> now, what i want to do, is ensure these random numbers are never recalculated
2024-02-20 22:48:29 +0100 <fen_> there is a slight issue with offsets in composite parametric objects...
2024-02-20 22:48:54 +0100miumiu(~miumiu@45-181-100-129.plugartelecom.net.br) (Client Quit)
2024-02-20 22:49:05 +0100 <fen_> so maybe it wants to have this handled specifically, so lists of parameteric objects have associated lists of random supports eg with different seeds
2024-02-20 22:49:27 +0100 <EvanR> to avoid recalculation there's memoization
2024-02-20 22:49:37 +0100 <EvanR> memocombinators?
2024-02-20 22:49:51 +0100 <fen_> im going to be using implicit params
2024-02-20 22:50:00 +0100 <fen_> they allow strict binding of local instances
2024-02-20 22:50:23 +0100 <fen_> and a semantic placeholder for strict variables under assumption of use of a strictly binding reflector
2024-02-20 22:50:26 +0100 <fen_> i want to write that
2024-02-20 22:50:37 +0100 <[exa]> fen_: so the overall goal of the thing is like, distributing the entropy around?
2024-02-20 22:50:56 +0100 <fen_> its basically wishing the random numbers could be declared at top level and be strict
2024-02-20 22:51:22 +0100 <fen_> they have to be evaluated and then strictly bound away from top level
2024-02-20 22:51:33 +0100 <fen_> so a local instance, or a regular variable
2024-02-20 22:51:50 +0100 <fen_> local instance here makes it apparent at type level
2024-02-20 22:51:50 +0100 <[exa]> oic, and ideally without pulling a monad through everything.
2024-02-20 22:52:07 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net)
2024-02-20 22:52:10 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752)
2024-02-20 22:52:17 +0100 <fen_> its a constraint, and yeah, other approaches to scoping would need a propegation structure which is likely monadic
2024-02-20 22:52:32 +0100 <[exa]> tbh I'm a bit lost in the code
2024-02-20 22:53:07 +0100 <fen_> can you get it to compile?
2024-02-20 22:53:18 +0100 <[exa]> cellphone :)
2024-02-20 22:53:28 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2024-02-20 22:53:30 +0100 <[exa]> (man I wish I had ghci on the cellphone)
2024-02-20 22:53:58 +0100 <fen_> https://paste.tomsmeding.com/j4CWgC50
2024-02-20 22:54:12 +0100 <fen_> thats my prolude module which youd need for complication for people on machines with compilers
2024-02-20 22:54:31 +0100 <fen_> basically the support algorithm implements a binary tree
2024-02-20 22:54:38 +0100 <fen_> you could just have regular coefs
2024-02-20 22:54:43 +0100tri(~tri@ool-18bbef1a.static.optonline.net)
2024-02-20 22:55:03 +0100 <fen_> but this way is good for learning, as it has extra variables dealing with hierarchical grouping
2024-02-20 22:55:10 +0100 <fen_> the n=2 case of the btree is the optimal
2024-02-20 22:55:21 +0100 <fen_> and has this weird hack to make it one object extensible
2024-02-20 22:55:28 +0100 <fen_> like a regular coefecient list is
2024-02-20 22:56:06 +0100 <fen_> you just grow this btree ass you keep adding support coefecients
2024-02-20 22:56:34 +0100 <fen_> can be ignored, can just consider the extensibility of a regular coefecient vector
2024-02-20 22:56:42 +0100 <fen_> these are coefs to random vectors
2024-02-20 22:56:47 +0100 <fen_> (at the leafs of the btree)
2024-02-20 22:56:56 +0100 <[exa]> aren't there skippable RNGs that kinda make sure you don't need the support tree here?
2024-02-20 22:57:15 +0100 <fen_> which are superposed to give any (but a specified) length of supported vector, then used to reparametrize the object
2024-02-20 22:57:23 +0100thegeekinside(~thegeekin@189.217.83.221) (Ping timeout: 272 seconds)
2024-02-20 22:57:36 +0100 <fen_> the rngs are these vectors that are random that can be precomputed
2024-02-20 22:57:48 +0100 <fen_> so they should be global
2024-02-20 22:57:56 +0100 <fen_> but also very much not being recomputed
2024-02-20 22:58:22 +0100 <fen_> these could appear at eveery one of a deep neuronal nets neurons as the encoding of a nonlinear parametric deep transfer object
2024-02-20 22:58:44 +0100 <fen_> fractal complexity does not lend well to not having memoised a huge common piece of data
2024-02-20 22:58:54 +0100thegeekinside(~thegeekin@189.217.83.221)
2024-02-20 22:59:00 +0100 <EvanR> sounds deep
2024-02-20 22:59:03 +0100 <[exa]> yap.
2024-02-20 22:59:05 +0100 <EvanR> ak chopra
2024-02-20 22:59:06 +0100 <fen_> true dat
2024-02-20 22:59:19 +0100tri(~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 260 seconds)
2024-02-20 22:59:21 +0100 <[exa]> nvm guys have to sleep, good luck
2024-02-20 22:59:40 +0100 <fen_> chow
2024-02-20 23:00:11 +0100 <fen_> tbh i am lost in the code also
2024-02-20 23:00:26 +0100coot(~coot@89-69-206-216.dynamic.chello.pl) (Quit: coot)
2024-02-20 23:00:35 +0100 <fen_> anyway. sorry i just had to clear up something for someone
2024-02-20 23:01:17 +0100 <fen_> so nrmally like at the neurons, you would have this rough object, with the random numbers there in the Rough datatype
2024-02-20 23:01:52 +0100 <fen_> which is really at risk of recomputation, esp, given that the different positions the rough objects appear at, might be of different sizes, and invoke different rng calculations
2024-02-20 23:02:22 +0100 <fen_> so it needs a standard approach, and i would like to (but am not sure how to) use implicit params for the strictness indication at type level
2024-02-20 23:02:43 +0100 <fen_> i wouldnt bring it to ask the comunity if it wasnt in this new idiom
2024-02-20 23:02:56 +0100 <fen_> which is kind of what i feel as though is worth asking for colaberation o
2024-02-20 23:03:14 +0100 <fen_> like "we" kind of need to know how to do this, so could do it together
2024-02-20 23:03:28 +0100 <fen_> given all the machinery for it and justification already exists
2024-02-20 23:03:36 +0100 <fen_> just a case opf putting together a code example
2024-02-20 23:04:18 +0100 <fen_> ...
2024-02-20 23:04:29 +0100 <probie> Why implicit params and not just something like the reader monad?
2024-02-20 23:04:45 +0100 <fen_> eg im looking for answers like "isnt what you need just a constraint in the datatype constructors signature?"
2024-02-20 23:05:20 +0100 <fen_> probie: compositionality algebra of the context being via constraints
2024-02-20 23:05:48 +0100 <fen_> and also that the iomplicit parameter is to be specifically used to annotate possible strictness
2024-02-20 23:05:52 +0100 <fen_> which it literally does
2024-02-20 23:06:02 +0100 <fen_> other constraints are sure not to be strict
2024-02-20 23:06:30 +0100 <fen_> arguments could be either, there is no different syntax
2024-02-20 23:07:17 +0100 <fen_> like what does the code doing this actually look like?
2024-02-20 23:07:47 +0100 <fen_> implicit params in GADT constructor signatures
2024-02-20 23:08:27 +0100 <fen_> with the existence of a strict reflection technique
2024-02-20 23:08:43 +0100 <fen_> which i think is just a double let binding
2024-02-20 23:08:56 +0100 <fen_> one for the !, one for the ?
2024-02-20 23:09:45 +0100 <fen_> (i was proposing a new constructor that merged the two `!?' such that certain strictness could be indicated using a form of implicit params)
2024-02-20 23:10:01 +0100 <fen_> and in order to return something
2024-02-20 23:10:15 +0100 <fen_> like, because it wants to be encapsulated in a function, so we seek a return type
2024-02-20 23:10:28 +0100 <fen_> this is an environment in which the reflected data can be used
2024-02-20 23:11:05 +0100 <fen_> which i think is a constraint continuation of the form ((? _ :: a => b) -> b)
2024-02-20 23:11:09 +0100 <fen_> this is what i have to go off
2024-02-20 23:11:42 +0100 <fen_> like, to use the datatype, the constraint has to be satisfied
2024-02-20 23:12:23 +0100 <fen_> so you need one of these environments to actually perform computations using that datatype when it accesses those variables
2024-02-20 23:12:44 +0100 <fen_> such an environment is normally constructed using ? in a let binding
2024-02-20 23:13:04 +0100 <fen_> but if that scope is to be returned, then something like a constrant continuation is required
2024-02-20 23:13:59 +0100 <fen_> ((? randomNumbers :: [[Double]] => Rough Object) -> Rough Object)
2024-02-20 23:14:34 +0100 <fen_> where data Rough has a constructor of type Rough :: ? randomNumbers :: [[Double]] => ...
2024-02-20 23:14:55 +0100 <fen_> iv never seen anyone use implicit params in a datatype
2024-02-20 23:15:45 +0100 <fen_> the syntax i propose would allow for datatype constructors to have signatures of the form Rough :: !? randomNumbers :: [[Double]] => ...
2024-02-20 23:17:16 +0100 <fen_> indicating the implicit params are strctly bound by a ! let binding, before being bound to implicit parameter scope by a ? let binding, overall returning an environment where the datatype can be used "by having had its construction completed"
2024-02-20 23:17:34 +0100 <fen_> which is a really strange notion, which constraints add to datatypes
2024-02-20 23:18:03 +0100 <fen_> that even a completed datatype might essentially still be missing arguments provided by the constraint
2024-02-20 23:19:12 +0100 <fen_> aka. provision of implicit parameters to the datatype constructor, requires handling of the scope in which these references are satisfiable
2024-02-20 23:19:47 +0100 <fen_> less so than with instances declared at top level which as an all encompasing scope
2024-02-20 23:20:19 +0100 <fen_> you just havent defined an instance yet and its essentially a type error in terms of missing top level global definitions
2024-02-20 23:21:20 +0100 <fen_> ie you would get a missing instance, having written the constraint properly, with the constraint at the function using the datatype having to subsume that of the datatypes used within the functions definition
2024-02-20 23:21:44 +0100 <fen_> but with it away from top level, these implicit parameters do not have such a global type error
2024-02-20 23:21:59 +0100 <fen_> and the handling of the restricted scope is required
2024-02-20 23:22:05 +0100a51(a51@gateway/vpn/protonvpn/a51) (Quit: WeeChat 4.2.1)
2024-02-20 23:22:06 +0100 <fen_> its a new requirewment that appears
2024-02-20 23:22:35 +0100 <fen_> types containing local data, not mimicking a lack of top level strictness
2024-02-20 23:23:12 +0100 <fen_> such that to work with stricness at type level, we begin having to handle restricted scopes
2024-02-20 23:23:22 +0100 <fen_> with me so far?
2024-02-20 23:23:33 +0100 <fen_> im asking that we should together write such an example
2024-02-20 23:24:17 +0100 <fen_> can anyone understand about the constraints in the continuations and the restricted scope enough to write what i described?
2024-02-20 23:25:05 +0100yoo(~yo0O0o@104.28.194.104)
2024-02-20 23:28:42 +0100danse-nr3(~danse@151.57.200.9)
2024-02-20 23:31:13 +0100julie_pilgrim(~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection)
2024-02-20 23:31:27 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2024-02-20 23:32:25 +0100 <geekosaur> fen_, do you think you could not take over the channel?
2024-02-20 23:34:09 +0100 <fen_> is there a wrong answer to this?
2024-02-20 23:34:20 +0100 <fen_> appologies
2024-02-20 23:34:53 +0100 <fen_> ill just assume anyone capable would rather mod me
2024-02-20 23:35:33 +0100 <fen_> i have a language extension relavent theoretic development
2024-02-20 23:35:48 +0100 <fen_> i want a least working example as a comunity effort, hang me
2024-02-20 23:36:15 +0100 <geekosaur> IRC is not the place for extended, involved discussions like that. there is reddit, there is the discourse
2024-02-20 23:36:20 +0100 <fen_> i dont find it helpful when mods essentially preclude from the outcome
2024-02-20 23:36:30 +0100 <fen_> its not like im writing gibberish
2024-02-20 23:36:54 +0100 <fen_> its a place i can find people actually capable of things like comunity development
2024-02-20 23:37:06 +0100 <fen_> of the language. we have done this extensively over the years
2024-02-20 23:37:16 +0100 <fen_> your claims seem gripey
2024-02-20 23:37:22 +0100 <c_wraith> then read it as "you're probably not going to get engagement here if your idea doesn't fit in one or two lines"
2024-02-20 23:37:26 +0100 <sm> fen_ it's still preferred by everyone here not to see a wall of text. Try to wait and get a dialog going. You can always post longer writing on discourse or reddit and link it here.
2024-02-20 23:37:27 +0100 <mauke> <fen_> its not like im writing gibberish <- debatable
2024-02-20 23:37:32 +0100 <sm> Get along with folks here or you won't last
2024-02-20 23:37:49 +0100 <fen_> its a good proposal, it has reasonably interesting associated theoretical considerations, there has been discussion
2024-02-20 23:38:03 +0100michalz(~michalz@185.246.207.197) (Quit: ZNC 1.8.2 - https://znc.in)
2024-02-20 23:38:08 +0100 <fen_> sm: no, your being encouraged by a mod not to read
2024-02-20 23:38:10 +0100 <sm> I would be interested to read it as a single post somehwere suitable
2024-02-20 23:38:14 +0100yoo(~yo0O0o@104.28.194.104) (Ping timeout: 260 seconds)
2024-02-20 23:38:45 +0100 <fen_> mauke: not like that debate is as fruitfull as the non-giberish. its sound theory
2024-02-20 23:39:07 +0100 <fen_> sm: i dont have that capability. the mod attitude would prevent the material seeing the light of day
2024-02-20 23:39:16 +0100 <mauke> as someone said 10 hours ago, "you are talking by yourself. Maybe you want to write a book or an article instead"
2024-02-20 23:39:24 +0100 <sm> not interested in this argument, let's discuss haskell in a friendly way eh
2024-02-20 23:39:52 +0100 <fen_> you would prefer it was something you could say you had not seen, this is always the case of general attitudes of a censor. i actually study it btw now i work in a social media company, and im often put in mind of unhelpful modding in irc
2024-02-20 23:40:01 +0100machinedgod(~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 264 seconds)
2024-02-20 23:40:23 +0100 <fen_> basically as soon as a mod has to contend with a flood, then its a "yoursing your words again are we", which totally i agree, is a detraction
2024-02-20 23:40:54 +0100 <mauke> that's not what censorship is
2024-02-20 23:41:15 +0100 <fen_> mauke: this kind of cometary! where he is like, go write a book, or save it for your blog howard, wheree the intension is so they *dont* have to read it. its simply rude!
2024-02-20 23:41:17 +0100 <geekosaur> apparently we users of #haskell do not have the right to decide what is reasonable use of our channel?
2024-02-20 23:41:27 +0100 <mauke> fen_: wrong
2024-02-20 23:41:49 +0100 <mauke> demanding your words to be read, no matter what, is rude
2024-02-20 23:42:04 +0100 <fen_> im saying that its always an option to mod rather than engaging, but half the best users are mods, and they are just sick of seeing words, which is such an unhelpful attitude fort them to promote
2024-02-20 23:42:37 +0100 <fen_> my bad for using too many words sure, but the save it for your blog comments are really detrimental to how people end up engaging
2024-02-20 23:42:49 +0100 <fen_> we are fine to talk about moding, but not the topic at hand
2024-02-20 23:43:06 +0100 <fen_> in this case i think i have a reasonable excuse. its important to haskell
2024-02-20 23:43:14 +0100 <mauke> there is no "topic at hand"
2024-02-20 23:43:18 +0100 <haskellbridge> <s​m> fen_: there's an art and etiquette to getting a conversation going here.
2024-02-20 23:43:19 +0100 <fen_> more than your desire not to have that be the case...
2024-02-20 23:43:43 +0100 <fen_> mauke: look at this interjection!! now i wasnt even saying *anything*. absurdity. no place for these digressions really
2024-02-20 23:43:56 +0100 <mauke> you've been talking non-stop
2024-02-20 23:43:58 +0100 <fen_> common enough, but super counterproductive
2024-02-20 23:44:36 +0100 <haskellbridge> <s​m> would you like to move on and re-introduce your topic in a sentence or two ?
2024-02-20 23:45:10 +0100 <fen_> but if instead of interjecting, with like, ok, i see what your getting at, hows about this. if its "ok just stop writing now" this puts a total kybosh on proceedings, and disencourages pottential engagement, so i think its really not great that the mods have to do this because of my flood, which i appologise for
2024-02-20 23:45:19 +0100 <fen_> sm: thanks
2024-02-20 23:45:19 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99) (Read error: Connection reset by peer)
2024-02-20 23:45:32 +0100 <haskellbridge> <s​m> there's nothing wrong with rambling on a bit but don't attack people when they ask you to do it differently
2024-02-20 23:45:41 +0100 <haskellbridge> <s​m> we mean no harm
2024-02-20 23:45:45 +0100 <fen_> i was describing a situation where a language extension building on implicit parameters allows consideration of strictness at type level
2024-02-20 23:45:51 +0100segfaultfizzbuzz(~segfaultf@23-93-189-95.fiber.dynamic.sonic.net)
2024-02-20 23:46:20 +0100masterbuilder(~quassel@user/masterbuilder)
2024-02-20 23:46:22 +0100 <fen_> !? mimicking ? in basically every way, but also appearing like a bang patern in the binding of the implicit parameter
2024-02-20 23:46:41 +0100 <mauke> what is your goal?
2024-02-20 23:46:50 +0100synchromesh(~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99)
2024-02-20 23:46:57 +0100 <fen_> and then how to give this in a least working example using the existing but more clunky two let bindings for the strictness and implicitness seperately
2024-02-20 23:46:59 +0100 <segfaultfizzbuzz> foo : Int -> ???? i want the type of foo 101 to be Int and foo 102 to be String ,... can that be done?
2024-02-20 23:47:23 +0100 <mauke> segfaultfizzbuzz: I don't think so
2024-02-20 23:47:31 +0100tomsmeding(~tomsmedin@2a01:4f8:c0c:5e5e::2) (Quit: ZNC 1.8.2 - https://znc.in)
2024-02-20 23:47:44 +0100 <ncf> if you can tolerate the type of both 101 and 102 being Either Int String, then yes. otherwise, it's called dependent types
2024-02-20 23:47:44 +0100 <fen_> mauke: a working example demonstraiting both the double let binding, handling of the scope resulting, such as with implicit parameter constraint continuations
2024-02-20 23:48:04 +0100tomsmeding(~tomsmedin@static.21.109.88.23.clients.your-server.de)
2024-02-20 23:48:16 +0100 <int-e> segfaultfizzbuzz: The basic answer is no; ???? needs to be a known type. It's quite fundamental to the type system.
2024-02-20 23:48:22 +0100 <segfaultfizzbuzz> right so the type must be known at compile time
2024-02-20 23:48:28 +0100 <mauke> fen_: then what do you need us for?
2024-02-20 23:48:38 +0100 <fen_> seg: you can use big eithers
2024-02-20 23:48:49 +0100 <segfaultfizzbuzz> functions have static types in other words
2024-02-20 23:48:57 +0100 <fen_> mauke: to write the example
2024-02-20 23:49:09 +0100 <fen_> or talk about it if you need me to write it, or however that works
2024-02-20 23:49:29 +0100 <fen_> in the first instance just to get what im saying and why bothering to do this is worth doing
2024-02-20 23:49:34 +0100 <mauke> what is my motivation for writing code for you?
2024-02-20 23:49:37 +0100 <int-e> segfaultfizzbuzz: The usual thing people do is to use a sum type like Either Int String, as ncf mentioned. Or more elaborate things involving existential types and type classes (notably the Typeable class)
2024-02-20 23:49:52 +0100 <segfaultfizzbuzz> right but the sum type is statically known
2024-02-20 23:49:55 +0100 <fen_> like, in possible leadup to any !? olanguage proposal, which again, would require someone that isnt me to do it
2024-02-20 23:50:40 +0100 <fen_> mauke: as part of the haskell comunity, you might be interested in the implications. certainly from my perspective i need to engage other users if a language extension were to result
2024-02-20 23:51:25 +0100 <fen_> i think that in the position of having developed the theory, and being in a position to engage the comunity, that the colaberation to construct the least working demonstrative example is a good goal
2024-02-20 23:51:32 +0100 <mauke> I have no idea how to write a language extension
2024-02-20 23:52:06 +0100 <fen_> me neither! bt someone here does, and if we can get it to work using the existing syntax, this pesky requirement to use 2 let bindings, and also do the scope ahndling
2024-02-20 23:52:06 +0100 <mauke> so if your working example requires a language extension, your target audience is probably pretty small
2024-02-20 23:52:38 +0100 <fen_> nono, the motivating example for the language extension just uses implict parameters and bangpatterns seperately
2024-02-20 23:52:44 +0100 <fen_> the extension combines those
2024-02-20 23:53:12 +0100 <fen_> and it sets up this formalism of scope handling
2024-02-20 23:53:20 +0100 <fen_> which i think is what i want input on
2024-02-20 23:53:29 +0100 <fen_> i kind of cant call the shots on how we do that
2024-02-20 23:53:35 +0100yoo(~yo0O0o@104.28.194.105)
2024-02-20 23:53:45 +0100 <fen_> maybe people dont like constraint continuations and can think of a better way for example
2024-02-20 23:54:04 +0100 <haskellbridge> <s​m> fen_: I for one don't see your idea clearly. A mini proposal, with examples/mockups etc., will make this clear to more of us and attract more feedback.
2024-02-20 23:54:13 +0100danse-nr3(~danse@151.57.200.9) (Ping timeout: 246 seconds)
2024-02-20 23:54:24 +0100acidjnk(~acidjnk@p200300d6e737e723f1d9672538a89ef2.dip0.t-ipconnect.de) (Ping timeout: 268 seconds)
2024-02-20 23:54:33 +0100 <fen_> we have to bind using let, and return a type that serves as a context in which a constraint is satisfied
2024-02-20 23:54:51 +0100 <fen_> previously i have done this using constraint continuations, but this is complicated and might not be the best way to introduce it
2024-02-20 23:55:18 +0100 <fen_> sm: whats unclear?
2024-02-20 23:55:29 +0100 <haskellbridge> <s​m> your proposal
2024-02-20 23:55:35 +0100 <fen_> this is how we get some idea about strictness at type level using existing machinery
2024-02-20 23:55:41 +0100 <fen_> the proposal strengthens that
2024-02-20 23:56:19 +0100 <fen_> implicit parameters are not instantiated at top level and so "might be strict" as indicated by a ? in a constraint
2024-02-20 23:57:04 +0100 <fen_> the proposal would alow use of !? instead, also indicating not just "maybe strictness" (unlike, certainly not strict of other constraints, instantiated at top level) but actual strictness
2024-02-20 23:57:38 +0100 <haskellbridge> <s​m> I have things to do, so I don't want to work hard to understand your idea from a stream of comments. It needs a proper description.
2024-02-20 23:57:40 +0100 <fen_> the idea of the working example hahaviving to cocontetwith hohow this sc is handled is what im coconceceed about
2024-02-20 23:57:47 +0100 <fen_> sorry my keyboard is wireless
2024-02-20 23:57:55 +0100 <haskellbridge> <s​m> maybe someone else is getting it though. Good luck.
2024-02-20 23:58:07 +0100 <int-e> segfaultfizzbuzz: Maybe it's worth pointing out that GHC erases type information... the program that runs only has values, without knowing their types. Values are usually pointers... and code that takes such a pointer will just assume that the value has the right type. (In fact this is crucial for being able to pass values on without evaluating them, as required for lazy evaluation.)
2024-02-20 23:58:23 +0100 <segfaultfizzbuzz> interesting
2024-02-20 23:58:27 +0100 <fen_> certainly i have described that adequately
2024-02-20 23:59:24 +0100 <segfaultfizzbuzz> is there a "systems" meaning of type then? like, if i have a pointer and i know its type, then i can index into it or something?
2024-02-20 23:59:54 +0100 <fen_> sm: do you understand how using ? at type level indicated information about pottential strictness, as opposed to regular constraints, by virtue of the local instantiation allowing for a strict variable to be reflected, which is impossible as you cant use bang patterns in class instances, to do in the normal top level scope. and how this indicates
2024-02-20 23:59:55 +0100 <fen_> we have scope handling considerations that result