| 2024-02-20 00:01:30 +0100 | acidjnk | (~acidjnk@p200300d6e737e7078172c370cd7bd683.dip0.t-ipconnect.de) (Ping timeout: 255 seconds) |
| 2024-02-20 00:03:07 +0100 | pavonia_ | (~user@user/siracusa) |
| 2024-02-20 00:03:35 +0100 | euleritian | (~euleritia@77.22.252.56) (Ping timeout: 264 seconds) |
| 2024-02-20 00:04:55 +0100 | pavonia | (~user@user/siracusa) (Read error: Connection reset by peer) |
| 2024-02-20 00:05:06 +0100 | pavonia_ | pavonia |
| 2024-02-20 00:11:44 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Quit: sord937) |
| 2024-02-20 00:11:59 +0100 | euphores | (~SASL_euph@user/euphores) (Read error: Connection reset by peer) |
| 2024-02-20 00:12:55 +0100 | CiaoSen | (~Jura@2a05:5800:2d5:3400:e6b9:7aff:fe80:3d03) (Ping timeout: 256 seconds) |
| 2024-02-20 00:13:07 +0100 | euphores | (~SASL_euph@user/euphores) |
| 2024-02-20 00:14:15 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-02-20 00:16:17 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-20 00:19:09 +0100 | sudden | (~cat@user/sudden) (Ping timeout: 268 seconds) |
| 2024-02-20 00:21:22 +0100 | adanwan | (~adanwan@gateway/tor-sasl/adanwan) (Remote host closed the connection) |
| 2024-02-20 00:21:40 +0100 | adanwan | (~adanwan@gateway/tor-sasl/adanwan) |
| 2024-02-20 00:30:03 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) |
| 2024-02-20 00:33:19 +0100 | phma | (~phma@host-67-44-208-180.hnremote.net) (Read error: Connection reset by peer) |
| 2024-02-20 00:33:51 +0100 | sudden | (~cat@user/sudden) |
| 2024-02-20 00:33:57 +0100 | phma | (phma@2001:5b0:211f:17e8:9781:bf89:87ee:5c) |
| 2024-02-20 00:39:07 +0100 | destituion | (~destituio@2a02:2121:626:f551:4ac:cbaa:8513:cc79) (Ping timeout: 256 seconds) |
| 2024-02-20 00:39:12 +0100 | Tuplanolla | (~Tuplanoll@91-159-68-95.elisa-laajakaista.fi) (Quit: Leaving.) |
| 2024-02-20 00:50:55 +0100 | destituion | (~destituio@2a02:2121:6b0:945a:2d6a:154b:f3d4:a642) |
| 2024-02-20 00:53:12 +0100 | euleritian | (~euleritia@77.22.252.56) (Ping timeout: 256 seconds) |
| 2024-02-20 00:53:31 +0100 | euleritian | (~euleritia@dynamic-176-006-180-132.176.6.pool.telefonica.de) |
| 2024-02-20 01:01:05 +0100 | rvalue | (~rvalue@user/rvalue) (Ping timeout: 256 seconds) |
| 2024-02-20 01:04:47 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) |
| 2024-02-20 01:11:42 +0100 | rvalue | (~rvalue@user/rvalue) |
| 2024-02-20 01:24:51 +0100 | sroso | (~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 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-20 01:29:58 +0100 | sroso | (~sroso@user/SrOso) (Max SendQ exceeded) |
| 2024-02-20 01:34:55 +0100 | werneta | (~werneta@024-205-076-158.res.spectrum.com) |
| 2024-02-20 01:36:34 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-20 01:37:09 +0100 | sroso | (~sroso@user/SrOso) (Max SendQ exceeded) |
| 2024-02-20 01:38:01 +0100 | pretty_dumm_guy | (trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) |
| 2024-02-20 01:42:49 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-20 01:46:15 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-20 01:56:17 +0100 | puke | (~puke@user/puke) |
| 2024-02-20 01:59:52 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-20 02:01:48 +0100 | jmdaemon | (~jmdaemon@user/jmdaemon) |
| 2024-02-20 02:03:49 +0100 | werneta | (~werneta@024-205-076-158.res.spectrum.com) (Quit: Lost terminal) |
| 2024-02-20 02:05:55 +0100 | whatsupdoc | (uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-02-20 02:07:37 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-20 02:17:49 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-20 02:24:25 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) |
| 2024-02-20 02:32:30 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-20 02:37:17 +0100 | tri | (~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 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 268 seconds) |
| 2024-02-20 02:48:13 +0100 | caesrmt^ | (~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 +0100 | azimut | (~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 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) (Ping timeout: 268 seconds) |
| 2024-02-20 02:50:45 +0100 | Lord_of_Life | (~Lord@user/lord-of-life/x-2819915) |
| 2024-02-20 02:51:37 +0100 | bilegeek | (~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817) |
| 2024-02-20 02:52:05 +0100 | xff0x | (~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 +0100 | peterbecich | (~Thunderbi@047-229-123-186.res.spectrum.com) (Ping timeout: 260 seconds) |
| 2024-02-20 03:03:03 +0100 | pretty_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 +0100 | otto_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 +0100 | otto_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 +0100 | jargon | (~jargon@157.sub-174-205-162.myvzw.com) (Remote host closed the connection) |
| 2024-02-20 03:31:10 +0100 | benkard | (~mulk@p5b2dcb88.dip0.t-ipconnect.de) |
| 2024-02-20 03:32:03 +0100 | mulk | (~mulk@pd95148d1.dip0.t-ipconnect.de) (Ping timeout: 272 seconds) |
| 2024-02-20 03:32:03 +0100 | benkard | mulk |
| 2024-02-20 03:32:22 +0100 | euphores | (~SASL_euph@user/euphores) (Ping timeout: 260 seconds) |
| 2024-02-20 03:41:15 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
| 2024-02-20 03:51:21 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-20 03:53:08 +0100 | Xe | (~cadey@perl/impostor/xe) (Ping timeout: 268 seconds) |
| 2024-02-20 03:53:08 +0100 | notzmv | (~daniel@user/notzmv) |
| 2024-02-20 03:56:54 +0100 | sysadm1nH | (~sysadm1nH@115.55.85.79.rev.sfr.net) |
| 2024-02-20 03:56:56 +0100 | sysadm1nH | (~sysadm1nH@115.55.85.79.rev.sfr.net) (Client Quit) |
| 2024-02-20 03:59:59 +0100 | Xe | (~cadey@perl/impostor/xe) |
| 2024-02-20 04:00:33 +0100 | phma | (phma@2001:5b0:211f:17e8:9781:bf89:87ee:5c) (Read error: Connection reset by peer) |
| 2024-02-20 04:01:14 +0100 | phma | (~phma@host-67-44-208-78.hnremote.net) |
| 2024-02-20 04:01:46 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 268 seconds) |
| 2024-02-20 04:02:15 +0100 | sroso | (~sroso@user/SrOso) (Remote host closed the connection) |
| 2024-02-20 04:02:36 +0100 | sroso | (~sroso@user/SrOso) |
| 2024-02-20 04:03:12 +0100 | sroso | (~sroso@user/SrOso) (Max SendQ exceeded) |
| 2024-02-20 04:03:20 +0100 | Xe | (~cadey@perl/impostor/xe) (Excess Flood) |
| 2024-02-20 04:03:29 +0100 | jbalint | (~jbalint@071-090-119-177.res.spectrum.com) (Remote host closed the connection) |
| 2024-02-20 04:03:37 +0100 | caesrmt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Ping timeout: 255 seconds) |
| 2024-02-20 04:03:40 +0100 | jbalint | (~jbalint@2600-6c44-117f-e98a-816a-9488-0fb1-07b7.inf6.spectrum.com) |
| 2024-02-20 04:06:19 +0100 | Xe | (~cadey@perl/impostor/xe) |
| 2024-02-20 04:11:45 +0100 | sysadm1nH | (~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 +0100 | sysadm1nH | (~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 +0100 | td_ | (~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 +0100 | td_ | (~td@i5387090B.versanet.de) |
| 2024-02-20 04:27:05 +0100 | average | (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 +0100 | tri | (~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 +0100 | caesrmt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) |
| 2024-02-20 04:58:37 +0100 | Lycurgus | (~georg@user/Lycurgus) |
| 2024-02-20 05:00:22 +0100 | tri | (~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 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) |
| 2024-02-20 05:22:31 +0100 | rosco | (~rosco@175.136.156.77) |
| 2024-02-20 05:28:17 +0100 | euleritian | (~euleritia@dynamic-176-006-180-132.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-20 05:28:34 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-20 05:29:19 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Remote host closed the connection) |
| 2024-02-20 05:29:23 +0100 | Katarushisu1 | (~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) (Quit: Ping timeout (120 seconds)) |
| 2024-02-20 05:29:36 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
| 2024-02-20 05:30:49 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-20 05:31:37 +0100 | Ranhir | (~Ranhir@157.97.53.139) (Ping timeout: 264 seconds) |
| 2024-02-20 05:32:49 +0100 | m1dnight | (~christoph@78-22-2-15.access.telenet.be) (Ping timeout: 264 seconds) |
| 2024-02-20 05:32:49 +0100 | APic | (apic@apic.name) (Ping timeout: 264 seconds) |
| 2024-02-20 05:35:33 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 260 seconds) |
| 2024-02-20 05:37:39 +0100 | aforemny | (~aforemny@2001:9e8:6cc8:100:42ef:f733:c482:5119) (Ping timeout: 255 seconds) |
| 2024-02-20 05:37:53 +0100 | aforemny_ | (~aforemny@2001:9e8:6cec:d900:9d72:673f:b1f3:dc04) |
| 2024-02-20 05:49:27 +0100 | Katarushisu1 | (~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) |
| 2024-02-20 05:49:49 +0100 | heartburn | (~gass@81.4.123.134) |
| 2024-02-20 05:49:51 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-02-20 05:52:35 +0100 | Ranhir | (~Ranhir@157.97.53.139) |
| 2024-02-20 05:52:57 +0100 | Katarushisu1 | (~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) (Client Quit) |
| 2024-02-20 05:59:36 +0100 | m1dnight | (~christoph@78-22-2-15.access.telenet.be) |
| 2024-02-20 06:00:51 +0100 | hueso | (~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 +0100 | caesrmt^ | (~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection) |
| 2024-02-20 06:08:49 +0100 | Katarushisu1 | (~Katarushi@finc-20-b2-v4wan-169598-cust1799.vm7.cable.virginm.net) |
| 2024-02-20 06:09:05 +0100 | Square3 | (~Square4@user/square) |
| 2024-02-20 06:09:16 +0100 | michalz | (~michalz@185.246.207.221) |
| 2024-02-20 06:11:37 +0100 | Square | (~Square@user/square) (Ping timeout: 256 seconds) |
| 2024-02-20 06:14:18 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-20 06:14:38 +0100 | [_] | (~itchyjunk@user/itchyjunk/x-7353470) |
| 2024-02-20 06:14:55 +0100 | APic | (apic@apic.name) |
| 2024-02-20 06:17:16 +0100 | thegeekinside | (~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 +0100 | actioninja8 | (~actioninj@user/actioninja) |
| 2024-02-20 06:19:50 +0100 | actioninja | (~actioninj@user/actioninja) (Ping timeout: 252 seconds) |
| 2024-02-20 06:19:51 +0100 | actioninja8 | actioninja |
| 2024-02-20 06:26:17 +0100 | michalz | (~michalz@185.246.207.221) (Quit: ZNC 1.8.2 - https://znc.in) |
| 2024-02-20 06:26:38 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving) |
| 2024-02-20 06:29:04 +0100 | michalz | (~michalz@185.246.207.197) |
| 2024-02-20 06:44:25 +0100 | bilegeek | (~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817) (Quit: Leaving) |
| 2024-02-20 06:47:27 +0100 | dodoyada | (~dodoyada@pool-71-178-11-160.washdc.fios.verizon.net) (Quit: Client closed) |
| 2024-02-20 06:54:59 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-02-20 07:03:35 +0100 | mulk | (~mulk@p5b2dcb88.dip0.t-ipconnect.de) (Ping timeout: 272 seconds) |
| 2024-02-20 07:03:59 +0100 | Vq | (~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 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Remote host closed the connection) |
| 2024-02-20 07:22:07 +0100 | mulk | (~mulk@pd95142c7.dip0.t-ipconnect.de) |
| 2024-02-20 07:23:15 +0100 | takuan | (~takuan@178-116-218-225.access.telenet.be) |
| 2024-02-20 07:25:23 +0100 | acidjnk | (~acidjnk@p200300d6e737e723f1d9672538a89ef2.dip0.t-ipconnect.de) |
| 2024-02-20 07:27:07 +0100 | mulk | (~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 +0100 | coot | (~coot@89-69-206-216.dynamic.chello.pl) |
| 2024-02-20 07:54:36 +0100 | bilegeek | (~bilegeek@2600:1008:b023:d9e2:9f22:5071:205d:e817) |
| 2024-02-20 08:00:57 +0100 | azimut | (~azimut@gateway/tor-sasl/azimut) |
| 2024-02-20 08:18:18 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) |
| 2024-02-20 08:22:31 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 256 seconds) |
| 2024-02-20 08:27:48 +0100 | mulk | (~mulk@pd951406a.dip0.t-ipconnect.de) |
| 2024-02-20 08:30:19 +0100 | tromp | (~textual@92.110.219.57) |
| 2024-02-20 08:34:57 +0100 | mulk | (~mulk@pd951406a.dip0.t-ipconnect.de) (Ping timeout: 268 seconds) |
| 2024-02-20 08:35:24 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) |
| 2024-02-20 08:36:00 +0100 | bitmapper | (uid464869@id-464869.lymington.irccloud.com) |
| 2024-02-20 08:37:36 +0100 | mulk | (~mulk@pd9514a85.dip0.t-ipconnect.de) |
| 2024-02-20 08:55:38 +0100 | tromp | (~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-20 09:00:09 +0100 | fendor | (~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) |
| 2024-02-20 09:08:30 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2024-02-20 09:09:41 +0100 | tromp | (~textual@92.110.219.57) |
| 2024-02-20 09:14:03 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 272 seconds) |
| 2024-02-20 09:15:08 +0100 | euleritian | (~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) |
| 2024-02-20 09:23:11 +0100 | kuribas | (~user@2a02:1808:80:3ece:5b45:c128:11b7:97c5) |
| 2024-02-20 09:35:35 +0100 | AlexZenon | (~alzenon@178.34.161.13) (Ping timeout: 272 seconds) |
| 2024-02-20 09:36:13 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 272 seconds) |
| 2024-02-20 09:38:25 +0100 | euleritian | (~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-20 09:38:42 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-20 09:46:16 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Quit: WeeChat 4.1.2) |
| 2024-02-20 09:46:53 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 09:47:00 +0100 | enoq | (~enoq@2a05:1141:1e6:3b00:c958:a45e:c4e0:3650) |
| 2024-02-20 09:47:10 +0100 | AlexZenon | (~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 +0100 | CiaoSen | (~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 +0100 | machinedgod | (~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 +0100 | kuribas | (~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 +0100 | gmg | (~user@user/gehmehgeh) |
| 2024-02-20 09:57:00 +0100 | tzh | (~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 +0100 | cfricke | (~cfricke@user/cfricke) |
| 2024-02-20 10:04:42 +0100 | kuribas | (~user@2a02:1808:80:3ece:18b4:369:3465:6cb1) |
| 2024-02-20 10:10:13 +0100 | kuribas | (~user@2a02:1808:80:3ece:18b4:369:3465:6cb1) (Ping timeout: 268 seconds) |
| 2024-02-20 10:10:43 +0100 | kuribas | (~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 +0100 | NSFAF__ | (~NSFAF@105.232.14.71) |
| 2024-02-20 10:13:57 +0100 | tromp | (~textual@92.110.219.57) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-20 10:16:33 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Quit: WeeChat 4.1.2) |
| 2024-02-20 10:19:06 +0100 | danse-nr3 | (~danse@151.43.214.115) |
| 2024-02-20 10:19:53 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 10:23:50 +0100 | danse-nr3 | (~danse@151.43.214.115) (Ping timeout: 256 seconds) |
| 2024-02-20 10:28:24 +0100 | raym | (~ray@user/raym) (Quit: Upgrading to FreeBSD 14.0-RELEASE-p5) |
| 2024-02-20 10:31:52 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) (Remote host closed the connection) |
| 2024-02-20 10:32:11 +0100 | NSFAF__ | (~NSFAF@105.232.14.71) (Ping timeout: 260 seconds) |
| 2024-02-20 10:35:00 +0100 | pastly | (~pastly@gateway/tor-sasl/pastly) |
| 2024-02-20 10:38:53 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 260 seconds) |
| 2024-02-20 10:40:31 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) |
| 2024-02-20 10:43:26 +0100 | ft | (~ft@p508db2e6.dip0.t-ipconnect.de) (Quit: leaving) |
| 2024-02-20 10:47:09 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) |
| 2024-02-20 10:53:27 +0100 | danse-nr3 | (~danse@151.57.223.96) |
| 2024-02-20 10:56:07 +0100 | NSFAF | (~NSFAF@105.232.14.71) |
| 2024-02-20 11:02:23 +0100 | lortabac | (~lortabac@37.97.111.147) |
| 2024-02-20 11:04:29 +0100 | xff0x | (~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 240 seconds) |
| 2024-02-20 11:05:29 +0100 | sympt | (~sympt@user/sympt) (Quit: Ping timeout (120 seconds)) |
| 2024-02-20 11:06:23 +0100 | sympt | (~sympt@user/sympt) |
| 2024-02-20 11:07:47 +0100 | mmhat | (~mmh@p200300f1c70b449eee086bfffe095315.dip0.t-ipconnect.de) |
| 2024-02-20 11:07:58 +0100 | chele | (~chele@user/chele) |
| 2024-02-20 11:12:00 +0100 | NSFAF | (~NSFAF@105.232.14.71) (Ping timeout: 255 seconds) |
| 2024-02-20 11:12:49 +0100 | econo_ | (uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-02-20 11:17:38 +0100 | chele | (~chele@user/chele) (Remote host closed the connection) |
| 2024-02-20 11:23:14 +0100 | raym | (~ray@user/raym) |
| 2024-02-20 11:24:08 +0100 | chele | (~chele@user/chele) |
| 2024-02-20 11:28:02 +0100 | Lycurgus | (~georg@user/Lycurgus) |
| 2024-02-20 11:28:29 +0100 | ubert | (~Thunderbi@2a02:8109:ab8a:5a00:ce61:4d12:7531:ec69) |
| 2024-02-20 11:36:13 +0100 | polux6 | (~polux@51-15-169-172.rev.poneytelecom.eu) |
| 2024-02-20 11:36:18 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds) |
| 2024-02-20 11:37:15 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-20 11:37:17 +0100 | polux | (~polux@51-15-169-172.rev.poneytelecom.eu) (Ping timeout: 240 seconds) |
| 2024-02-20 11:37:17 +0100 | polux6 | polux |
| 2024-02-20 11:37:48 +0100 | NSFAF | (~NSFAF@105.232.14.71) |
| 2024-02-20 11:38:16 +0100 | rosco | (~rosco@175.136.156.77) (Quit: Lost terminal) |
| 2024-02-20 11:38:35 +0100 | NSFAF_ | (~NSFAF@105.232.14.71) |
| 2024-02-20 11:39:38 +0100 | NSFAF__ | (~NSFAF@105.232.14.71) |
| 2024-02-20 11:40:12 +0100 | euleritian | (~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) |
| 2024-02-20 11:42:22 +0100 | NSFAF | (~NSFAF@105.232.14.71) (Ping timeout: 246 seconds) |
| 2024-02-20 11:42:31 +0100 | NSFAF | (~NSFAF@105.232.14.71) |
| 2024-02-20 11:43:25 +0100 | NSFAF | (~NSFAF@105.232.14.71) (Max SendQ exceeded) |
| 2024-02-20 11:43:25 +0100 | NSFAF_ | (~NSFAF@105.232.14.71) (Ping timeout: 246 seconds) |
| 2024-02-20 11:44:59 +0100 | NSFAF__ | (~NSFAF@105.232.14.71) (Ping timeout: 260 seconds) |
| 2024-02-20 11:45:22 +0100 | NSFAF | (~NSFAF@130.185.144.25) |
| 2024-02-20 11:45:49 +0100 | bilegeek | (~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 +0100 | NSFAF | (~NSFAF@130.185.144.25) (Ping timeout: 246 seconds) |
| 2024-02-20 11:59:59 +0100 | euleritian | (~euleritia@dynamic-176-006-187-025.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-20 12:00:16 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-02-20 12:02:24 +0100 | lortabac | (~lortabac@37.97.111.147) (Ping timeout: 255 seconds) |
| 2024-02-20 12:07:42 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) |
| 2024-02-20 12:08:42 +0100 | igemnace | (~ian@user/igemnace) (Read error: Connection reset by peer) |
| 2024-02-20 12:26:26 +0100 | igemnace | (~ian@user/igemnace) |
| 2024-02-20 12:36:45 +0100 | kaskal | (~kaskal@213-147-167-18.nat.highway.webapn.at) (Quit: ZNC - https://znc.in) |
| 2024-02-20 12:37:19 +0100 | kaskal | (~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 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-20 12:45:10 +0100 | califax | (~califax@user/califx) |
| 2024-02-20 12:50:28 +0100 | fen78 | (~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 +0100 | m1dnight | (~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 +0100 | tromp | (~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 +0100 | lortabac | (~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 +0100 | CiaoSen | (~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 +0100 | califax | (~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 +0100 | califax | (~califax@user/califx) |
| 2024-02-20 13:12:42 +0100 | lortabac | (~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 +0100 | m1dnight | (~christoph@78-22-14-161.access.telenet.be) |
| 2024-02-20 13:15:33 +0100 | lortabac | (~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 +0100 | califax | (~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 +0100 | califax | (~califax@user/califx) |
| 2024-02-20 13:21:41 +0100 | synchromesh | (~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 +0100 | chele | (~chele@user/chele) (Ping timeout: 256 seconds) |
| 2024-02-20 13:23:11 +0100 | synchromesh | (~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 +0100 | danse-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 +0100 | tromp | (~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 +0100 | gentauro | (~gentauro@user/gentauro) (Read error: Connection reset by peer) |
| 2024-02-20 13:40:49 +0100 | jmdaemon | (~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> | <mauke> `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 +0100 | m1dnight | (~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 +0100 | gentauro | (~gentauro@user/gentauro) |
| 2024-02-20 13:47:30 +0100 | m1dnight | (~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> | <mauke> `hmm :: a -> b -> b; hmm x = seq x undefined` |
| 2024-02-20 13:49:37 +0100 | <haskellbridge> | <mauke> 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> | <mauke> 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 +0100 | m1dnight | (~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 +0100 | danse-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 +0100 | danse-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 +0100 | danse-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> | <mauke> 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 +0100 | NSFAF | (~NSFAF@105.232.14.71) |
| 2024-02-20 14:04:15 +0100 | <fen78> | is lifted... sorry garbled |
| 2024-02-20 14:04:25 +0100 | NSFAF_ | (~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 +0100 | raym | (~ray@user/raym) (Quit: leaving) |
| 2024-02-20 14:06:29 +0100 | NSFAF_ | (~NSFAF@105.232.14.71) (Read error: Connection reset by peer) |
| 2024-02-20 14:06:46 +0100 | NSFAF_ | (~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 +0100 | NSFAF | (~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 +0100 | lortabac | (~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 +0100 | califax | (~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 +0100 | shapr | (~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 +0100 | califax | (~califax@user/califx) |
| 2024-02-20 14:18:13 +0100 | mulk | (~mulk@pd9514a85.dip0.t-ipconnect.de) (Ping timeout: 260 seconds) |
| 2024-02-20 14:18:15 +0100 | CiaoSen | (~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 +0100 | mulk | (~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 +0100 | oneeyedalien | (~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 +0100 | califax | (~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 +0100 | tromp | (~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> | <Jade> Why can I not write `data Foo a where X :: Foo a` using `-XGADTSyntax`? |
| 2024-02-20 14:27:55 +0100 | <haskellbridge> | <Jade> It tells me to enable `-XGADT` |
| 2024-02-20 14:28:11 +0100 | califax | (~califax@user/califx) |
| 2024-02-20 14:28:18 +0100 | euleritian | (~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 +0100 | tri | (~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 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Read error: Connection reset by peer) |
| 2024-02-20 14:29:59 +0100 | tri | (~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> | <Jade> 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 +0100 | lortabac | (~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 +0100 | tri | (~tri@ool-18bc2e74.dyn.optonline.net) (Ping timeout: 268 seconds) |
| 2024-02-20 14:34:36 +0100 | <haskellbridge> | <Jade> 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> | <Jade> I think there's an open ticket for flags interferring with each other |
| 2024-02-20 14:35:10 +0100 | califax | (~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 +0100 | califax | (~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 +0100 | targetdisk | (~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 +0100 | m1dnight | (~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 +0100 | shapr | (~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 +0100 | thegeekinside | (~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 +0100 | CiaoSen | (~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 +0100 | thegeekinside | (~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 +0100 | troydm | (~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 +0100 | mmhat | (~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 +0100 | fen78 | (~fen@84.68.80.95) (Quit: Connection closed) |
| 2024-02-20 15:21:47 +0100 | thegeekinside | (~thegeekin@189.217.83.221) |
| 2024-02-20 15:22:08 +0100 | oneeyedalien_ | (~oneeyedal@user/oneeyedalien) |
| 2024-02-20 15:22:32 +0100 | NSFAF_ | (~NSFAF@105.232.14.71) (Read error: Connection reset by peer) |
| 2024-02-20 15:25:01 +0100 | oneeyedalien | (~oneeyedal@user/oneeyedalien) (Ping timeout: 264 seconds) |
| 2024-02-20 15:25:55 +0100 | szkl | (uid110435@uxbridge.irccloud.com) (Quit: Connection closed for inactivity) |
| 2024-02-20 15:29:51 +0100 | mmhat | (~mmh@p200300f1c70b44daee086bfffe095315.dip0.t-ipconnect.de) |
| 2024-02-20 15:35:27 +0100 | lortabac | (~lortabac@37.97.111.147) (Ping timeout: 256 seconds) |
| 2024-02-20 15:36:42 +0100 | chele | (~chele@user/chele) |
| 2024-02-20 15:50:25 +0100 | myxos | (~myxos@065-028-251-121.inf.spectrum.com) (Remote host closed the connection) |
| 2024-02-20 15:50:37 +0100 | actioninja | (~actioninj@user/actioninja) (Quit: Ping timeout (120 seconds)) |
| 2024-02-20 15:50:41 +0100 | Square | (~Square@user/square) |
| 2024-02-20 15:51:00 +0100 | actioninja | (~actioninj@user/actioninja) |
| 2024-02-20 15:52:50 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) (Ping timeout: 255 seconds) |
| 2024-02-20 15:53:23 +0100 | Square3 | (~Square4@user/square) (Ping timeout: 264 seconds) |
| 2024-02-20 15:53:23 +0100 | myxos | (~myxos@065-028-251-121.inf.spectrum.com) |
| 2024-02-20 15:53:40 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 15:54:02 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 252 seconds) |
| 2024-02-20 15:54:41 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
| 2024-02-20 15:54:59 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
| 2024-02-20 15:58:20 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 268 seconds) |
| 2024-02-20 15:59:51 +0100 | bitdex | (~bitdex@gateway/tor-sasl/bitdex) (Quit: = "") |
| 2024-02-20 16:00:35 +0100 | danse-nr3 | (~danse@151.43.209.161) (Remote host closed the connection) |
| 2024-02-20 16:01:30 +0100 | danse-nr3 | (~danse@151.43.209.161) |
| 2024-02-20 16:03:21 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) |
| 2024-02-20 16:04:16 +0100 | lortabac | (~lortabac@37.97.111.147) |
| 2024-02-20 16:06:25 +0100 | lortabac | (~lortabac@37.97.111.147) (Client Quit) |
| 2024-02-20 16:07:07 +0100 | lottaquestions_ | (~nick@2607:fa49:503d:b200:a224:6171:dcbc:3474) (Quit: Konversation terminated!) |
| 2024-02-20 16:16:40 +0100 | CiaoSen | (~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03) |
| 2024-02-20 16:30:53 +0100 | mulk | (~mulk@pd9514af5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds) |
| 2024-02-20 16:31:54 +0100 | mulk | (~mulk@pd95147b3.dip0.t-ipconnect.de) |
| 2024-02-20 16:34:05 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) (Ping timeout: 240 seconds) |
| 2024-02-20 16:34:12 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 16:35:45 +0100 | Vq | (~vq@2001:2043:1c58:ea00:ca7f:54ff:fe6a:fd48) |
| 2024-02-20 16:36:20 +0100 | xff0x | (~xff0x@178.255.149.135) |
| 2024-02-20 16:38:31 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 260 seconds) |
| 2024-02-20 16:41:11 +0100 | xff0x | (~xff0x@178.255.149.135) (Ping timeout: 256 seconds) |
| 2024-02-20 16:41:52 +0100 | CiaoSen | (~Jura@2a05:5800:2c7:500:e6b9:7aff:fe80:3d03) (Ping timeout: 255 seconds) |
| 2024-02-20 16:42:07 +0100 | danse-nr3 | (~danse@151.43.209.161) (Ping timeout: 268 seconds) |
| 2024-02-20 16:42:39 +0100 | xff0x | (~xff0x@ai082039.d.east.v6connect.net) |
| 2024-02-20 16:45:57 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) |
| 2024-02-20 16:47:39 +0100 | danse-nr3 | (~danse@151.43.209.161) |
| 2024-02-20 16:49:35 +0100 | todi | (~todi@p4fd1a2f5.dip0.t-ipconnect.de) |
| 2024-02-20 16:52:01 +0100 | euphores | (~SASL_euph@user/euphores) |
| 2024-02-20 16:52:36 +0100 | danse-nr3 | (~danse@151.43.209.161) (Ping timeout: 268 seconds) |
| 2024-02-20 16:54:06 +0100 | oneeyedalien_ | (~oneeyedal@user/oneeyedalien) (Quit: Leaving) |
| 2024-02-20 16:54:27 +0100 | Square | (~Square@user/square) (Ping timeout: 255 seconds) |
| 2024-02-20 16:55:32 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 16:55:49 +0100 | danse-nr3 | (~danse@151.43.209.161) |
| 2024-02-20 16:59:58 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 264 seconds) |
| 2024-02-20 17:00:07 +0100 | ubert | (~Thunderbi@2a02:8109:ab8a:5a00:ce61:4d12:7531:ec69) (Remote host closed the connection) |
| 2024-02-20 17:02:13 +0100 | danse-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 +0100 | danse-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 +0100 | cfricke | (~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 +0100 | euleritian | (~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) |
| 2024-02-20 17:34:34 +0100 | euleritian | (~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-20 17:34:57 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-02-20 17:37:01 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) (Ping timeout: 260 seconds) |
| 2024-02-20 17:37:18 +0100 | <haskellbridge> | <sm> "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> | <sm> "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 +0100 | ski | (~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 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) () |
| 2024-02-20 17:45:17 +0100 | pavonia | (~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 +0100 | igemnace | (~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 +0100 | danse-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 +0100 | danse-nr3 | (~danse@151.43.160.252) |
| 2024-02-20 17:56:44 +0100 | euleritian | (~euleritia@77.22.252.56) (Ping timeout: 268 seconds) |
| 2024-02-20 17:57:18 +0100 | euleritian | (~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) |
| 2024-02-20 17:57:58 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) (Ping timeout: 268 seconds) |
| 2024-02-20 17:58:40 +0100 | Maxdamantus | (~Maxdamant@user/maxdamantus) |
| 2024-02-20 18:01:11 +0100 | jjhoo | (~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 +0100 | enoq | (~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 +0100 | ulthuan23456 | (~ulthuan23@2a09:bac3:3116:191::28:90) |
| 2024-02-20 18:10:01 +0100 | ulthuan23456 | (~ulthuan23@2a09:bac3:3116:191::28:90) (Client Quit) |
| 2024-02-20 18:10:23 +0100 | kaskal | (~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 +0100 | danse-nr3 | (~danse@151.43.160.252) (Ping timeout: 264 seconds) |
| 2024-02-20 18:11:28 +0100 | kaskal | (~kaskal@2001:4bb8:2c3:39c1:ff3f:d58:4fd9:e10c) |
| 2024-02-20 18:12:49 +0100 | jjhoo | (jahakala@user/jjhoo) |
| 2024-02-20 18:16:49 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) (Ping timeout: 272 seconds) |
| 2024-02-20 18:18:19 +0100 | jjhoo | (jahakala@user/jjhoo) (Ping timeout: 268 seconds) |
| 2024-02-20 18:18:33 +0100 | euleritian | (~euleritia@dynamic-176-006-199-015.176.6.pool.telefonica.de) (Read error: Connection reset by peer) |
| 2024-02-20 18:18:51 +0100 | euleritian | (~euleritia@77.22.252.56) |
| 2024-02-20 18:20:37 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 18:22:05 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-20 18:24:06 +0100 | kuribas | (~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection) |
| 2024-02-20 18:24:54 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds) |
| 2024-02-20 18:27:34 +0100 | waleee | (~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 268 seconds) |
| 2024-02-20 18:28:14 +0100 | penteract | (~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 +0100 | Lycurgus | (~georg@user/Lycurgus) (Quit: leaving) |
| 2024-02-20 18:32:34 +0100 | rvalue | (~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 +0100 | econo_ | (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 +0100 | rvalue | (~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 +0100 | tzh | (~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 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) |
| 2024-02-20 18:54:03 +0100 | tri | (~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 +0100 | tri | (~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 +0100 | penteract | (~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 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-20 19:23:35 +0100 | son0p | (~ff@167.0.172.211) (Ping timeout: 252 seconds) |
| 2024-02-20 19:23:47 +0100 | wootehfoot | (~wootehfoo@user/wootehfoot) (Read error: Connection reset by peer) |
| 2024-02-20 19:30:14 +0100 | ChaiTRex | (~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 +0100 | ChaiTRex | (~ChaiTRex@user/chaitrex) |
| 2024-02-20 19:35:44 +0100 | synchromesh | (~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 +0100 | synchromesh | (~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99) |
| 2024-02-20 19:37:01 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) |
| 2024-02-20 19:37:40 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) (Remote host closed the connection) |
| 2024-02-20 19:40:02 +0100 | cfricke | (~cfricke@user/cfricke) |
| 2024-02-20 19:43:49 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) |
| 2024-02-20 19:52:45 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-20 19:54:26 +0100 | Taneb | (~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (Quit: I seem to have stopped.) |
| 2024-02-20 19:57:09 +0100 | Taneb | (~Taneb@runciman.hacksoc.org) |
| 2024-02-20 20:06:12 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection) |
| 2024-02-20 20:07:55 +0100 | target_i | (~target_i@217.175.14.39) |
| 2024-02-20 20:11:08 +0100 | oo_miguel | (~Thunderbi@78-11-181-16.static.ip.netia.com.pl) (Quit: oo_miguel) |
| 2024-02-20 20:11:56 +0100 | Unicorn_Princess | (~Unicorn_P@user/Unicorn-Princess/x-3540542) |
| 2024-02-20 20:15:28 +0100 | derpyxdhs | (~Thunderbi@user/derpyxdhs) |
| 2024-02-20 20:17:32 +0100 | derpyxdhs | (~Thunderbi@user/derpyxdhs) (Client Quit) |
| 2024-02-20 20:19:48 +0100 | L29Ah | (~L29Ah@wikipedia/L29Ah) |
| 2024-02-20 20:21:35 +0100 | danse-nr3 | (~danse@151.43.155.200) |
| 2024-02-20 20:22:36 +0100 | gabriel_sevecek | (~gabriel@188-167-229-200.dynamic.chello.sk) (Quit: WeeChat 4.1.1) |
| 2024-02-20 20:24:14 +0100 | gabriel_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 +0100 | waleee | (~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 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) (Remote host closed the connection) |
| 2024-02-20 20:32:48 +0100 | ski | (~ski@ext-1-033.eduroam.chalmers.se) |
| 2024-02-20 20:33:43 +0100 | dcoutts | (~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 260 seconds) |
| 2024-02-20 20:35:02 +0100 | euleritian | (~euleritia@77.22.252.56) (Read error: Connection reset by peer) |
| 2024-02-20 20:35:22 +0100 | euleritian | (~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) |
| 2024-02-20 20:37:14 +0100 | ulvarref` | (~user@188.124.56.153) (Remote host closed the connection) |
| 2024-02-20 20:52:23 +0100 | Vq | (~vq@2001:2043:1c58:ea00:ca7f:54ff:fe6a:fd48) (Ping timeout: 260 seconds) |
| 2024-02-20 20:54:07 +0100 | Vq | (~vq@81-231-76-8-no600.tbcn.telia.com) |
| 2024-02-20 20:54:23 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 20:55:03 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer) |
| 2024-02-20 20:56:45 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 20:58:49 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds) |
| 2024-02-20 20:59:28 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer) |
| 2024-02-20 20:59:52 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 21:00:55 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Remote host closed the connection) |
| 2024-02-20 21:01:23 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 21:02:50 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer) |
| 2024-02-20 21:03:11 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 21:03:39 +0100 | cfricke | (~cfricke@user/cfricke) (Quit: WeeChat 4.1.2) |
| 2024-02-20 21:04:01 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Read error: Connection reset by peer) |
| 2024-02-20 21:04:25 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 21:04:52 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) (Remote host closed the connection) |
| 2024-02-20 21:05:15 +0100 | sam113101 | (~sam@modemcable146.137-200-24.mc.videotron.ca) |
| 2024-02-20 21:06:43 +0100 | fendor | (~fendor@2a02:8388:1605:d100:267b:1353:13d7:4f0c) (Remote host closed the connection) |
| 2024-02-20 21:15:20 +0100 | euphores | (~SASL_euph@user/euphores) (Quit: Leaving.) |
| 2024-02-20 21:15:40 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-20 21:20:54 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-20 21:25:15 +0100 | euphores | (~SASL_euph@user/euphores) |
| 2024-02-20 21:27:06 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 21:31:39 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Ping timeout: 255 seconds) |
| 2024-02-20 21:34:28 +0100 | son0p | (~ff@167.0.172.211) |
| 2024-02-20 21:38:26 +0100 | chele | (~chele@user/chele) (Remote host closed the connection) |
| 2024-02-20 21:42:59 +0100 | ft | (~ft@p508db2e6.dip0.t-ipconnect.de) |
| 2024-02-20 21:46:09 +0100 | sord937 | (~sord937@gateway/tor-sasl/sord937) (Quit: sord937) |
| 2024-02-20 21:57:04 +0100 | danse-nr3 | (~danse@151.43.155.200) (Read error: Connection reset by peer) |
| 2024-02-20 21:57:39 +0100 | danse-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 +0100 | shapr | facepalms |
| 2024-02-20 21:59:58 +0100 | <mauke> | I don't know that combinator |
| 2024-02-20 22:00:05 +0100 | califax | (~califax@user/califx) (Remote host closed the connection) |
| 2024-02-20 22:01:09 +0100 | califax | (~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 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) |
| 2024-02-20 22:14:44 +0100 | <shapr> | :-P |
| 2024-02-20 22:15:21 +0100 | target_i | (~target_i@217.175.14.39) (Quit: leaving) |
| 2024-02-20 22:19:11 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…) |
| 2024-02-20 22:21:01 +0100 | phma | (~phma@host-67-44-208-78.hnremote.net) (Read error: Connection reset by peer) |
| 2024-02-20 22:22:25 +0100 | phma | (phma@2001:5b0:211c:c1d8:e754:54f0:2658:655) |
| 2024-02-20 22:23:34 +0100 | tromp | (~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) |
| 2024-02-20 22:27:11 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) |
| 2024-02-20 22:28:11 +0100 | tri | (~tri@ool-18bbef1a.static.optonline.net) (Remote host closed the connection) |
| 2024-02-20 22:28:15 +0100 | gorignak | (~gorignak@user/gorignak) |
| 2024-02-20 22:28:44 +0100 | shapr | (~user@c-24-218-186-89.hsd1.ma.comcast.net) (Remote host closed the connection) |
| 2024-02-20 22:30:45 +0100 | euphores | (~SASL_euph@user/euphores) (Quit: Leaving.) |
| 2024-02-20 22:35:48 +0100 | euphores | (~SASL_euph@user/euphores) |
| 2024-02-20 22:36:29 +0100 | danse-nr3 | (~danse@151.57.200.9) (Ping timeout: 272 seconds) |
| 2024-02-20 22:37:10 +0100 | fen53 | (~fen@84.68.80.95) |
| 2024-02-20 22:37:54 +0100 | fen53 | fen_ |
| 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 +0100 | euphores | (~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 +0100 | euphores | (~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 +0100 | miumiu | (~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 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection) |
| 2024-02-20 22:46:05 +0100 | miumiu | (~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 +0100 | miumiu | (~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 +0100 | miumiu | (~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 +0100 | machinedgod | (~machinedg@d173-183-246-216.abhsia.telus.net) |
| 2024-02-20 22:52:10 +0100 | julie_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 +0100 | dcoutts | (~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 +0100 | tri | (~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 +0100 | thegeekinside | (~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 +0100 | thegeekinside | (~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 +0100 | tri | (~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 +0100 | coot | (~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 +0100 | a51 | (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 +0100 | yoo | (~yo0O0o@104.28.194.104) |
| 2024-02-20 23:28:42 +0100 | danse-nr3 | (~danse@151.57.200.9) |
| 2024-02-20 23:31:13 +0100 | julie_pilgrim | (~julie_pil@user/julie-pilgrim/x-1240752) (Remote host closed the connection) |
| 2024-02-20 23:31:27 +0100 | takuan | (~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 +0100 | michalz | (~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 +0100 | yoo | (~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 +0100 | machinedgod | (~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> | <sm> 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> | <sm> 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 +0100 | synchromesh | (~synchrome@2407:7000:aa2d:4e00:9cf7:efcb:5efd:a99) (Read error: Connection reset by peer) |
| 2024-02-20 23:45:32 +0100 | <haskellbridge> | <sm> 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> | <sm> 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 +0100 | segfaultfizzbuzz | (~segfaultf@23-93-189-95.fiber.dynamic.sonic.net) |
| 2024-02-20 23:46:20 +0100 | masterbuilder | (~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 +0100 | synchromesh | (~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 +0100 | tomsmeding | (~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 +0100 | tomsmeding | (~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 +0100 | yoo | (~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> | <sm> 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 +0100 | danse-nr3 | (~danse@151.57.200.9) (Ping timeout: 246 seconds) |
| 2024-02-20 23:54:24 +0100 | acidjnk | (~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> | <sm> 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> | <sm> 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> | <sm> 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 |