IRCBrowse

2020/11/20

2020-11-20 00:00:43 +0100britva(~britva@31-10-157-156.cgn.dynamic.upc.ch)
2020-11-20 00:00:43 +0100britva(~britva@31-10-157-156.cgn.dynamic.upc.ch) (Client Quit)
2020-11-20 00:01:05 +0100 <monochrom> OK, at least that's my model of why they ask it.
2020-11-20 00:02:41 +0100toxixDTZUZU
2020-11-20 00:02:43 +0100 <monochrom> Better examples would be: hash table lookups are O(1)-time, big-O means worst case. Those they really hold dear to.
2020-11-20 00:03:05 +0100ski. o O ( TCMC )
2020-11-20 00:03:10 +0100 <dolio> Haskell's dead. He doesn't do anything.
2020-11-20 00:03:44 +0100 <ski> @where haskel
2020-11-20 00:03:44 +0100 <lambdabot> <http://web.archive.org/web/20070703001910/http://www.cs.chalmers.se/~augustss/pics/haskel.gif>
2020-11-20 00:04:37 +0100 <monochrom> OK, obOnTopic: I'm reading the paper "Splittable Pseudorandom Number Generators using Cryptographic Hashing", it's pretty neat.
2020-11-20 00:07:50 +0100 <monochrom> Heh, actually the only reason it's on-topic is because for some reason Claesen and Palka sent it to the Haskell 2013 Symposium.
2020-11-20 00:08:46 +0100 <monochrom> splittable PRNGs are now a non-Haskell-specific topic, the Java and Rust people are equally interested for concurrent algorithms.
2020-11-20 00:10:18 +0100 <dolio> I'm not sure being on topic here requires not being on topic anywhere else.
2020-11-20 00:10:23 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser) (Quit: WeeChat 2.9)
2020-11-20 00:10:35 +0100 <monochrom> OK!
2020-11-20 00:10:57 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 00:11:53 +0100 <monochrom> Conjecture: If Koen Claessen proves P/=NP one day, he'll submit it to a Haskell Symposium or ICFP. >:)
2020-11-20 00:12:26 +0100 <Rembane> ^^
2020-11-20 00:13:42 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Quit: Leaving)
2020-11-20 00:14:09 +0100skiimagines "You know, I recently proved this cool result : .." in Claessen's voice
2020-11-20 00:14:35 +0100 <Rembane> :D
2020-11-20 00:14:56 +0100 <Rembane> I wonder what the reason is that they started working on the number generators
2020-11-20 00:15:00 +0100 <Rembane> QuickCheck maybe...
2020-11-20 00:15:49 +0100 <monochrom> Yeah, that paper begins with how the old random's split sucked totally for pretty simple QuickCheck use cases.
2020-11-20 00:17:02 +0100 <Rembane> Ha! Nice! :D
2020-11-20 00:17:03 +0100andi-(~andi-@NixOS/user/andi-) (Ping timeout: 272 seconds)
2020-11-20 00:17:43 +0100kritzefitz(~kritzefit@212.86.56.80) (Remote host closed the connection)
2020-11-20 00:18:17 +0100 <monochrom> This paper and the splitmix paper, together with what the splitmix paper cites and improves upon, all 3 use this basic idea:
2020-11-20 00:18:27 +0100 <dolio> Maybe I shouldn't drag back the previous conversation, but P vs. NP seems like one of the most overhyped problems.
2020-11-20 00:18:44 +0100 <dolio> Probably irrelevant to practice.
2020-11-20 00:19:55 +0100 <monochrom> Your generator state consists of the initial seed, the history of how you got here via splitting (a list of lefts and rights), and how many times you've called "next".
2020-11-20 00:20:14 +0100 <monochrom> And your random number is simply the hash of that state.
2020-11-20 00:20:46 +0100magma(~magma@host-87-20-128-180.retail.telecomitalia.it)
2020-11-20 00:21:26 +0100andi-(~andi-@NixOS/user/andi-)
2020-11-20 00:21:30 +0100 <monochrom> The implementation details are what hashing to use, and how to make that incremental so you never rehash the same lengthy history prefix.
2020-11-20 00:22:03 +0100erisco(~erisco@d24-57-249-233.home.cgocable.net)
2020-11-20 00:22:24 +0100 <Rembane> It's beautiful.
2020-11-20 00:22:37 +0100 <Rembane> How do you know if you should pick left or right?
2020-11-20 00:23:00 +0100 <davean> The operation you're doing defines which you're doing.
2020-11-20 00:23:06 +0100 <monochrom> Say my history is <left, right, left>, and I call split.
2020-11-20 00:23:30 +0100 <monochrom> Now the two new states are <left, right, left, left> and <left, right, left, right>, respectively
2020-11-20 00:24:12 +0100Franciman(~francesco@host-82-56-223-169.retail.telecomitalia.it)
2020-11-20 00:24:17 +0100magma(~magma@host-87-20-128-180.retail.telecomitalia.it) (Client Quit)
2020-11-20 00:24:44 +0100 <monochrom> split (seed, history, counter) = ((seed, history++[left], counter), (seed, history++[right], counter))
2020-11-20 00:25:19 +0100Franciman(~francesco@host-82-56-223-169.retail.telecomitalia.it) (Client Quit)
2020-11-20 00:25:28 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 00:25:30 +0100hackagecodeworld-api 0.7.0 - Graphics library for CodeWorld https://hackage.haskell.org/package/codeworld-api-0.7.0 (ChrisSmith)
2020-11-20 00:26:18 +0100 <monochrom> Now you need to bet everything on the quality of your hash function, yeah. :)
2020-11-20 00:26:28 +0100theorbtwo(~theorb@cpc81822-swin19-2-0-cust3.3-1.cable.virginm.net) (Ping timeout: 260 seconds)
2020-11-20 00:27:21 +0100 <Rembane> Oh. Got it! That's clever.
2020-11-20 00:27:23 +0100 <monochrom> splitmix basically just ran DieHard1 etc and reported very good scores.
2020-11-20 00:27:30 +0100hackagezydiskell 0.1.1.0 - Haskell language binding for the Zydis library, a x86/x86-64 disassembler. https://hackage.haskell.org/package/zydiskell-0.1.1.0 (nerded)
2020-11-20 00:27:55 +0100 <monochrom> Claessen and Palka's simply went crypto.
2020-11-20 00:28:09 +0100christo(~chris@81.96.113.213)
2020-11-20 00:29:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 00:29:52 +0100xerox_(~xerox@unaffiliated/xerox)
2020-11-20 00:32:08 +0100 <monochrom> The next cleverness is how to eliminate storing that lengthy history, bringing the time cost back down to O(1) regardless of how many times you've called split.
2020-11-20 00:33:31 +0100son0p(~son0p@181.136.122.143) (Quit: leaving)
2020-11-20 00:33:31 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 00:34:02 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 00:34:42 +0100 <monochrom> For Claessen and Palka, it turns out that popular crypto hash functions run a block cipher for as many rounds as your input (which is the history here), so you can just save "the hash so far" instead of the full history.
2020-11-20 00:35:22 +0100 <monochrom> For splitmix, the hash is an inner product, so again you can just save "the inner product so far".
2020-11-20 00:35:37 +0100 <monochrom> actually s/inner/dot/ to be specific.
2020-11-20 00:36:20 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-11-20 00:37:07 +0100hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-11-20 00:37:09 +0100 <monochrom> Those two papers are both very fun and pleasing to read.
2020-11-20 00:37:10 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 00:37:35 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2020-11-20 00:38:00 +0100jayw99(2fe3e53b@047-227-229-059.res.spectrum.com)
2020-11-20 00:38:16 +0100 <jayw99> hi! is there a way to use the @ syntax for data types defined as records
2020-11-20 00:38:23 +0100hekkaidekapus_(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-11-20 00:38:42 +0100 <jayw99> say I have: data A = A { field :: Int }
2020-11-20 00:38:53 +0100 <jayw99> and i want to make a function f {field=f}
2020-11-20 00:39:02 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 00:39:04 +0100 <jayw99> is there a way to do something like f a@{field=f}
2020-11-20 00:39:06 +0100 <monochrom> f x@A{field=y} = y+1
2020-11-20 00:39:21 +0100 <jayw99> oh you have to have the A
2020-11-20 00:39:27 +0100 <monochrom> Yeah, that's all.
2020-11-20 00:39:28 +0100machinedgod(~machinedg@24.105.81.50)
2020-11-20 00:39:34 +0100 <jayw99> thx!
2020-11-20 00:40:07 +0100benb(52456307@82-69-99-7.dsl.in-addr.zen.co.uk) (Remote host closed the connection)
2020-11-20 00:40:56 +0100Chi1thangoo(~Chi1thang@87.112.60.168) (Ping timeout: 240 seconds)
2020-11-20 00:41:43 +0100hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 240 seconds)
2020-11-20 00:45:04 +0100jayw99(2fe3e53b@047-227-229-059.res.spectrum.com) (Ping timeout: 245 seconds)
2020-11-20 00:48:51 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com)
2020-11-20 00:48:51 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 00:49:01 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 00:49:11 +0100acidjnk_new(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de)
2020-11-20 00:49:54 +0100Varis(~Tadas@unaffiliated/varis)
2020-11-20 00:52:31 +0100hackageyi-language 0.19.0 - Collection of language-related Yi libraries. https://hackage.haskell.org/package/yi-language-0.19.0 (TomMurphy)
2020-11-20 00:56:48 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-20 00:56:58 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 00:58:18 +0100falafel_(~falafel@c-73-79-82-198.hsd1.pa.comcast.net)
2020-11-20 00:58:38 +0100p-core1(~Thunderbi@2a0e:1c80:4:1023::1004)
2020-11-20 00:58:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-11-20 00:58:46 +0100hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-11-20 00:59:26 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Ping timeout: 264 seconds)
2020-11-20 00:59:26 +0100p-core1p-core
2020-11-20 01:01:12 +0100falafel(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 01:02:08 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 272 seconds)
2020-11-20 01:03:16 +0100jedws(~jedws@101.184.150.93)
2020-11-20 01:07:17 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2020-11-20 01:08:32 +0100Varis(~Tadas@unaffiliated/varis)
2020-11-20 01:10:24 +0100borne(~fritjof@200116b864eda200f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-11-20 01:12:36 +0100borne(~fritjof@200116b8640a4d0024e67d79d03c01ac.dip.versatel-1u1.de)
2020-11-20 01:13:39 +0100jedws(~jedws@101.184.150.93) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 01:14:04 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 01:14:31 +0100hackageyi-core 0.19.0 - Yi editor core library https://hackage.haskell.org/package/yi-core-0.19.0 (TomMurphy)
2020-11-20 01:14:41 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-20 01:14:42 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 01:15:02 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 01:15:34 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-20 01:15:57 +0100jedws(~jedws@101.184.150.93)
2020-11-20 01:16:27 +0100Sarma(~Amras@unaffiliated/amras0000)
2020-11-20 01:17:28 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-11-20 01:18:37 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Quit: Leaving)
2020-11-20 01:18:37 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 01:18:42 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843)
2020-11-20 01:20:03 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 01:22:47 +0100Tracerneo1(~Tracerneo@193.56.252.12) (Remote host closed the connection)
2020-11-20 01:29:22 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2020-11-20 01:32:31 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16)
2020-11-20 01:34:57 +0100jess(jess@freenode/staff/jess) (Quit: Leaving)
2020-11-20 01:36:05 +0100enoq(~textual@194-208-146-143.lampert.tv) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 01:36:38 +0100leungbk(~user@2605:e000:1315:706:925b:594a:9503:ee10)
2020-11-20 01:36:39 +0100nullheroes(~danielvu@168.235.66.22)
2020-11-20 01:43:20 +0100DJWillis(~DJWillis@217.146.82.202)
2020-11-20 01:44:45 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 240 seconds)
2020-11-20 01:46:23 +0100ph88(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b)
2020-11-20 01:48:05 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 240 seconds)
2020-11-20 01:55:38 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr) (Ping timeout: 256 seconds)
2020-11-20 01:56:53 +0100Benzi-Junior(~BenziJuni@88-149-67-198.du.xdsl.is) (Ping timeout: 260 seconds)
2020-11-20 01:57:00 +0100B-J(~BenziJuni@88-149-65-135.du.xdsl.is)
2020-11-20 01:57:58 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2020-11-20 01:59:49 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 02:00:07 +0100leungbk(~user@2605:e000:1315:706:925b:594a:9503:ee10) (Ping timeout: 260 seconds)
2020-11-20 02:00:30 +0100hackageyi-core 0.19.1 - Yi editor core library https://hackage.haskell.org/package/yi-core-0.19.1 (TomMurphy)
2020-11-20 02:00:31 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 02:00:47 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 02:00:49 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 02:00:55 +0100alp(~alp@2a01:e0a:58b:4920:8196:f1ff:e993:87c3) (Ping timeout: 272 seconds)
2020-11-20 02:01:33 +0100ph88(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b) (Ping timeout: 272 seconds)
2020-11-20 02:05:22 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 02:05:25 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 02:06:00 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 02:06:31 +0100acidjnk_new2(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de)
2020-11-20 02:07:22 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 272 seconds)
2020-11-20 02:08:21 +0100livvy(~livvy@gateway/tor-sasl/livvy)
2020-11-20 02:09:24 +0100acidjnk_new(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-11-20 02:09:24 +0100gentauro(~gentauro@unaffiliated/gentauro) (Read error: Connection reset by peer)
2020-11-20 02:10:10 +0100Deide(~Deide@217.155.19.23) (Quit: Seeee yaaaa)
2020-11-20 02:10:16 +0100gentauro(~gentauro@unaffiliated/gentauro)
2020-11-20 02:10:17 +0100christo(~chris@81.96.113.213)
2020-11-20 02:11:24 +0100 <dolio> Someone's working on yi?
2020-11-20 02:11:37 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 02:12:38 +0100alp(~alp@2a01:e0a:58b:4920:a9d4:25a5:c24f:25ed)
2020-11-20 02:13:04 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-lviokxjrzjjmnlqh) (Ping timeout: 240 seconds)
2020-11-20 02:14:01 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Ping timeout: 264 seconds)
2020-11-20 02:14:16 +0100leungbk(~user@cpe-104-33-52-83.socal.res.rr.com)
2020-11-20 02:14:37 +0100christo(~chris@81.96.113.213) (Read error: No route to host)
2020-11-20 02:15:14 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-itluyvgbrrzsqlpm)
2020-11-20 02:15:16 +0100christo(~chris@81.96.113.213)
2020-11-20 02:16:00 +0100hackageyi-core 0.19.2 - Yi editor core library https://hackage.haskell.org/package/yi-core-0.19.2 (TomMurphy)
2020-11-20 02:16:52 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 02:19:07 +0100 <glguy> Maybe someone could tell Tom Murphy about package candidates
2020-11-20 02:20:45 +0100erisco(~erisco@d24-57-249-233.home.cgocable.net) (Quit: Leaving)
2020-11-20 02:21:46 +0100ShinyPants(~user@2604:3d09:207f:f650:1c53:faca:fa1d:35d3)
2020-11-20 02:22:35 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 02:24:16 +0100iqubic(~user@2601:602:9500:4870:d13a:6a31:cf0a:f017)
2020-11-20 02:25:49 +0100 <iqubic> Well, I'm struggling right now. I want to write a function with the type [[a]] -> M.Map (V2 Int), where the first element of the first list is associated with (V2 0 0), and the rest follows from there. I'm not sure how to do that.
2020-11-20 02:27:35 +0100 <iqubic> Can I get some help on how to do that?
2020-11-20 02:27:50 +0100 <dsal> I don't understand how you get from `a` to whatever V2 is.
2020-11-20 02:27:57 +0100 <dsal> Is `V2 Int` a type?
2020-11-20 02:28:40 +0100 <iqubic> dsal: data V2 a = V2 a a.
2020-11-20 02:28:58 +0100 <iqubic> It's from the Data.Linear package, but you can just use that definite.
2020-11-20 02:29:03 +0100 <dsal> So something like this? > fmap (\(x:xs) -> (x, xs)) ["abc", "def"]
2020-11-20 02:29:14 +0100 <dsal> > fmap (\(x:xs) -> (x, xs)) ["abc", "def"] -- -> M.fromList
2020-11-20 02:29:16 +0100 <lambdabot> [('a',"bc"),('d',"ef")]
2020-11-20 02:30:01 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 265 seconds)
2020-11-20 02:30:15 +0100 <dsal> Oh, I think I understand.
2020-11-20 02:30:29 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 02:30:46 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 02:32:23 +0100 <dsal> > fmap (\(y,l) -> zipWith (\x a -> (x,y,a)) [0..] l) $ zip [0..] ["abc", "def"] -- something like this?
2020-11-20 02:32:25 +0100 <lambdabot> [[(0,0,'a'),(1,0,'b'),(2,0,'c')],[(0,1,'d'),(1,1,'e'),(2,1,'f')]]
2020-11-20 02:34:05 +0100 <iqubic> Basically something like this:
2020-11-20 02:34:07 +0100 <iqubic> https://dpaste.com/AVYCK9ULA
2020-11-20 02:34:22 +0100 <iqubic> If that makes any sense.
2020-11-20 02:34:43 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2020-11-20 02:34:48 +0100 <iqubic> I see what you've given me.
2020-11-20 02:34:48 +0100Lord_of_Life_(~Lord@46.217.218.71)
2020-11-20 02:34:51 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 265 seconds)
2020-11-20 02:34:51 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 265 seconds)
2020-11-20 02:35:03 +0100 <iqubic> dsal: Does my paste make sense?
2020-11-20 02:35:16 +0100roconnor(~roconnor@host-104-157-230-3.dyn.295.ca) (Ping timeout: 260 seconds)
2020-11-20 02:35:21 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843)
2020-11-20 02:35:35 +0100 <dsal> Yeah, completely. I just sketched that thing in lambdabot, but I think it gets you pretty close to what you want.
2020-11-20 02:35:42 +0100 <iqubic> Yes. It does.
2020-11-20 02:36:05 +0100 <iqubic> I just need to change the data types used, and feed the result into M.fromList.
2020-11-20 02:38:03 +0100 <dsal> Cool... There's probably a better way to do that, and I should probably come up with a nice way to do that. Sort of a two dimensional zip.
2020-11-20 02:38:19 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz)
2020-11-20 02:38:55 +0100p-core(~Thunderbi@2a0e:1c80:4:1023::1004) (Ping timeout: 272 seconds)
2020-11-20 02:39:14 +0100 <iqubic> For now, that's the least of my worries.
2020-11-20 02:42:34 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 02:44:18 +0100ShinyPants(~user@2604:3d09:207f:f650:1c53:faca:fa1d:35d3) (Remote host closed the connection)
2020-11-20 02:44:59 +0100remby(~rg@2607:fea8:2c40:307::1ef6) (Quit: Konversation terminated!)
2020-11-20 02:45:13 +0100 <iqubic> Can I use zip when the first argument is [0..]?
2020-11-20 02:46:38 +0100 <dsal> :t zip
2020-11-20 02:46:39 +0100 <lambdabot> [a] -> [b] -> [(a, b)]
2020-11-20 02:46:49 +0100 <dsal> Oh, you mean will it terminate?
2020-11-20 02:46:59 +0100 <dsal> zip ends when either input ends
2020-11-20 02:47:19 +0100 <iqubic> :t zipWith
2020-11-20 02:47:20 +0100 <lambdabot> (a -> b -> c) -> [a] -> [b] -> [c]
2020-11-20 02:47:27 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 02:49:03 +0100 <dsal> `zip` is just `zipWith (,)`
2020-11-20 02:50:30 +0100hackageyi-frontend-pango 0.19.0 - Pango frontend for Yi editor https://hackage.haskell.org/package/yi-frontend-pango-0.19.0 (TomMurphy)
2020-11-20 02:50:34 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2020-11-20 02:50:46 +0100 <dsal> Oh, I didn't notice a thing I did.
2020-11-20 02:50:47 +0100Tario(~Tario@201.192.165.173)
2020-11-20 02:50:53 +0100 <dsal> `zipWith2D :: (a -> b -> c -> d) -> [a] -> [b] -> [[c]] -> [d]; zipWith2D f xs ys = foldMap (\(y, l) -> zipWith (\x -> f x y) xs l) . zip ys`
2020-11-20 02:50:57 +0100 <dsal> That's a slightly better version.
2020-11-20 02:51:02 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2020-11-20 02:51:30 +0100hackageyi-frontend-vty 0.19.0 - Vty frontend for Yi editor https://hackage.haskell.org/package/yi-frontend-vty-0.19.0 (TomMurphy)
2020-11-20 02:52:04 +0100 <dsal> using fmap meant you got a `[[d]]` back, which was confusing me when I tried doing it with a declared type.
2020-11-20 02:56:00 +0100hackageyi-keymap-vim 0.19.0 - Vim keymap for Yi editor https://hackage.haskell.org/package/yi-keymap-vim-0.19.0 (TomMurphy)
2020-11-20 02:57:01 +0100hackageyi-misc-modes 0.19.0 - Yi editor miscellaneous modes https://hackage.haskell.org/package/yi-misc-modes-0.19.0 (TomMurphy)
2020-11-20 02:57:26 +0100 <dsal> I need to add that to my aoc toolkit. I end up inventing something like that regularly.
2020-11-20 03:00:04 +0100 <dsal> Oh cool, I had a function that was slightly related that could be built on that, and it already had tests, so I can wedge it in there.
2020-11-20 03:00:41 +0100 <iqubic> dsal: I'm actually preparing my AOC toolkit as we speak.
2020-11-20 03:01:01 +0100 <dsal> I should do more of that. I always feel like it would've been a great idea after the fact.
2020-11-20 03:01:03 +0100 <iqubic> I have a file literally called Grid.hs, for doing grid based stuff.
2020-11-20 03:02:01 +0100 <dsal> I've got `parseGrid :: (Char -> a) -> String -> Map (Int,Int) a` which is pretty common for those map things for me. And a bunch of `around` and distance functions.
2020-11-20 03:02:56 +0100 <dsal> And stuff that takes those grid things and spits out text or png visualizations.
2020-11-20 03:04:05 +0100 <dsal> Mostly just use this text one: `draw :: Bounded2D a => FilePath -> a -> PixelFun -> IO ()`
2020-11-20 03:05:11 +0100crdrost(~crdrost@2601:646:8280:85f0:90f7:1b03:f01f:afae) (Quit: This computer has gone to sleep)
2020-11-20 03:05:22 +0100roconnor(~roconnor@host-104-157-230-3.dyn.295.ca)
2020-11-20 03:07:25 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 264 seconds)
2020-11-20 03:08:28 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16)
2020-11-20 03:09:53 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 03:11:09 +0100guest1120(~user@49.5.6.87)
2020-11-20 03:11:38 +0100 <MarcelineVQ> I always think aoc is a really great idea until problem 3 or 4
2020-11-20 03:11:57 +0100 <MarcelineVQ> Then I feel less and less sure about that until the curve becomes eliptical
2020-11-20 03:12:22 +0100 <monochrom> haha
2020-11-20 03:13:12 +0100 <monochrom> This proves that your sentiment is under Newtonian gravitation >:)
2020-11-20 03:13:37 +0100 <MarcelineVQ> this explains why I'm always in free fall
2020-11-20 03:13:42 +0100Entertainment(~entertain@104.246.132.210) ()
2020-11-20 03:14:24 +0100codeAlways(uid272474@gateway/web/irccloud.com/x-zbflumxjrtygmhzc) (Quit: Connection closed for inactivity)
2020-11-20 03:15:32 +0100 <iqubic> What is Bounded2D?
2020-11-20 03:15:44 +0100 <iqubic> My drawing function is quite primative.
2020-11-20 03:16:24 +0100christo(~chris@81.96.113.213)
2020-11-20 03:16:43 +0100livvy(~livvy@gateway/tor-sasl/livvy) (Ping timeout: 240 seconds)
2020-11-20 03:20:37 +0100leungbk(~user@cpe-104-33-52-83.socal.res.rr.com) (Remote host closed the connection)
2020-11-20 03:20:54 +0100benjamingr__(uid23465@gateway/web/irccloud.com/x-aztrejkfdpbhytuo) (Quit: Connection closed for inactivity)
2020-11-20 03:21:47 +0100macrover(~macrover@ip70-189-231-35.lv.lv.cox.net) (Ping timeout: 260 seconds)
2020-11-20 03:22:49 +0100 <dsal> iqubic: Bounded2D gives me `bounds2d :: a -> ((Int,Int), (Int,Int))`-- (min x, min y), (max x, max y)
2020-11-20 03:23:05 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-20 03:23:10 +0100 <iqubic> I see.
2020-11-20 03:23:12 +0100 <iqubic> Nice.
2020-11-20 03:23:25 +0100 <iqubic> I don't have any functions for dealing with Rectangles.
2020-11-20 03:24:15 +0100Tario(~Tario@201.192.165.173)
2020-11-20 03:24:30 +0100hackagemprelude 0.2.1 - A minimalish prelude. https://hackage.haskell.org/package/mprelude-0.2.1 (mbj)
2020-11-20 03:24:39 +0100falafel_(~falafel@c-73-79-82-198.hsd1.pa.comcast.net) (Remote host closed the connection)
2020-11-20 03:25:03 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 03:25:20 +0100 <MarcelineVQ> you should steal conal's drawing stuff http://conal.net/papers/functional-images/
2020-11-20 03:28:04 +0100 <dsal> I end up drawing a lot of the stuff while I'm trying to understand it. This junk helps. Also that thing that translates my arbitrary bounds to 0-based bounds. I get that wrong so much.
2020-11-20 03:28:29 +0100 <dsal> I ended up with a data type that represents the size and has translation functions for each direction.
2020-11-20 03:29:19 +0100 <dsal> I'm not trying to do super fancy drawing stuff, mainly just "take grid from memory and put on screen"
2020-11-20 03:29:20 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Read error: Connection reset by peer)
2020-11-20 03:29:35 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2020-11-20 03:30:01 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-20 03:30:38 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-20 03:31:04 +0100conal(~conal@ip-66-115-176-195.creativelink.net) (Quit: Computer has gone to sleep.)
2020-11-20 03:31:27 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 03:31:36 +0100 <dsal> e.g., this is about as fancy as I get: https://asciinema.org/a/288366
2020-11-20 03:32:17 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 03:32:38 +0100 <MarcelineVQ> Urist Akinhumor has drowned
2020-11-20 03:38:04 +0100xff0x(~fox@2001:1a81:534b:a000:65df:cebc:ef3d:70f7) (Ping timeout: 240 seconds)
2020-11-20 03:38:09 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843)
2020-11-20 03:39:39 +0100conal(~conal@ip-66-115-176-195.creativelink.net)
2020-11-20 03:40:00 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-20 03:40:28 +0100xff0x(~fox@2001:1a81:5385:e100:f695:2019:7725:a87d)
2020-11-20 03:42:13 +0100shatriff(~vitaliish@176.52.219.10) (Remote host closed the connection)
2020-11-20 03:42:49 +0100shatriff(~vitaliish@176.52.219.10)
2020-11-20 03:47:16 +0100 <ski> dsal : seems to be missing an `o', just beside the start ?
2020-11-20 03:49:01 +0100hackagedevtools 0.1.0 - Haskell development tool agregate https://hackage.haskell.org/package/devtools-0.1.0 (mbj)
2020-11-20 03:50:04 +0100 <ski> MarcelineVQ : who ?
2020-11-20 03:52:12 +0100 <MarcelineVQ> Urist is the generic surname for dwarfs when telling dwarf fortress stories, dsal's art was reminiscent of flooding water in dwarf fortress
2020-11-20 03:53:18 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 03:53:53 +0100christo(~chris@81.96.113.213)
2020-11-20 03:54:26 +0100alp(~alp@2a01:e0a:58b:4920:a9d4:25a5:c24f:25ed) (Remote host closed the connection)
2020-11-20 03:55:08 +0100jedws(~jedws@101.184.150.93) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 03:55:08 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 03:55:19 +0100christo(~chris@81.96.113.213)
2020-11-20 03:58:03 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-20 04:01:52 +0100 <dsal> I don't remember the puzzle. Something about flooding with air.
2020-11-20 04:02:18 +0100CMCDragonkai1(~Thunderbi@124.19.3.250)
2020-11-20 04:02:59 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 04:03:08 +0100 <dsal> Yeah, I don't remember what that gap was. Probably should've painted it something that didn't make it look like an accident.
2020-11-20 04:06:45 +0100CMCDragonkai1(~Thunderbi@124.19.3.250) (Ping timeout: 240 seconds)
2020-11-20 04:07:30 +0100drbean(~drbean@TC210-63-209-219.static.apol.com.tw)
2020-11-20 04:08:56 +0100urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2020-11-20 04:11:05 +0100 <ski> mhm
2020-11-20 04:13:25 +0100jespada(~jespada@90.254.245.49) (Ping timeout: 240 seconds)
2020-11-20 04:15:55 +0100jespada(~jespada@90.254.245.49)
2020-11-20 04:17:24 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16)
2020-11-20 04:17:39 +0100renzhi(~renzhi@2607:fa49:655f:e600::28da) (Quit: WeeChat 2.3)
2020-11-20 04:18:42 +0100 <magicman> I must be missing something. Is there a way in esqueleto to turn an SqlExpr (Entity x) into an SqlExpr (Maybe (Entity x))?
2020-11-20 04:19:05 +0100 <magicman> The 'just' function works on SqlExpr (Value x) -> SqlExpr (Value (Maybe x)), so that's not what I want.
2020-11-20 04:21:26 +0100didymosoats
2020-11-20 04:24:02 +0100acidjnk_new2(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de) (Ping timeout: 264 seconds)
2020-11-20 04:24:35 +0100 <magicman> I have a function that chooses between two queries, depending on if I want "Only those X that have some related Y, and their Y", or "All X, and possibly their related Y".
2020-11-20 04:25:45 +0100 <magicman> So that translates to an inner join VS outer join, except esqueleto says no, because outer join gives Maybe. For good reason. So I want to wrap the result of the inner join in Maybe as well.
2020-11-20 04:27:36 +0100 <magicman> And I kinda want to still be on the query-level. I could do the select $ from $ blah for both queries, and map Just where relevant, but that feels a bit off.
2020-11-20 04:30:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 04:34:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 04:35:33 +0100nados(~dan@69-165-210-185.cable.teksavvy.com)
2020-11-20 04:35:36 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas) (Ping timeout: 240 seconds)
2020-11-20 04:37:40 +0100conal(~conal@ip-66-115-176-195.creativelink.net) (Quit: Computer has gone to sleep.)
2020-11-20 04:38:00 +0100acidjnk_new2(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de)
2020-11-20 04:42:35 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 04:43:31 +0100hackageyi-mode-haskell 0.19.0 - Yi editor haskell mode https://hackage.haskell.org/package/yi-mode-haskell-0.19.0 (TomMurphy)
2020-11-20 04:44:31 +0100hackageyi-mode-javascript 0.19.0 - Yi editor javascript mode https://hackage.haskell.org/package/yi-mode-javascript-0.19.0 (TomMurphy)
2020-11-20 04:44:39 +0100lagothrix(~lagothrix@unaffiliated/lagothrix) (Killed (hitchcock.freenode.net (Nickname regained by services)))
2020-11-20 04:44:47 +0100lagothrix(~lagothrix@unaffiliated/lagothrix)
2020-11-20 04:45:31 +0100hackageyi-fuzzy-open 0.19.0 - Fuzzy open plugin for yi https://hackage.haskell.org/package/yi-fuzzy-open-0.19.0 (TomMurphy)
2020-11-20 04:46:30 +0100hackageyi-ireader 0.19.0 - Yi editor incremental reader https://hackage.haskell.org/package/yi-ireader-0.19.0 (TomMurphy)
2020-11-20 04:47:31 +0100hackageyi-snippet 0.19.0, yi-keymap-emacs 0.19.0 (TomMurphy): https://qbin.io/weak-ratios-hjy8
2020-11-20 04:51:02 +0100theDon(~td@muedsl-82-207-238-104.citykom.de) (Ping timeout: 260 seconds)
2020-11-20 04:51:48 +0100 <magicman> Hrm. Looks like I can maybe possibly use the EMaybe function from the Internal module. This probably will not break anything ever, because directly using datatype constructors from modules named Internal never breaks things... *knocks on wood*.
2020-11-20 04:52:01 +0100hackageyi-dynamic-configuration 0.19.0 - Dynamic configuration support for Yi https://hackage.haskell.org/package/yi-dynamic-configuration-0.19.0 (TomMurphy)
2020-11-20 04:52:31 +0100 <magicman> (also, whoa, didn't know people still worked on Yi. It's been a while since I've seen that name show up!)
2020-11-20 04:52:41 +0100theDon(~td@94.134.91.165)
2020-11-20 04:53:20 +0100northman_(~northman@204.111.252.124) (Quit: Textual IRC Client: www.textualapp.com)
2020-11-20 04:57:03 +0100falafel__(~falafel@c-73-79-82-198.hsd1.pa.comcast.net)
2020-11-20 04:57:30 +0100hackageconversions 0.0.4 - Injective explicit total and partial conversions https://hackage.haskell.org/package/conversions-0.0.4 (mbj)
2020-11-20 04:59:47 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 05:00:45 +0100jedws(~jedws@101.184.150.93)
2020-11-20 05:08:56 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 240 seconds)
2020-11-20 05:09:36 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 05:12:12 +0100falafel__(~falafel@c-73-79-82-198.hsd1.pa.comcast.net) (Ping timeout: 256 seconds)
2020-11-20 05:13:17 +0100Feuermagier_(~Feuermagi@213.178.26.41)
2020-11-20 05:15:16 +0100Feuermagier(~Feuermagi@213.178.26.41) (Ping timeout: 240 seconds)
2020-11-20 05:18:42 +0100nf(~n@monade.li) (Ping timeout: 260 seconds)
2020-11-20 05:19:01 +0100nf(~n@monade.li)
2020-11-20 05:19:54 +0100m0rphism(~m0rphism@HSI-KBW-095-208-098-207.hsi5.kabel-badenwuerttemberg.de) (Ping timeout: 272 seconds)
2020-11-20 05:20:18 +0100 <koz_> If I'm reading type judgments, should I read 'Gamma, x : A |- x : A' as something like, 'given the fact that x types as A (plus possibly other facts), it follows that x types as A'?
2020-11-20 05:21:00 +0100quarters(~quarters@unaffiliated/quarters)
2020-11-20 05:21:37 +0100 <monochrom> Yes.
2020-11-20 05:22:40 +0100 <koz_> So basically, if I have '[above horizontal line] Gamma |- A : s [below horizontal line] Gamma, x : A |- x : A', this basically says 'if A is really a type, and we know that x types as A, then x types as A'?
2020-11-20 05:22:47 +0100iqubic(~user@2601:602:9500:4870:d13a:6a31:cf0a:f017) ("ERC (IRC client for Emacs 28.0.50)")
2020-11-20 05:22:55 +0100 <koz_> I guess I'm confused at the difference between the horizontal line and the turnstile.
2020-11-20 05:24:03 +0100 <monochrom> But the left of a turnstile is a very special kind of "assumptions".
2020-11-20 05:24:38 +0100 <monochrom> The left can only list the variables in scope, and their types.
2020-11-20 05:24:54 +0100 <koz_> Ah, so in a way, to the left of the turnstile we have a 'typing environment' basically?
2020-11-20 05:25:05 +0100 <monochrom> Yes, that's exactly it.
2020-11-20 05:25:13 +0100 <koz_> So what's with the big horizontal line?
2020-11-20 05:25:25 +0100 <monochrom> That one is really general implication.
2020-11-20 05:26:10 +0100 <koz_> Ah! I think I see it.
2020-11-20 05:26:32 +0100 <koz_> Since we have Gamma on the left of the top turnstile, with no mention of x, it means 'we can assume that every type has a kind'?
2020-11-20 05:26:46 +0100 <monochrom> or dividing a proof step into "before" and "after"
2020-11-20 05:27:56 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 260 seconds)
2020-11-20 05:27:56 +0100 <koz_> I guess I'm asking why this wasn't written as something like 'Gamma, x : A |- A : s, x : A'.
2020-11-20 05:28:30 +0100 <monochrom> Instead of "assume that a type has a kind", I think this rules is saying "in this system, a type has a kind".
2020-11-20 05:29:25 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-20 05:29:46 +0100hololeap(~hololeap@unaffiliated/hololeap) (Ping timeout: 256 seconds)
2020-11-20 05:30:15 +0100 <koz_> The rule is called 'var' if that helps any.
2020-11-20 05:30:32 +0100hololeap(~hololeap@unaffiliated/hololeap)
2020-11-20 05:35:30 +0100hackageyi-keymap-cua 0.19.0 - Cua keymap for Yi editor https://hackage.haskell.org/package/yi-keymap-cua-0.19.0 (TomMurphy)
2020-11-20 05:36:37 +0100 <monochrom> A:s in a conclusion position is very different, in some sense opposite, of A:s in a prerequisite position.
2020-11-20 05:37:03 +0100 <koz_> Could you elaborate on that?
2020-11-20 05:38:43 +0100 <monochrom> I was hoping that you could use what you already know about the difference between "G implies P and Q" and "G and P implies Q"
2020-11-20 05:40:10 +0100 <monochrom> If you have a rule that says: "conclusion: x:monochrom |- monochrom is a legal type, and x:monochrom", then it defines that monochrom is a legal type.
2020-11-20 05:40:23 +0100 <monochrom> But if you don't have rule...
2020-11-20 05:40:46 +0100conal(~conal@ip-66-115-176-195.creativelink.net)
2020-11-20 05:40:48 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-20 05:40:53 +0100 <monochrom> If you have, instead, "premise: monochrom is a type; conclusion: x:monochrom |- x:monochrom"
2020-11-20 05:41:17 +0100 <monochrom> now you still don't know whether monochrom is a type, and generally "expr : monochrom" has any chance of being legal at all.
2020-11-20 05:41:39 +0100 <monochrom> You will have to look for other rules to see if you can prove "monochrom is a type" or not.
2020-11-20 05:42:06 +0100 <koz_> Ah, I think I see what you're saying.
2020-11-20 05:42:15 +0100 <monochrom> If there is no, this means the system is trying to say "monochrom is not a legal type, you will never have anything of the form expr : monochrom"
2020-11-20 05:42:17 +0100howdoi(uid224@gateway/web/irccloud.com/x-dgisunxwmcstbixs) (Quit: Connection closed for inactivity)
2020-11-20 05:42:36 +0100 <koz_> Alright, thanks, that helps.
2020-11-20 05:42:49 +0100 <koz_> I keep forgetting that I need to become ten times stupider than I am as a human to properly read logic. :P
2020-11-20 05:42:55 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-20 05:43:05 +0100 <koz_> It's the optimist in me. 'Of course this is a type, what else could it possibly be?'.
2020-11-20 05:44:29 +0100 <monochrom> Some authors write a separate CFG to define legal types, and don't include this in the type checking rules.
2020-11-20 05:44:38 +0100 <koz_> These ones clearly didn't do that.
2020-11-20 05:44:58 +0100 <monochrom> Other authors use the type rules to define both legal types and type checking at the same time.
2020-11-20 05:44:58 +0100 <nshepperd> i think i would read that as saying that a typing environment containing x:A emits/proves that judgement (eg. so you can use it in other rules), but only if it also proves that A is a type
2020-11-20 05:45:01 +0100hackageyi-dynamic-configuration 0.19.1 - Dynamic configuration support for Yi https://hackage.haskell.org/package/yi-dynamic-configuration-0.19.1 (TomMurphy)
2020-11-20 05:45:25 +0100quarters(~quarters@unaffiliated/quarters) (Ping timeout: 240 seconds)
2020-11-20 05:45:30 +0100rekahsoft(~rekahsoft@fitz10681.telemetry.esentire.com)
2020-11-20 05:47:31 +0100 <monochrom> Dependent typing is likely to mean legal types don't match any CFG, so it may be better to merge type forming rules with type checking rules, because the format allows you to add more restrictions.
2020-11-20 05:47:31 +0100hackageyi-frontend-pango 0.19.1 - Pango frontend for Yi editor https://hackage.haskell.org/package/yi-frontend-pango-0.19.1 (TomMurphy)
2020-11-20 05:47:37 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Remote host closed the connection)
2020-11-20 05:47:39 +0100 <nshepperd> if A is not a type, but instead instead a potato, then "Gamma, x:A" does not let you use x:A in further rules
2020-11-20 05:47:59 +0100 <nshepperd> (unless there's a separate rules that says so)
2020-11-20 05:48:12 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 05:49:15 +0100 <koz_> Propositions as potatoes.
2020-11-20 05:49:23 +0100 <dolio> Proper variable scoping isn't context free, I believe.
2020-11-20 05:49:42 +0100 <dolio> So you're already screwed once you have variables.
2020-11-20 05:49:57 +0100 <monochrom> Oh heh yeah.
2020-11-20 05:51:06 +0100 <monochrom> http://www.vex.net/~trebla/weblog/declare-before-use.xhtml is my proof, at least of a related theorem.
2020-11-20 05:51:57 +0100 <monochrom> If it's just a few issues such as proper scoping standing in the way, we can make do with "fits this CFG plus has scoping requirements". Many authors do.
2020-11-20 05:52:11 +0100 <dolio> I worked on a project that tried to resolve variable scoping during parsing. I recommend not doing that.
2020-11-20 05:52:43 +0100 <monochrom> But dependent typing can have so many more unwiedly restrictions that you can't scale that style.
2020-11-20 05:53:07 +0100 <koz_> monochrom: That's a really cute proof using a technique I spent a lot of time with.
2020-11-20 05:53:18 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 05:53:21 +0100 <koz_> (our whole ToC class consisted of assignments pumping damn near everything)
2020-11-20 05:57:16 +0100 <dolio> Yeah. Now I remember almost nothing about that part. :)
2020-11-20 05:58:10 +0100 <koz_> dolio: One particularly gory (non-pumping) question was about CE languages.
2020-11-20 05:58:22 +0100 <koz_> Like, all the questions around CE-ness were unpleasant, honestly.
2020-11-20 06:02:32 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 06:04:32 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 06:04:56 +0100texasmynsted(~texasmyns@212.102.45.112) (Ping timeout: 240 seconds)
2020-11-20 06:07:35 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz)
2020-11-20 06:10:16 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz) (Client Quit)
2020-11-20 06:13:30 +0100hackageyi 0.19.0 - Yi editor https://hackage.haskell.org/package/yi-0.19.0 (TomMurphy)
2020-11-20 06:23:27 +0100day_(~Unknown@unaffiliated/day)
2020-11-20 06:23:45 +0100conal(~conal@ip-66-115-176-195.creativelink.net) (Quit: Computer has gone to sleep.)
2020-11-20 06:26:44 +0100day(~Unknown@unaffiliated/day) (Ping timeout: 260 seconds)
2020-11-20 06:26:44 +0100day_day
2020-11-20 06:28:04 +0100quarters(~quarters@38-73-246-124.starry-inc.net)
2020-11-20 06:31:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 06:31:41 +0100Sarma(~Amras@unaffiliated/amras0000) (Remote host closed the connection)
2020-11-20 06:35:17 +0100Amras(~Amras@unaffiliated/amras0000)
2020-11-20 06:35:34 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2020-11-20 06:38:57 +0100borne(~fritjof@200116b8640a4d0024e67d79d03c01ac.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-20 06:40:53 +0100borne(~fritjof@200116b86455d000feb15fd2865dc87d.dip.versatel-1u1.de)
2020-11-20 06:40:58 +0100Codaraxis_(~Codaraxis@ip68-5-90-227.oc.oc.cox.net) (Ping timeout: 260 seconds)
2020-11-20 06:42:14 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-11-20 06:42:52 +0100Rudd0(~Rudd0@185.189.115.108) (Ping timeout: 272 seconds)
2020-11-20 06:46:05 +0100alx741(~alx741@181.196.68.156) (Ping timeout: 240 seconds)
2020-11-20 06:47:07 +0100acidjnk_new2(~acidjnk@p200300d0c719ff356dc4eeabe79b61ea.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-20 06:47:12 +0100ggole(~ggole@2001:8003:8119:7200:3080:9a4e:22db:fd6d)
2020-11-20 06:47:22 +0100hooper(2fe3e53b@047-227-229-059.res.spectrum.com)
2020-11-20 06:50:01 +0100 <hooper> hi! i have a design question: so I want to have shapes like triangles and squares. they should both share some common attributes like having a number of sides and functions like computing the area, but would have different functions specific to each class as well
2020-11-20 06:50:05 +0100rekahsoft(~rekahsoft@fitz10681.telemetry.esentire.com) (Ping timeout: 260 seconds)
2020-11-20 06:50:08 +0100 <hooper> what is the best way to structure this?
2020-11-20 06:50:20 +0100 <hooper> I'm thinking a shape typeclass
2020-11-20 06:51:36 +0100 <hooper> but then not sure how to handle methods unique to one class
2020-11-20 06:51:39 +0100 <glguy> hooper, you can make a record like: data Polygon = Polygon { sides :: Int, Area :: Double, etc }
2020-11-20 06:52:22 +0100 <hooper> hm but i only want triangles and squares
2020-11-20 06:52:39 +0100 <glguy> OK, then: data Shape = Triangle | Square
2020-11-20 06:53:26 +0100 <hooper> so then lets say i declare like data Triangle = { a, b, c }
2020-11-20 06:53:35 +0100 <hooper> where a b c are Double type
2020-11-20 06:53:46 +0100 <hooper> how would I write an area function then
2020-11-20 06:54:40 +0100 <hooper> i need area to be polymorphic for square and triangle
2020-11-20 06:55:42 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 06:58:03 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2020-11-20 07:03:10 +0100SanchayanMaity(~Sanchayan@223.226.123.235)
2020-11-20 07:04:25 +0100luigy(~luigy@104.236.106.229) (Ping timeout: 240 seconds)
2020-11-20 07:05:25 +0100lukelau(~lukelau@46.101.13.214) (Quit: Bye)
2020-11-20 07:05:41 +0100lukelau(~lukelau@46.101.13.214)
2020-11-20 07:05:59 +0100AmrasSarma
2020-11-20 07:07:40 +0100 <dsal> hooper: what is the type of the area function?
2020-11-20 07:09:12 +0100luigy(~luigy@104.236.106.229)
2020-11-20 07:14:36 +0100zebrag(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2020-11-20 07:21:25 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Ping timeout: 240 seconds)
2020-11-20 07:22:37 +0100 <koz_> If you need a _closed_ set of shapes, your best bet as per glguy would be something like 'data Shape = Triangle Double Double Double | Square Double', then defining 'area :: Shape -> Double' and case-matching.
2020-11-20 07:23:07 +0100aarvar(~foewfoiew@50.35.43.33) (Ping timeout: 246 seconds)
2020-11-20 07:26:14 +0100 <koz_> If you need things that work for only one shape variety, you can either return Maybes, or you can do something like 'data Triangle = Triangle Double Double Double', 'data Square = Square Double', 'data Shape = ATriangle Triangle | ASquare Square', so then you can write functions that work only on triangles, only on squares, or on both.
2020-11-20 07:27:53 +0100ddellacosta(dd@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2020-11-20 07:29:17 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de)
2020-11-20 07:30:01 +0100wei2912(~wei2912@unaffiliated/wei2912)
2020-11-20 07:30:27 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Remote host closed the connection)
2020-11-20 07:30:53 +0100alx741(~alx741@181.196.68.156)
2020-11-20 07:31:00 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-11-20 07:31:44 +0100hooper(2fe3e53b@047-227-229-059.res.spectrum.com) (Ping timeout: 245 seconds)
2020-11-20 07:32:08 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2020-11-20 07:33:55 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Client Quit)
2020-11-20 07:34:14 +0100Fractalis(~Fractalis@2601:987:280:8d40:9de1:6445:b757:a1c4)
2020-11-20 07:34:35 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-11-20 07:34:51 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Client Quit)
2020-11-20 07:35:13 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-11-20 07:36:09 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz)
2020-11-20 07:36:48 +0100BarleyMo(2a02d45a@42-2-212-090.static.netvigator.com)
2020-11-20 07:38:16 +0100alp(~alp@2a01:e0a:58b:4920:954a:8bbd:83ff:d679)
2020-11-20 07:47:18 +0100nados(~dan@69-165-210-185.cable.teksavvy.com) (Quit: Leaving)
2020-11-20 07:47:30 +0100mi23523523(~Aman33333@85.253.192.47.cable.starman.ee)
2020-11-20 07:47:49 +0100mi23523523Kr23523523
2020-11-20 07:49:38 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 07:50:11 +0100DJWillis(~DJWillis@217.146.82.202) (Remote host closed the connection)
2020-11-20 07:53:01 +0100Kr23523523(~Aman33333@85.253.192.47.cable.starman.ee) (Quit: Leaving)
2020-11-20 07:54:23 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7958:7d8e:4908:c843) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 07:55:54 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2020-11-20 07:59:35 +0100quarters(~quarters@38-73-246-124.starry-inc.net) (Ping timeout: 256 seconds)
2020-11-20 08:01:25 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com) (Ping timeout: 264 seconds)
2020-11-20 08:01:32 +0100quarters(~quarters@38-73-246-124.starry-inc.net)
2020-11-20 08:01:50 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com)
2020-11-20 08:02:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 08:03:31 +0100electricityZZZZ(~electrici@108-216-157-17.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 265 seconds)
2020-11-20 08:04:26 +0100roconnor(~roconnor@host-104-157-230-3.dyn.295.ca) (Remote host closed the connection)
2020-11-20 08:04:51 +0100roconnor(~roconnor@host-104-157-230-3.dyn.295.ca)
2020-11-20 08:05:45 +0100quarters(~quarters@38-73-246-124.starry-inc.net) (Ping timeout: 240 seconds)
2020-11-20 08:06:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 08:09:30 +0100daim2k5(~daim2k5@185.204.1.185)
2020-11-20 08:09:53 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 260 seconds)
2020-11-20 08:10:34 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-20 08:18:20 +0100 <idnar> so I ran `cabal build` in my project and now if I run `cabal install` it wants to rebuild everything; how do I see why?
2020-11-20 08:18:21 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-11-20 08:18:55 +0100Varis(~Tadas@unaffiliated/varis)
2020-11-20 08:22:53 +0100mananamenos(~mananamen@84.122.202.215.dyn.user.ono.com)
2020-11-20 08:24:18 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16)
2020-11-20 08:25:05 +0100 <glguy> Install bundles up the source and does a build and install fresh from that sdist
2020-11-20 08:25:38 +0100 <glguy> It won't rebuild libraries installed from hackage though
2020-11-20 08:28:11 +0100vicfred_(~vicfred@unaffiliated/vicfred)
2020-11-20 08:28:26 +0100Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Read error: Connection reset by peer)
2020-11-20 08:29:56 +0100Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-11-20 08:30:01 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2020-11-20 08:30:25 +0100alp(~alp@2a01:e0a:58b:4920:954a:8bbd:83ff:d679) (Ping timeout: 272 seconds)
2020-11-20 08:31:04 +0100vicfred(~vicfred@unaffiliated/vicfred) (Ping timeout: 265 seconds)
2020-11-20 08:32:15 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Remote host closed the connection)
2020-11-20 08:32:34 +0100dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be)
2020-11-20 08:32:38 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2020-11-20 08:34:19 +0100plutoniix(~q@ppp-223-24-158-101.revip6.asianet.co.th)
2020-11-20 08:34:38 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de) (Quit: bitmagie)
2020-11-20 08:34:50 +0100borne(~fritjof@200116b86455d000feb15fd2865dc87d.dip.versatel-1u1.de) (Ping timeout: 264 seconds)
2020-11-20 08:35:28 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 08:38:56 +0100jespada(~jespada@90.254.245.49) (Ping timeout: 240 seconds)
2020-11-20 08:40:25 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 08:40:31 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 08:41:10 +0100Sgeo_(~Sgeo@ool-18b982ad.dyn.optonline.net) (Read error: Connection reset by peer)
2020-11-20 08:41:46 +0100jespada(~jespada@90.254.245.49)
2020-11-20 08:42:51 +0100 <Martinsos> glguy, hooper: While I would also probably go with the approach you described, what is argument against not going with the typeclass approach? I was doing something similar recently and I had really hard time making this decision, it was mostly about trying to guess how I might extend this code later. With data types, adding a new function should be simple, but that function needs to know internals of all the shapes and has to be
2020-11-20 08:42:51 +0100 <Martinsos> obviously in a separate module, so there is no encapsualtion there. Also, if I add a new shape, I have to modify all of these functions. With type class, I can have the `area` logic encapsualted together with the each shape, which sounds cool. If I add new shape, I don't need to modify any of the previous shapes or their logic. However if I add new method, I have to modify all of their type classes. Which actually sounds not so bad to
2020-11-20 08:42:51 +0100 <Martinsos> me. Ok, one thing I can't do it put all these shapes in an array together, since they are different types, but I could create another data type that is just a box for them `data Shape = ShapeSquare Square | ShapeTriangle Triangle` and then make it also an instance of `IsShape` type class and I solved that problem.
2020-11-20 08:44:18 +0100vilpan(~0@212.117.1.172)
2020-11-20 08:45:05 +0100 <Martinsos> If I am correct this is officially called "expression problem"?
2020-11-20 08:45:59 +0100 <Martinsos> I saw some solutions in Haskell for making it extendable in both types and functions direction, but all of them were pretty complicated and it seemed to me they were not really needed in pratice often. I would rather just go with simple, pragmatic solution that does not use complicated Haskell features, at least for the moment.
2020-11-20 08:46:16 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2020-11-20 08:47:05 +0100 <dminuoso> Martinsos: There's roughly two opposing properties of a language. Adding new operations and adding new data.
2020-11-20 08:48:28 +0100 <dminuoso> In Haskell it is easy to add new operations/functions for a data type, but like you put it, adding more constructors (that is extending the data type) is hard.
2020-11-20 08:51:54 +0100 <idnar> glguy: well, I'm seeing all the deps "needs build"; but if I rerun `cabal build` it doesn't build anything
2020-11-20 08:52:57 +0100 <idnar> glguy: my guess is some flag like --enable-tests is changing
2020-11-20 08:54:04 +0100 <idnar> err, "requires build"
2020-11-20 08:56:16 +0100zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2020-11-20 08:56:43 +0100raichoo(~raichoo@213.240.178.58)
2020-11-20 08:59:35 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-20 09:04:32 +0100zaquest(~notzaques@5.128.210.178)
2020-11-20 09:08:17 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 265 seconds)
2020-11-20 09:09:18 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 09:09:24 +0100hyiltiz(~quassel@unaffiliated/hyiltiz) (Quit: hyiltiz)
2020-11-20 09:09:26 +0100cfricke(~cfricke@unaffiliated/cfricke)
2020-11-20 09:09:58 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 09:10:02 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 09:11:32 +0100hexfive(~hexfive@50-47-142-195.evrt.wa.frontiernet.net) (Quit: i must go. my people need me.)
2020-11-20 09:11:53 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 09:12:17 +0100chele(~chele@ip5b416ea2.dynamic.kabel-deutschland.de)
2020-11-20 09:12:55 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 09:13:15 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 09:13:19 +0100alp(~alp@2a01:e0a:58b:4920:c533:3fa3:3963:3f02)
2020-11-20 09:13:32 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 09:14:41 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com) (Remote host closed the connection)
2020-11-20 09:14:44 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 09:14:58 +0100plutoniix(~q@ppp-223-24-158-101.revip6.asianet.co.th) (Ping timeout: 260 seconds)
2020-11-20 09:15:30 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-11-20 09:16:36 +0100mikevdg(73bd5248@115-189-82-72.mobile.spark.co.nz)
2020-11-20 09:17:36 +0100 <mikevdg> I've got a Monad question regarding https://github.com/opqdonut/haskell-exercises/blob/master/templ/W6B.hs
2020-11-20 09:17:50 +0100 <mikevdg> Excuse the CCPP stuff in that file. Line 676
2020-11-20 09:17:55 +0100 <mikevdg> *CPP
2020-11-20 09:18:24 +0100 <mikevdg> you have `where g state = let (v, state1, log) = runSL op state0`
2020-11-20 09:18:48 +0100 <mikevdg> How is that possible? How can you say `where f x = ...` if x doesn't have a value?
2020-11-20 09:19:05 +0100 <mikevdg> I understand you can do it for pattern matching with tuples and lists. (a, b) = f x...
2020-11-20 09:19:17 +0100 <mikevdg> But is that possible with functions too?
2020-11-20 09:19:40 +0100 <mikevdg> (g is (Int -> (a, Int, [String])
2020-11-20 09:21:13 +0100drbean(~drbean@TC210-63-209-219.static.apol.com.tw) (Ping timeout: 264 seconds)
2020-11-20 09:22:57 +0100 <koz_> mikevdg: 'where g state = ...' is basically 'where g = \state -> ...'.
2020-11-20 09:23:02 +0100 <koz_> Is that what threw you?
2020-11-20 09:23:08 +0100 <merijn> mikevdg: That's just defining a function
2020-11-20 09:23:21 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 09:23:23 +0100 <mikevdg> I've been staring at this exercise for an hour.
2020-11-20 09:23:51 +0100 <merijn> "where f x = ..." is just "defining a local function 'f' with a single argument 'x'"
2020-11-20 09:24:08 +0100 <mikevdg> yea, that makes sense now. Now that I think about it, I do it all the time.
2020-11-20 09:24:13 +0100 <mikevdg> double x = x * x
2020-11-20 09:24:29 +0100 <koz_> mikevdg: Yeah - you can write that as 'double = \x -> x * x'
2020-11-20 09:24:35 +0100 <mikevdg> f x = ... where f is some anonymous function... same pattern.
2020-11-20 09:24:57 +0100 <mikevdg> well... it's not anonymous if you call it f.
2020-11-20 09:25:02 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com)
2020-11-20 09:25:22 +0100 <mikevdg> foo = MyMonad f where f arg = ...
2020-11-20 09:26:54 +0100 <mikevdg> It threw me because I was defining a function that was being used as a variable.
2020-11-20 09:27:18 +0100plutoniix(~q@node-ufe.pool-125-24.dynamic.totinternet.net)
2020-11-20 09:27:20 +0100Fractalis(~Fractalis@2601:987:280:8d40:9de1:6445:b757:a1c4) (Quit: Leaving)
2020-11-20 09:28:29 +0100 <mikevdg> you guys are awesome.
2020-11-20 09:28:42 +0100 <koz_> mikevdg: We try.
2020-11-20 09:31:51 +0100borne(~fritjof@200116b86455d000f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-20 09:31:52 +0100 <opqdonut> mikevdg: I hope you like the exercises! Check out https://haskell.mooc.fi which is based on the same exercises, but also contains reading material
2020-11-20 09:32:09 +0100 <merijn> mikevdg: Well, technically it *is* defining a variable. It's just a variable that happens to be a function :)
2020-11-20 09:32:13 +0100 <mikevdg> hey, it's the author! Sure, will do.
2020-11-20 09:32:15 +0100 <opqdonut> mikevdg: part 1 is out, but it doesn't cover monads, part 2 will come soon(tm)
2020-11-20 09:33:11 +0100 <guest1120> what's diffrent with <|> and >> ?
2020-11-20 09:33:19 +0100 <merijn> guest1120: Eh, lots :p
2020-11-20 09:33:30 +0100 <guest1120> simply?
2020-11-20 09:33:47 +0100 <[exa]> guest1120: if you asked for *> and >> the answer would be simple, but <|> and >> differ even in type signature
2020-11-20 09:33:49 +0100 <koz_> :t (<|>)
2020-11-20 09:33:50 +0100 <lambdabot> Alternative f => f a -> f a -> f a
2020-11-20 09:33:54 +0100 <koz_> :t (>>)
2020-11-20 09:33:55 +0100 <lambdabot> Monad m => m a -> m b -> m b
2020-11-20 09:33:58 +0100 <koz_> Simply. :P
2020-11-20 09:33:58 +0100 <merijn> guest1120: <|> is a choice combinator, exact meaning but in, for example, parsers it's usually "left *or* right"
2020-11-20 09:33:59 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 09:34:25 +0100 <merijn> > Just 2 <|> Just 3
2020-11-20 09:34:27 +0100 <lambdabot> Just 2
2020-11-20 09:34:34 +0100 <merijn> > Nothing <|> Just 3
2020-11-20 09:34:36 +0100 <lambdabot> Just 3
2020-11-20 09:34:40 +0100 <merijn> > Just 2 >> Just 3
2020-11-20 09:34:42 +0100 <lambdabot> Just 3
2020-11-20 09:34:46 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 09:34:46 +0100 <guest1120> ok
2020-11-20 09:34:46 +0100 <merijn> > Nothing >> Just 3
2020-11-20 09:34:48 +0100 <lambdabot> Nothing
2020-11-20 09:34:58 +0100 <dminuoso> guest1120: Note that the "or" should be taken with a grain of salt.
2020-11-20 09:35:00 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2020-11-20 09:36:55 +0100 <merijn> Yes
2020-11-20 09:37:03 +0100 <merijn> > [1,2] >> [3,4]
2020-11-20 09:37:05 +0100 <lambdabot> [3,4,3,4]
2020-11-20 09:37:10 +0100 <merijn> > [1,2] <|> [3,4]
2020-11-20 09:37:12 +0100 <lambdabot> [1,2,3,4]
2020-11-20 09:37:29 +0100 <guest1120> what?
2020-11-20 09:37:32 +0100 <koz_> merijn: I had never considered >> in a list context before.
2020-11-20 09:38:11 +0100 <merijn> koz_: :)
2020-11-20 09:38:15 +0100 <dminuoso> guest1120: Roughly, if you build a parser: `string "foobar" <|> string "fooquux"` and throw it against "fooquux" then depending on the parser library it might not parse.
2020-11-20 09:38:41 +0100 <koz_> Like, upon thought it makes sense, but I guess I hardly ever use lists for their monad properties.
2020-11-20 09:39:02 +0100 <merijn> guest1120: Alternative has <|> and empty, with the definition that "<|> is associative" and "empty is the left and right identity for <|>" so "x <|> empty = x = empty <|> x"
2020-11-20 09:39:07 +0100christo(~chris@81.96.113.213)
2020-11-20 09:40:23 +0100 <merijn> guest1120: The exact meaning of the associative operation depends on the instance. For parsers it's usually "try left, then on failure try right", and empty is "a failing parser", but for lists it's "concatenate" with empty being the empty list
2020-11-20 09:42:22 +0100mikevdgreads about Data.Semigroup
2020-11-20 09:42:56 +0100 <merijn> Semigroups are great, we should to more of those :D
2020-11-20 09:43:41 +0100 <guest1120> dminuoso: merijn to combinate parsers, >> or <|> I should use?
2020-11-20 09:43:45 +0100 <guest1120> I'm confused now
2020-11-20 09:43:59 +0100 <tdammers> merijn: I propose adding that to the Zen Of Python, just to mess with Python cultists
2020-11-20 09:44:02 +0100 <guest1120> parse (spaces >> symbol) "lisp" input
2020-11-20 09:44:07 +0100 <merijn> guest1120: Well, that depends on what you want :)
2020-11-20 09:44:22 +0100 <guest1120> parseExpr = parseAtom <|> parseString
2020-11-20 09:44:25 +0100 <merijn> guest1120: "a >> b" is "a, then b", "a <|> b" is "a or b"
2020-11-20 09:44:38 +0100 <merijn> tdammers: :)
2020-11-20 09:44:50 +0100 <merijn> tdammers: I have more important business
2020-11-20 09:45:02 +0100 <guest1120> merijn: ok
2020-11-20 09:45:12 +0100 <tdammers> merijn: yeah, but would be fun, wouldn't it
2020-11-20 09:45:13 +0100 <merijn> tdammers: Like, figure out a good name for "Monoid m => Bool -> m -> m" so I can *finally* get it into base
2020-11-20 09:45:16 +0100 <[exa]> the kids today don't even start their first python tutorial with `import this`.
2020-11-20 09:45:41 +0100 <mikevdg> import turtle;
2020-11-20 09:45:57 +0100 <tdammers> [exa]: just yesterday I've seen someone argue that "oneThing if condition else otherThing" is great syntax
2020-11-20 09:46:02 +0100 <kritzefitz> merijn, That type doesn't seem familiar to me. What would that operator do?
2020-11-20 09:46:03 +0100 <merijn> tdammers: I'm using mif in my code now, but I'm not happy with it
2020-11-20 09:46:25 +0100 <merijn> kritzefitz: "\b x -> if b then x else mempty"
2020-11-20 09:46:31 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk)
2020-11-20 09:46:41 +0100 <merijn> kritzefitz: It's amazing how astonishingly useful that is
2020-11-20 09:46:45 +0100 <tdammers> if anything, I'd go with mwhen rather than mif
2020-11-20 09:46:48 +0100 <guest1120> lex, happy, parsec, they're same?
2020-11-20 09:47:09 +0100 <tdammers> mif suggests Monoid m => Bool -> m -> m -> m, or maybe even Monoid m => Bool -> m -> m -> m -> m
2020-11-20 09:47:16 +0100 <merijn> tdammers: Yeah, but that leads to confusion with monad's and whenM, etc.
2020-11-20 09:47:37 +0100 <tdammers> it's very similar to when from Control.Monad though, isn't it
2020-11-20 09:48:04 +0100 <merijn> yeah
2020-11-20 09:48:12 +0100Yumasi(~guillaume@2a01cb09b06b29eabd8cf63c98e88a0f.ipv6.abo.wanadoo.fr)
2020-11-20 09:48:15 +0100 <tdammers> in fact, if Monad could have the Monoid instance it deserves, it would be the exact same thing
2020-11-20 09:48:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 09:49:15 +0100hyiltiz(~quassel@82.118.227.47)
2020-11-20 09:49:15 +0100hyiltiz(~quassel@82.118.227.47) (Changing host)
2020-11-20 09:49:15 +0100hyiltiz(~quassel@unaffiliated/hyiltiz)
2020-11-20 09:49:32 +0100 <dminuoso> guest1120: Presumably by lex you meant alex?
2020-11-20 09:49:46 +0100 <dminuoso> guest1120: At any rate, they are all parsing/lexing libraries but with different ergonomics and properties.
2020-11-20 09:50:03 +0100 <guest1120> dminuoso: which one is easier?
2020-11-20 09:50:22 +0100 <dminuoso> "easier" is hard to answer in general
2020-11-20 09:50:23 +0100 <merijn> kritzefitz: Some example uses: https://github.com/haskell/cabal/blob/master/Cabal/src/Distribution/Simple/Program/GHC.hs#L203-L209 also note that from/to in the surrounding code https://github.com/haskell/cabal/blob/master/Cabal/src/Distribution/Simple/Program/GHC.hs#L174-L199 are just slightly specialised versions of that function
2020-11-20 09:50:48 +0100 <guest1120> I'm learing parsec by write yourself a scheme with 48 hours
2020-11-20 09:50:52 +0100 <merijn> kritzefitz: It's great for selectively including bits and pieces in complex compound structures
2020-11-20 09:50:58 +0100 <guest1120> but some codes are old
2020-11-20 09:50:59 +0100 <dminuoso> But `megaparsec` is a safe default for a parsing library
2020-11-20 09:51:22 +0100plutoniix(~q@node-ufe.pool-125-24.dynamic.totinternet.net) (Quit: Leaving)
2020-11-20 09:51:26 +0100 <dminuoso> That is, if you want a tl;dr for "which parsing library should I use", you generally cant go wrong with megaparsec.
2020-11-20 09:51:44 +0100 <tdammers> also megaparsec > parsec in 99.9% of cases these days
2020-11-20 09:52:08 +0100 <guest1120> but parsec comes with ghc?
2020-11-20 09:52:20 +0100 <tdammers> does it? I don't think it does
2020-11-20 09:52:28 +0100 <koz_> tdammers: Isn't parsec a boot library?
2020-11-20 09:52:41 +0100 <tdammers> I thought it wasn't, but maybe it is by now
2020-11-20 09:52:53 +0100 <guest1120> Text.Parsec?
2020-11-20 09:53:03 +0100 <kritzefitz> merijn, It does seem useful. But I just realised thta I rarely use a lot of Monoids and now I'm wondering if I'm missing out.
2020-11-20 09:53:18 +0100 <koz_> kritzefitz: You definitely are.
2020-11-20 09:53:28 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-11-20 09:53:35 +0100 <koz_> You can get a remarkable range of behaviour out of foldMap by varying up your Monoids.
2020-11-20 09:54:08 +0100 <dminuoso> guest1120: The boot libraries should not be a relevant factor for what you should use.
2020-11-20 09:54:24 +0100 <merijn> kritzefitz: You are :p
2020-11-20 09:54:29 +0100 <dminuoso> The fact that GHC comes with them is not for your convenience.
2020-11-20 09:54:45 +0100 <merijn> kritzefitz: Note that the entire surrounding 150-200 lines of code I just linked is basically all composing a bunch of monoids together :p
2020-11-20 09:55:07 +0100 <mikevdg> Haskell: A new way to break your brain every day. `mempty :: Sum Int` --> Sum {getSum = 0}
2020-11-20 09:55:45 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-itluyvgbrrzsqlpm) (Quit: Connection closed for inactivity)
2020-11-20 09:56:10 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 09:56:15 +0100 <merijn> mikevdg: Don't forget Dual
2020-11-20 09:56:18 +0100 <guest1120> ok
2020-11-20 09:56:28 +0100 <mikevdg> merijn: Dual?
2020-11-20 09:56:28 +0100 <dminuoso> Mmm, why exactly does GHC ship with these boot packages at all? Is ghc linked dynamically?
2020-11-20 09:56:40 +0100 <mikevdg> :t Dual
2020-11-20 09:56:41 +0100 <lambdabot> a -> Dual a
2020-11-20 09:56:47 +0100 <koz_> dminuoso: I think they're needed to build GHC itself?
2020-11-20 09:57:02 +0100 <mikevdg> Is there a thing in, e.g. ghci, to also get a bit of documentation on a type?
2020-11-20 09:57:04 +0100 <koz_> There's also Down.
2020-11-20 09:57:09 +0100 <merijn> mikevdg: "newtype Dual a = Dual a" where "mempty = Dual mempty" and "mappend (Dual x) (Dual y) = Dual (mappend y x)"
2020-11-20 09:57:09 +0100 <koz_> @hoogle Dual
2020-11-20 09:57:10 +0100 <lambdabot> Data.Monoid newtype Dual a
2020-11-20 09:57:10 +0100 <lambdabot> Data.Monoid Dual :: a -> Dual a
2020-11-20 09:57:10 +0100 <lambdabot> Data.Semigroup newtype Dual a
2020-11-20 09:57:10 +0100 <kritzefitz> The first thing that comes to minds, when I think about monoids, is that WriterT uses Monoids for the written things. So if I want to collect elements into a list it degrades (:) to (++) and that bother me. But I guess I'm just thinking about this the wrong way.
2020-11-20 09:57:13 +0100 <mikevdg> Or do I have to go to Hoogle?
2020-11-20 09:57:28 +0100 <merijn> > [1,2,3] <> [4,5,6]
2020-11-20 09:57:30 +0100 <lambdabot> [1,2,3,4,5,6]
2020-11-20 09:57:34 +0100 <merijn> > Dual [1,2,3] <> Dual [4,5,6]
2020-11-20 09:57:37 +0100 <lambdabot> Dual {getDual = [4,5,6,1,2,3]}
2020-11-20 09:57:41 +0100 <koz_> :D
2020-11-20 09:57:56 +0100 <koz_> Another cool Monoid: Ordering.
2020-11-20 09:58:00 +0100 <merijn> kritzefitz: There's more monoids than lists, though
2020-11-20 09:58:11 +0100 <merijn> koz_: You're forgetting the *best* Monoid
2020-11-20 09:58:15 +0100 <koz_> Lists are actually a very uninteresting monoid.
2020-11-20 09:58:18 +0100 <dminuoso> koz_: Oh mmm. I was somehow under the impression that a GHC installation somehow came with these packages
2020-11-20 09:58:22 +0100 <koz_> merijn: (Monoid b) => a -> b?
2020-11-20 09:58:29 +0100 <merijn> koz_: Of course
2020-11-20 09:58:56 +0100 <koz_> newtype MonoidInjection a b :P
2020-11-20 09:59:02 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 09:59:12 +0100 <guest1120> why there're <> and ++ two ways to do the same thing?
2020-11-20 09:59:24 +0100 <merijn> :t (++)
2020-11-20 09:59:25 +0100 <dminuoso> guest1120: (<>) is more general than ++
2020-11-20 09:59:25 +0100 <lambdabot> [a] -> [a] -> [a]
2020-11-20 09:59:27 +0100 <kritzefitz> merijn, sure there are. But I guess I'm missing the familiarity with Monoids to recognize when their properties would actually be useful to me.
2020-11-20 09:59:29 +0100 <merijn> :t (<>)
2020-11-20 09:59:29 +0100 <koz_> guest1120: (++) is list-only, while <> will work for any Semigroup.
2020-11-20 09:59:30 +0100 <lambdabot> Semigroup a => a -> a -> a
2020-11-20 09:59:40 +0100 <Martinsos> dminuoso: So specifically for that example with shapes, which one do you think is a better approach? Data types or type classes? And why?
2020-11-20 10:00:00 +0100 <merijn> kritzefitz: Note that the monoid that koz_ mentioned "instance Monoid m => Monoid (r -> m)" applies recursively :)
2020-11-20 10:00:05 +0100micahsovereign[m(micahsover@gateway/shell/matrix.org/x-pdyvnptozmxbustx) (Quit: Idle for 30+ days)
2020-11-20 10:00:08 +0100hnOsmium0001[m](hnosmium00@gateway/shell/matrix.org/x-uzbrsqhjgvjvnext) (Quit: Idle for 30+ days)
2020-11-20 10:00:09 +0100 <merijn> :t comparing fst
2020-11-20 10:00:10 +0100 <lambdabot> Ord a => (a, b) -> (a, b) -> Ordering
2020-11-20 10:00:20 +0100 <merijn> :t comparing snd <> comparing fst
2020-11-20 10:00:22 +0100 <lambdabot> (Ord a1, Ord a2) => (a2, a1) -> (a2, a1) -> Ordering
2020-11-20 10:00:27 +0100 <dminuoso> Martinsos: It's hard to say with that little information.
2020-11-20 10:00:34 +0100 <koz_> It's quite context-specific.
2020-11-20 10:01:06 +0100 <merijn> > sortBy (comparing fst) [(1,2), (2,2), (1,1), (2,1)]
2020-11-20 10:01:08 +0100 <lambdabot> [(1,2),(1,1),(2,2),(2,1)]
2020-11-20 10:01:19 +0100 <Martinsos> dminuoso: you mean to say it depends on which extension is important for us, what we might need in the future?
2020-11-20 10:01:30 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-20 10:01:40 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-11-20 10:01:47 +0100 <merijn> > sortBy (comparing snd) [(1,2), (2,2), (1,1), (2,1)]
2020-11-20 10:01:47 +0100 <merijn> > sortBy (comparing <> comparing snd) [(1,2), (2,2), (1,1), (2,1)]
2020-11-20 10:01:47 +0100 <merijn> eh, whoops
2020-11-20 10:01:47 +0100 <merijn> > sortBy (comparing fst <> comparing snd) [(1,2), (2,2), (1,1), (2,1)]
2020-11-20 10:01:50 +0100 <lambdabot> [(1,1),(1,2),(2,1),(2,2)]
2020-11-20 10:01:50 +0100 <lambdabot> [(1,1),(2,1),(1,2),(2,2)]
2020-11-20 10:01:50 +0100 <lambdabot> error:
2020-11-20 10:01:50 +0100 <lambdabot> • Couldn't match type ‘(a, a1) -> Ordering’ with ‘Ordering’
2020-11-20 10:01:50 +0100 <lambdabot> Expected type: (a, a1) -> (a, a1) -> Ordering
2020-11-20 10:01:58 +0100 <dminuoso> Martinsos: In general, if you want something extensible covering the expression problem, then tagless final or datatypes a la carte are common approaches in Haskell
2020-11-20 10:02:15 +0100 <merijn> > sortBy (comparing snd <> comparing fst) [(1,2), (2,2), (1,1), (2,1)]
2020-11-20 10:02:17 +0100 <lambdabot> [(1,1),(2,1),(1,2),(2,2)]
2020-11-20 10:02:22 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-20 10:02:28 +0100 <koz_> Those are _very_ nuclear hammers.
2020-11-20 10:03:19 +0100 <Martinsos> dminuoso: hmmm thanks, I will have to investigate those! I think I was reading datatypes a la carte but concluded I don't need that complexity right now. I guess what I am wondering, when somebody asks "should I do this with data types or type classes", and information is relatively simple (like that example with shapes), what is the correct answer? Probably: do it with data types since that is the simplest / least code, and let's see
2020-11-20 10:03:19 +0100 <Martinsos> how it evolves?
2020-11-20 10:03:41 +0100 <merijn> kritzefitz: Note how the monoid for functions lets you monoidally combine functions, regardless of number of arguments, which is especially neat with Ordering allowing for arbitrarily complex sorting criteria
2020-11-20 10:04:24 +0100 <dminuoso> Martinsos: So Im in a similar spot, I've solved the expression problem in this particular project with "have a code generator" and if people want to extend my data type, they have to make a PR and Ill rerun the code generator. :p
2020-11-20 10:04:24 +0100Chi1thangoo(~Chi1thang@87.112.60.168)
2020-11-20 10:04:51 +0100 <dminuoso> For this particular project.
2020-11-20 10:04:52 +0100 <kritzefitz> merijn, indeed, that is a very nice Monoid. I wasn't aware it existed.
2020-11-20 10:05:02 +0100 <dminuoso> There is no correct answer really
2020-11-20 10:05:13 +0100 <dminuoso> But roughly I'd avoid typeclasses if you are not sure they will help you
2020-11-20 10:05:32 +0100 <dminuoso> Often, the expression problem is not as bad as it seems
2020-11-20 10:06:00 +0100Feuermagier(~Feuermagi@213.178.26.41)
2020-11-20 10:06:22 +0100comerijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 10:07:13 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk) (Remote host closed the connection)
2020-11-20 10:07:33 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk)
2020-11-20 10:07:57 +0100 <Martinsos> dminuoso: thanks! I think that sounds like a good rule, avoid typeclass if not needed, and in most cases the problem will not actually be problematic. Cool, thank you
2020-11-20 10:08:12 +0100 <koz_> Yeah - the reality is that All The Extensibility All The Time isn't helpful, and in some cases, it'll even slow you down.
2020-11-20 10:08:17 +0100ph88(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b)
2020-11-20 10:08:19 +0100 <koz_> Over-generalizing early can be pretty bad.
2020-11-20 10:08:32 +0100 <hololeap> is Show1 derivable in GHC 8.8.4?
2020-11-20 10:08:38 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2020-11-20 10:08:52 +0100 <koz_> hololeap: I don't think *1 is derivable for any * in any version?
2020-11-20 10:08:56 +0100 <[exa]> kritzefitz: btw, my favorite example with function semigroup is `rotList = drop <> take` (even with multiple parameters)
2020-11-20 10:09:09 +0100acidjnk_new2(~acidjnk@p200300d0c719ff35956387e811e01df5.dip0.t-ipconnect.de)
2020-11-20 10:09:15 +0100 <dminuoso> [exa]: That example was pretty cool :)
2020-11-20 10:09:34 +0100 <koz_> kritzefitz: For a recent Real Job For Real Money example from me - I used Monoid to implement 'find exactly one' with error handling.
2020-11-20 10:09:42 +0100 <hololeap> koz_, ok i ask because it is listed here: https://github.com/haskell-compat/deriving-compat
2020-11-20 10:09:47 +0100comerijnmerijn
2020-11-20 10:09:52 +0100BarleyMo(2a02d45a@42-2-212-090.static.netvigator.com) (Remote host closed the connection)
2020-11-20 10:09:57 +0100 <hololeap> "Provides Template Haskell functions that mimic deriving extensions that were introduced or modified in recent versions of GHC."
2020-11-20 10:10:08 +0100supercoven(~Supercove@dsl-hkibng31-54fae2-36.dhcp.inet.fi)
2020-11-20 10:10:13 +0100 <koz_> The Monoid in question is something like 'data FindExactlyOne a = NoneFound | OneFound a | TooManyFound'.
2020-11-20 10:10:20 +0100Kaeipi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-11-20 10:10:26 +0100Merfont(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-11-20 10:10:38 +0100 <koz_> (the instances of Semigroup and Monoid are left as an exercise to the reader)
2020-11-20 10:11:03 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 240 seconds)
2020-11-20 10:12:01 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-20 10:12:17 +0100 <merijn> the more you use Semigroup/Monoid/foldMap, the more use you see for them :)
2020-11-20 10:12:25 +0100cfricke(~cfricke@unaffiliated/cfricke)
2020-11-20 10:12:29 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-20 10:12:40 +0100 <koz_> Realistically, it's {M,m}onoids all the way down?
2020-11-20 10:12:40 +0100 <merijn> koz_: Did you see the glorious addition of foldMap' ? (*finally*)
2020-11-20 10:12:46 +0100 <koz_> merijn: Where?
2020-11-20 10:12:46 +0100 <kritzefitz> koz_, I think I remember having a similar problem. Now I realize that, semantically I also implemented a Monoid but didn't really use the typeclass for that. So I guess those are the kinds of opportunities I should look out for.
2020-11-20 10:12:52 +0100 <merijn> koz_: In base :)
2020-11-20 10:12:57 +0100 <koz_> kritzefitz: It gets easier with practice.
2020-11-20 10:13:05 +0100 <koz_> merijn: No I did not. Indeed, *finally*.
2020-11-20 10:13:06 +0100 <mikevdg> opqdonut: I've just read through some parts of your MOOC. If I earn 5 ECTS, what can I use them for?
2020-11-20 10:13:07 +0100 <merijn> koz_: GHC 8.8 or 8.10 added it?
2020-11-20 10:13:28 +0100 <koz_> hololeap: I wasn't aware *1 could be derived automagically at all.
2020-11-20 10:14:16 +0100 <hololeap> well, deriving Show1 with that GHC version not working for me
2020-11-20 10:14:19 +0100 <mikevdg> opqdonut: and is there a fancy certificate at the end? :-)
2020-11-20 10:14:39 +0100 <koz_> hololeap: I don't even know how it would work with any version. I'm pretty sure that's not stock derivable at least.
2020-11-20 10:14:40 +0100jess(jess@freenode/staff/jess)
2020-11-20 10:17:01 +0100benjamingr__(uid23465@gateway/web/irccloud.com/x-fmpqsizgoykkkpyq)
2020-11-20 10:17:53 +0100 <idnar> :t foldMap'
2020-11-20 10:17:54 +0100 <lambdabot> (Foldable t, Monoid m) => (a -> m) -> t a -> m
2020-11-20 10:18:03 +0100 <idnar> :t foldMap
2020-11-20 10:18:04 +0100 <lambdabot> (Foldable t, Monoid m) => (a -> m) -> t a -> m
2020-11-20 10:18:12 +0100 <idnar> wut
2020-11-20 10:18:17 +0100 <koz_> idnar: The type sig won't tell you the difference.
2020-11-20 10:18:23 +0100 <merijn> idnar: foldMap' is strict
2020-11-20 10:18:59 +0100 <idnar> ohhh right, I was thinking foldMap_
2020-11-20 10:19:10 +0100 <dminuoso> Also, foldMap' by default associates differently internaly
2020-11-20 10:19:14 +0100 <dminuoso> By default
2020-11-20 10:19:25 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2020-11-20 10:19:27 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 10:19:30 +0100 <merijn> koz_: Now I just need a strict tuple to go with that :p
2020-11-20 10:20:26 +0100 <kritzefitz> Strict tuples would be so great.
2020-11-20 10:20:42 +0100 <koz_> merijn: So like, 'data StrictTuple a b = StrictTuple !a !b'?
2020-11-20 10:21:27 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 10:22:09 +0100 <kritzefitz> I guess you could use it to break the internals of lots of types, but it seems like it could be nice, if you could provide strictness as part of type parameters.
2020-11-20 10:23:01 +0100 <kritzefitz> e.g. `[!Int]` would be a list, where the elements would be evaluated with the spine.
2020-11-20 10:24:33 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 10:24:42 +0100Merfont(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Remote host closed the connection)
2020-11-20 10:25:01 +0100Merfont(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-11-20 10:25:20 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 10:26:47 +0100cloudster(~cloudster@124.123.105.47)
2020-11-20 10:27:24 +0100pavonia(~user@unaffiliated/siracusa) (Quit: Bye!)
2020-11-20 10:27:26 +0100mikevdg(73bd5248@115-189-82-72.mobile.spark.co.nz) (Remote host closed the connection)
2020-11-20 10:28:03 +0100Chi1thangoo(~Chi1thang@87.112.60.168) (Ping timeout: 256 seconds)
2020-11-20 10:29:04 +0100thc202(~thc202@unaffiliated/thc202)
2020-11-20 10:29:58 +0100 <dminuoso> kritzefitz: Indeed it would be cool, we could then write strictness polymorphic code akin to levity polymorphism.
2020-11-20 10:30:19 +0100christo(~chris@81.96.113.213)
2020-11-20 10:30:25 +0100 <merijn> dminuoso: I've already floated that idea a bunch of times :p
2020-11-20 10:30:34 +0100cloudster(~cloudster@124.123.105.47) (Remote host closed the connection)
2020-11-20 10:30:48 +0100 <dminuoso> Any plans after your M.Sc? :>
2020-11-20 10:30:55 +0100 <dminuoso> Seems like the perfect PhD thesis.
2020-11-20 10:30:57 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com) (Remote host closed the connection)
2020-11-20 10:31:08 +0100 <merijn> dminuoso: My M.Sc. was finished literal *years* ago
2020-11-20 10:31:11 +0100 <dminuoso> Oh
2020-11-20 10:31:14 +0100 <dminuoso> Hold on
2020-11-20 10:31:33 +0100 <merijn> It's my PhD thesis I'm procrastinating on :p
2020-11-20 10:32:03 +0100 <dminuoso> Well, what about a second PhD then!
2020-11-20 10:32:08 +0100 <merijn> hah
2020-11-20 10:32:10 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 10:32:12 +0100 <merijn> never >.>
2020-11-20 10:32:37 +0100dminuosowonders whether a second doctor entitles you to being called "Doctor Doctor"
2020-11-20 10:32:47 +0100 <koz_> dminuoso: Doctor Squared.
2020-11-20 10:32:55 +0100 <dminuoso> heh
2020-11-20 10:32:56 +0100 <merijn> I'm already drs. :p
2020-11-20 10:33:14 +0100 <dminuoso> merijn: This is honestly so confusing. Why are you already dr?
2020-11-20 10:33:21 +0100 <merijn> Which sadly, is not the plural of dr
2020-11-20 10:33:25 +0100 <dminuoso> oh
2020-11-20 10:33:27 +0100 <dminuoso> haha
2020-11-20 10:33:29 +0100 <dminuoso> what is drs then?
2020-11-20 10:33:51 +0100 <merijn> dminuoso: drs is doctorandus, it's roughly equivalent to MSc. from the time before EU standardized on bachelor/master
2020-11-20 10:34:07 +0100 <dminuoso> Ah, presumably its similar to Dipl. in Germany
2020-11-20 10:34:19 +0100vsiddharth(~user@135-180-144-154.fiber.dynamic.sonic.net)
2020-11-20 10:34:29 +0100 <merijn> But since I started university before that switch I'm entitled to use either drs or MSc. as I see fit
2020-11-20 10:34:38 +0100 <pjb> dminuoso: IMO, doctor titles sum, not multiply.
2020-11-20 10:34:49 +0100 <merijn> Anyway
2020-11-20 10:35:08 +0100 <merijn> Only morons do a phd, I'm not sure what kinda idiot you gotta be to do *two* of the damn things
2020-11-20 10:35:37 +0100 <dminuoso> pjb: addition/multiplication are relative. In fact, there are fields in math in which b^2 and 2*b denote the same thing
2020-11-20 10:35:46 +0100 <merijn> otoh, if your dumb and stubborn enough to start a 2nd phd, I guess you'd be dumb and stubborn enough to make it
2020-11-20 10:35:52 +0100 <pjb> merijn: when you want to advance two fields. For example, Elon Musk could be doctor in car batteries, and doctor in rocket engines.
2020-11-20 10:35:53 +0100 <merijn> s/your/you're
2020-11-20 10:36:18 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 10:36:38 +0100 <dminuoso> pjb: PhDs dont advance you.
2020-11-20 10:36:56 +0100 <pjb> merijn: no, it advances science.
2020-11-20 10:37:00 +0100 <merijn> hah
2020-11-20 10:37:03 +0100 <dminuoso> "advances science"
2020-11-20 10:37:07 +0100 <merijn> I like your optimism :)
2020-11-20 10:37:32 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-11-20 10:37:32 +0100hiroaki(~hiroaki@ip4d168e73.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2020-11-20 10:38:05 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Remote host closed the connection)
2020-11-20 10:38:16 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 240 seconds)
2020-11-20 10:38:42 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 10:39:03 +0100 <dminuoso> Much of academia follows "publication creep" where you're pushed to publish as often as possible in magazines with high impact factors.
2020-11-20 10:39:16 +0100 <dminuoso> The primary motivation is not science, it's just money.
2020-11-20 10:40:08 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 10:40:21 +0100 <dminuoso> It's getting increasingly difficult to filter out the useless, irrelevant or (semi-)plagiarized publications if you want to do some work in a field
2020-11-20 10:40:23 +0100avoandmayo(~textual@122-58-109-105-adsl.sparkbb.co.nz) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 10:40:30 +0100hackageZ-IO 0.1.8.0 - Simple and high performance IO toolkit for Haskell https://hackage.haskell.org/package/Z-IO-0.1.8.0 (winterland)
2020-11-20 10:40:40 +0100 <merijn> dminuoso: Oh, I got a simple hack for that
2020-11-20 10:41:04 +0100 <merijn> dminuoso: I just assume it's irrelevant and don't read it ;)
2020-11-20 10:42:55 +0100 <hololeap> the TH generated Show1 instance from deriving-compat seems to work fine
2020-11-20 10:43:52 +0100 <hololeap> although i have to put the `$(deriveShow1 ''Foo)` line at the very bottom... template haskell is weird
2020-11-20 10:49:52 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 272 seconds)
2020-11-20 10:50:13 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se)
2020-11-20 10:51:01 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 10:51:37 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com)
2020-11-20 10:52:39 +0100 <c_wraith> a top-level TH splice separates the file into what's sort of multiple compilation units. It resolves names from before the splice, then does the splice with only those names in context, then looks at the rest of the file.
2020-11-20 10:53:20 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 10:55:46 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-kwmvlnupagfhstlw)
2020-11-20 10:59:11 +0100ubert(~Thunderbi@p200300ecdf1e5355e6b318fffe838f33.dip0.t-ipconnect.de)
2020-11-20 11:00:35 +0100Rudd0(~Rudd0@185.189.115.98)
2020-11-20 11:03:08 +0100ph88^(~ph88@ip5f5af6cd.dynamic.kabel-deutschland.de)
2020-11-20 11:03:10 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 272 seconds)
2020-11-20 11:03:10 +0100knupfer(~Thunderbi@200116b824bb7e005406fbfffe2fdbcc.dip.versatel-1u1.de)
2020-11-20 11:03:12 +0100knupfer(~Thunderbi@200116b824bb7e005406fbfffe2fdbcc.dip.versatel-1u1.de) (Client Quit)
2020-11-20 11:03:25 +0100knupfer(~Thunderbi@i5E86B41D.versanet.de)
2020-11-20 11:04:57 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 11:05:16 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-20 11:05:42 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-20 11:05:56 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-20 11:06:21 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Remote host closed the connection)
2020-11-20 11:07:14 +0100ph88(~ph88@2a02:8109:9e00:7e5c:f073:c081:c2ef:433b) (Ping timeout: 264 seconds)
2020-11-20 11:07:19 +0100Feuermagier_(~Feuermagi@213.178.26.41) (Quit: Leaving)
2020-11-20 11:11:22 +0100DavidEichmann(~david@62.110.198.146.dyn.plus.net)
2020-11-20 11:12:33 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2020-11-20 11:16:18 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 11:19:35 +0100guest1120(~user@49.5.6.87) (Quit: ERC (IRC client for Emacs 27.1))
2020-11-20 11:20:36 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Ping timeout: 256 seconds)
2020-11-20 11:22:36 +0100vsiddharth(~user@135-180-144-154.fiber.dynamic.sonic.net) (Ping timeout: 240 seconds)
2020-11-20 11:25:55 +0100gienah(~mwright@gentoo/developer/gienah)
2020-11-20 11:30:56 +0100kuribas(~user@ptr-25vy0i7lmmi4jlxzmxu.18120a2.ip6.access.telenet.be)
2020-11-20 11:34:22 +0100 <merijn> c_wraith: Except a bug made it work for several years with classes >.>
2020-11-20 11:34:57 +0100fendor_(~fendor@77.119.129.57.wireless.dyn.drei.com)
2020-11-20 11:36:09 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Ping timeout: 260 seconds)
2020-11-20 11:36:49 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 11:37:37 +0100fendor(~fendor@178.165.131.185.wireless.dyn.drei.com) (Ping timeout: 260 seconds)
2020-11-20 11:39:03 +0100shatriff(~vitaliish@176.52.219.10) (Remote host closed the connection)
2020-11-20 11:39:19 +0100shatriff(~vitaliish@176.52.219.10)
2020-11-20 11:41:22 +0100pong(chiya@2406:3003:2077:2341::babe) (Ping timeout: 260 seconds)
2020-11-20 11:41:58 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 260 seconds)
2020-11-20 11:42:34 +0100pong(chiya@2406:3003:2077:2341::babe)
2020-11-20 11:46:24 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 11:47:47 +0100darjeeling_(~darjeelin@122.245.211.11) (Ping timeout: 265 seconds)
2020-11-20 11:50:26 +0100__monty__(~toonn@unaffiliated/toonn)
2020-11-20 11:51:56 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 272 seconds)
2020-11-20 11:53:21 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-20 11:54:24 +0100alp(~alp@2a01:e0a:58b:4920:c533:3fa3:3963:3f02) (Ping timeout: 240 seconds)
2020-11-20 11:57:16 +0100knupfer(~Thunderbi@i5E86B41D.versanet.de) (Ping timeout: 240 seconds)
2020-11-20 11:57:23 +0100ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net)
2020-11-20 11:57:58 +0100ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net) (Changing host)
2020-11-20 11:57:58 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus)
2020-11-20 12:00:16 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Ping timeout: 240 seconds)
2020-11-20 12:02:02 +0100darjeeling_(~darjeelin@122.245.211.11)
2020-11-20 12:04:46 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com)
2020-11-20 12:08:02 +0100hidedagger(~nate@unaffiliated/hidedagger) (Quit: WeeChat 2.9)
2020-11-20 12:09:02 +0100prez(~prez@unaffiliated/prez) (Quit: znc)
2020-11-20 12:10:04 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 12:12:53 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr)
2020-11-20 12:13:50 +0100Alleria_(~AllahuAkb@2604:2000:1484:26:ef:21ba:eb1b:b066) (Ping timeout: 264 seconds)
2020-11-20 12:14:25 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Ping timeout: 240 seconds)
2020-11-20 12:17:15 +0100wei2912(~wei2912@unaffiliated/wei2912) (Remote host closed the connection)
2020-11-20 12:18:24 +0100Franciman(~francesco@host-79-27-199-238.retail.telecomitalia.it)
2020-11-20 12:19:46 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr) (Quit: Lost terminal)
2020-11-20 12:21:37 +0100rprije(~rprije@124.148.131.132) (Ping timeout: 265 seconds)
2020-11-20 12:22:58 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr)
2020-11-20 12:23:47 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 12:25:04 +0100gproto23(~gproto23@unaffiliated/gproto23)
2020-11-20 12:27:56 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909)
2020-11-20 12:28:14 +0100sszark(~sszark@h-213-180.A392.priv.bahnhof.se)
2020-11-20 12:28:25 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-20 12:28:43 +0100vilpan(~0@212.117.1.172) ()
2020-11-20 12:29:44 +0100 <sszark> I'm extending an existing module by re-exporting it along with my own additions. Is there a way to export the whole scope in a module instead of declaring everything?
2020-11-20 12:30:17 +0100 <tdammers> yes. you can do whole-module reexports
2020-11-20 12:30:28 +0100 <tdammers> module Foo where (module Bar); import Bar
2020-11-20 12:31:46 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909) (Client Quit)
2020-11-20 12:32:27 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 12:33:00 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909)
2020-11-20 12:33:16 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 240 seconds)
2020-11-20 12:33:38 +0100 <ClaudiusMaximus> can you do module Foo where (module Bar, module Foo) ; import Bar ; foo = 3 -- to export everything from Foo too? i haven't tested...
2020-11-20 12:35:05 +0100climber(3d044c81@61.4.76.129)
2020-11-20 12:35:35 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909) (Client Quit)
2020-11-20 12:35:38 +0100 <tdammers> IIRC yes
2020-11-20 12:35:54 +0100cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it)
2020-11-20 12:36:00 +0100 <ski> Martinsos : i think it's good to think of it as first considering sum/variant types (with pattern-matching) ("FP") vs. product/record types (with "message-dispatching") ("OO"), these two being more directly comparable
2020-11-20 12:37:25 +0100pong(chiya@2406:3003:2077:2341::babe) (Ping timeout: 272 seconds)
2020-11-20 12:38:07 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 12:39:17 +0100alp(~alp@2a01:e0a:58b:4920:d884:ceaa:fae:7708)
2020-11-20 12:40:02 +0100Yumasi(~guillaume@2a01cb09b06b29eabd8cf63c98e88a0f.ipv6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2020-11-20 12:42:16 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-11-20 12:43:50 +0100pong(chiya@2406:3003:2077:2341::babe)
2020-11-20 12:44:26 +0100pong(chiya@2406:3003:2077:2341::babe) (Max SendQ exceeded)
2020-11-20 12:45:29 +0100pong(chiya@2406:3003:2077:2341::babe)
2020-11-20 12:46:08 +0100pong(chiya@2406:3003:2077:2341::babe) (Max SendQ exceeded)
2020-11-20 12:47:36 +0100Guest31037(chiya@2406:3003:2077:2341::babe)
2020-11-20 12:47:58 +0100Guest31037cawfee
2020-11-20 12:49:21 +0100m0rphism(~m0rphism@HSI-KBW-095-208-098-207.hsi5.kabel-badenwuerttemberg.de)
2020-11-20 12:49:32 +0100 <sszark> thank you tdammers ClaudiusMaximus
2020-11-20 12:51:05 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 12:55:19 +0100In0perable(~PLAYER_1@fancydata.science) (Quit: All your buffer are belong to us!)
2020-11-20 12:55:25 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Ping timeout: 240 seconds)
2020-11-20 12:59:06 +0100Alleria_(~AllahuAkb@69.202.254.168)
2020-11-20 13:00:23 +0100sMuNiX(~sMuNiX@vlnsm8-montreal02-142-122-8-233.internet.virginmobile.ca)
2020-11-20 13:01:56 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-11-20 13:07:51 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2020-11-20 13:11:26 +0100 <merijn> sszark, ClaudiusMaximus: In fact you can even import only *part* of Foo and re-export that part
2020-11-20 13:11:54 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de)
2020-11-20 13:13:48 +0100gxt(~gxt@gateway/tor-sasl/gxt) (Remote host closed the connection)
2020-11-20 13:15:18 +0100 <Martinsos> ski: I didn't quite get where you are getting with this, would you mind giving me more details/context? How would that fit into deciding how to represent those Shapes / expressin problem?
2020-11-20 13:15:46 +0100 <dexterfoo> Is "ViewPatterns" GHC extension good?
2020-11-20 13:16:25 +0100 <ski> dexterfoo : it can be useful, sometimes
2020-11-20 13:16:47 +0100jrm(~jrm@freebsd/developer/jrm)
2020-11-20 13:17:01 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2020-11-20 13:17:28 +0100 <ski> (avoiding an explicit `case'. being able to fall-through to a later defining equation, if the "secondary" match fails)
2020-11-20 13:18:59 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de) (Quit: bitmagie)
2020-11-20 13:19:53 +0100 <ski> Martinsos : consider your type `Shape'. you want shapes to come in different alternative variants, such as circle,rectangle,&c. and you also want shapes to have various properties like perimeter,area,&c.
2020-11-20 13:21:08 +0100 <Martinsos> ski: exactly, we want them to have some common interface, but also to be able to work with them individually. I think we can add that we also want to be able to put them all together in a list.
2020-11-20 13:21:25 +0100 <ski> so, for each alternative kind of shape, you need to have an implementation of each property. imagine schematically displaying this in a table. the rows are your different alternatives, the columns are your different properties
2020-11-20 13:22:15 +0100 <Martinsos> ski: sure, makes sense
2020-11-20 13:24:12 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-20 13:24:34 +0100 <ski> the "OO" approach, the product/record types approach, is to slice your table into separate rows. each row becomes a function (a "constructor" in OO terms), that takes whatever parameters the alternative requires (like radius, or width & height), and returns a record with one implementation for each property (each "method"). in OO terminology, this is a class (with a class constructor taking tha parameters)
2020-11-20 13:24:40 +0100 <ski> that implements the `Shape' interface (or inherits from the (hopefully abstract) base class `Shape', if you must)
2020-11-20 13:25:26 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net)
2020-11-20 13:25:42 +0100climber(3d044c81@61.4.76.129) (Remote host closed the connection)
2020-11-20 13:25:57 +0100 <Martinsos> ski: Sure, still following! Sorry I will stop writing, if I don't write anything it means I am following :D
2020-11-20 13:25:59 +0100 <ski> the "FP" approach, the sum/variant types approach, is to slice your table into separate columns. each column (each property) becomes a pattern-matching function that checks which alternative kind of shape it's given, and computes the property for that case
2020-11-20 13:26:41 +0100 <Martinsos> Aha got it
2020-11-20 13:27:03 +0100 <ski> the alternatives becomes the data constructors of your sum / variant / algebraic data type
2020-11-20 13:27:11 +0100 <Martinsos> And while product approach is more natural / nicer for OO, sum/variatns approach is more natural/nicer for FP?
2020-11-20 13:27:43 +0100 <Martinsos> We could say that first one groups logic by variant, whiel second one groups logic by operation?
2020-11-20 13:28:25 +0100 <ski> now, in the "OO" approach, if you want to add another kind of alternative, that's easy, just define a new record-producing operation / define a new OO class. but if you want to add another property, now you must edit all the existing classes
2020-11-20 13:28:40 +0100pjb(~t@2a01cb04063ec500fcb709f072569e15.ipv6.abo.wanadoo.fr) ("ERC (IRC client for Emacs 27.1)")
2020-11-20 13:29:13 +0100 <ski> while, in the "FP" approach, if you want to add another property, that's easy, you just define a new pattern-matching function. but if you want to add another alternative, you now have to edit all the existing pattern-matching functions
2020-11-20 13:30:48 +0100 <Martinsos> ski: I knew about the extendibility perspective, but what I didn't know is that one is considered OO approach while another is considered FP approach. I get it that that is also incorrect, to call them like that, but it does give an interesting perspective.
2020-11-20 13:30:52 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 13:31:38 +0100 <Martinsos> ski: But to me implementing "OO" approach in Haskell doesn't seem much harder, we can do it with type classes right? Although it does require more code so I guess that makes it less elegant and therefore the variant approach is more of a "FP" approach?
2020-11-20 13:31:38 +0100 <ski> Martinsos : exercise : define (FP) a sum type `ShapeS' with alternatives `CircleS',`RectangleS', and pattern-matching functions `perimeterS',`areaS'. then define (OO) a product type `ShapeP' with fields `perimeterP',`areaP' and record-consatructing operations `circleP',`rectangleP'
2020-11-20 13:32:15 +0100 <ski> note that if you want a property/method that takes additional parameters, that's just a field that's a function
2020-11-20 13:32:37 +0100 <Martinsos> ski: Ok here you are basically implementing type classes manually right?
2020-11-20 13:33:28 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:6c06:f0fd:283a:1f37:de16) (Read error: Connection reset by peer)
2020-11-20 13:33:44 +0100 <Martinsos> ski: Thanks, I get the examples! I have been playing with both examples previously so I did try them in practice, but I was still wondering is, which one is better, if one does not have a ton of information on how the codebase will evolve? I guess the "FP" is simpler and therefore maybe preferred as the first try.
2020-11-20 13:33:51 +0100 <ski> also note that pattern-matching allows you to match on nested patterns, and on multiple parallel patterns, not just a single level of alternatives. also, if you throw recursive types into the mix, it can get more interesting/complicated. but the above should hopefully showoff the basic duality between sum types and product types
2020-11-20 13:34:09 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2020-11-20 13:34:16 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-20 13:34:50 +0100 <ski> it's not about either one or the other, you want to have both available to you. sometimes one is more appropriate, sometimes the other. sometimes you can envisage alternatives being changed or added to (or removed from) more often than properties. sometimes the other way around
2020-11-20 13:35:10 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Ping timeout: 246 seconds)
2020-11-20 13:35:33 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-11-20 13:36:18 +0100 <Martinsos> ski: Thanks for detailed explanation, it is clearer now!
2020-11-20 13:36:46 +0100Entertainment(~entertain@104.246.132.210)
2020-11-20 13:37:03 +0100 <Martinsos> ski: for the Shape problem, which one would you use? If you don't know in which direction you will be adding more (operations or variants)? Probably with sum type since it is simpler and we don't have info for either?
2020-11-20 13:37:25 +0100 <ski> Martinsos : "And while product approach is more natural / nicer for OO, sum/variatns approach is more natural/nicer for FP?" -- FP languages have tended to emphasize sum types more. it seems it's only now that sum types with pattern-matching are starting to seep out into more mainstream languages. for a long time, there's been an OO dogma that using `switch' or `instanceof' is bad (and the latter is bad, i'd
2020-11-20 13:37:31 +0100 <ski> argue. but the motivation for wanting to use it is valid, the problem people want to address is real)
2020-11-20 13:38:25 +0100Tario(~Tario@201.192.165.173)
2020-11-20 13:39:55 +0100 <ski> and so, you've gotten the VisitorPattern for (clumsily & verbosily) simulating/encoding sum types with pattern-matching, in OO. it's basically just a CPS / Church encoding of sum types. `A + B' being encoded as `forall o. (A -> o) * (B -> o) -> o'. `(A -> o) * (B -> o)' is the visitor, it's the branches of a `case'-`of', packaged up together
2020-11-20 13:40:11 +0100daim2k5(~daim2k5@185.204.1.185) (Remote host closed the connection)
2020-11-20 13:41:20 +0100enoq(~textual@194-208-146-143.lampert.tv)
2020-11-20 13:41:30 +0100 <ski> Martinsos : "We could say that first one groups logic by variant, whiel second one groups logic by operation?" -- yes (although the way i'm using the term "operation" is more like in the Abstract Data Type sense. so i'd probably say "property"/"method" instead of "operation", in your characterization)
2020-11-20 13:43:59 +0100 <ski> "one is considered OO approach while another is considered FP approach. I get it that that is also incorrect, to call them like that, but it does give an interesting perspective." -- they're crude terms, there's more to FP and OO than this. but it does place the finger on some important differences between how both tends to be used, and it's a quick way to get the point across. if someone already understands
2020-11-20 13:44:05 +0100 <ski> what are product/record types, and what are sum/variant types, then i'd probably prefer using those terms instead of "OO" and "FP"
2020-11-20 13:44:27 +0100 <joel135> . o O (interaction laws https://youtu.be/LHIKGC_oxFA?t=801)
2020-11-20 13:44:28 +0100mlugg(c3c2162d@195.194.22.45)
2020-11-20 13:44:45 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Ping timeout: 240 seconds)
2020-11-20 13:45:53 +0100 <ski> Martinsos : "But to me implementing \"OO\" approach in Haskell doesn't seem much harder, we can do it with type classes right?" -- you may note that i haven't mentioned type classes at all. (and the main reason i started talking about this now was to steer you away from comparing with type classes right away). if you do the exercise i suggested, you should not be defining any type classes at all, nor making
2020-11-20 13:45:59 +0100 <ski> any instances of any such
2020-11-20 13:46:52 +0100 <cads> hey would anyone be willing to pair program with me and show me how they set up and deploy a haskell based microservice?
2020-11-20 13:47:09 +0100 <cads> say, something that I can send a string to, and it'll send me back the Sha3-512
2020-11-20 13:47:17 +0100 <cads> asking a lot
2020-11-20 13:47:23 +0100 <cads> whadda say?
2020-11-20 13:48:06 +0100 <ski> Martinsos : and yes, doing the product/record types approach in Haskell is not that hard (but perhaps it must be pointed out to someone that it's possible, if it doesn't occur immediately as an alternative). which is another reason the "FP" term is crude. as is the "OO" term, since OO tends to also include things like implementation inheritance, and open recursion. you can do those in Haskell as well, but
2020-11-20 13:48:12 +0100 <ski> you have to do a little bit more work (especially for open recursion)
2020-11-20 13:48:41 +0100gproto023(~gproto23@unaffiliated/gproto23)
2020-11-20 13:49:02 +0100 <ski> Martinsos : "Ok here you are basically implementing type classes manually right?" -- emphatically no
2020-11-20 13:49:16 +0100 <cads> in return, I can offer to close a bug report in a python script of your choice (within 1 to 2 hours of labor)
2020-11-20 13:49:43 +0100mlugg76(68eeaaef@104.238.170.239)
2020-11-20 13:49:49 +0100 <absence> why can i pass a (forall a. IsString a => a) to a function that expects String?
2020-11-20 13:49:51 +0100niko(~niko@freenode/staff/ubuntu.member.niko)
2020-11-20 13:50:09 +0100 <merijn> absence: Because "instance IsString String"? :)
2020-11-20 13:50:17 +0100 <merijn> :t fromString "foo"
2020-11-20 13:50:19 +0100 <lambdabot> IsString a => a
2020-11-20 13:50:25 +0100 <merijn> > fromString "foo" :: String
2020-11-20 13:50:27 +0100 <lambdabot> "foo"
2020-11-20 13:50:31 +0100 <ski> absence : because it has type `a', for every type `a' that is an instance of `IsString'. and since `String' is such a type, your input (also) has type `String'
2020-11-20 13:50:38 +0100 <mlugg76> (the other mlugg is a timed-out me, sorry!) Can you define a typeclass instance for a type family? E.g. if I have a type family like https://termbin.com/o4le, since every instance of the family has a `Show` instance, can I make `show :: Foo a -> String` valid?
2020-11-20 13:50:54 +0100mlugg(c3c2162d@195.194.22.45) (Ping timeout: 245 seconds)
2020-11-20 13:50:58 +0100 <merijn> mlugg76: "no"
2020-11-20 13:51:12 +0100mlugg76mlugg
2020-11-20 13:51:14 +0100 <merijn> mlugg76: Because a type family is basically a type level function
2020-11-20 13:51:16 +0100 <ski> if
2020-11-20 13:51:21 +0100 <ski> foo :: forall a. IsString a => a
2020-11-20 13:51:23 +0100da39a3ee5e6b4b0d(~da39a3ee5@mx-ll-171.5.161-165.dynamic.3bb.co.th)
2020-11-20 13:51:23 +0100 <ski> then also
2020-11-20 13:51:29 +0100gproto23(~gproto23@unaffiliated/gproto23) (Ping timeout: 256 seconds)
2020-11-20 13:51:32 +0100 <absence> merijn, ski: ah, so the fact that the function expects String forces the a to be String via the instance, that makes sence. thanks!
2020-11-20 13:51:33 +0100 <ski> foo :: IsString String => String
2020-11-20 13:51:37 +0100 <mlugg> merijn: okay, ty
2020-11-20 13:51:45 +0100 <ski> and since `IsString String' holds, we further have
2020-11-20 13:51:49 +0100 <ski> foo :: String
2020-11-20 13:52:00 +0100 <merijn> mlugg: Basically "Foo a" is not a parameteric type, it's "the result of the Foo type family applied to 'a'"
2020-11-20 13:52:19 +0100 <ski> absence : so, you're specializing your (overloaded) polymorphic value, to type `String', before passing it to the function. you're passing a `String'
2020-11-20 13:52:34 +0100 <merijn> mlugg: So if you have "type instance Foo Bool = Int" (or whatever the right syntax is, then "Foo Bool" isn't 'Foo' (with it's instance) it's "Int"
2020-11-20 13:52:52 +0100 <ski> absence, yep
2020-11-20 13:54:55 +0100 <ski> Martinsos : btw, you might note that with `Circle = Double',`Rectangle = Double * Double', you have `ShapeS = Circle + Rectangle'. similarly, with `Perimeter = Double',`Area = Double', you have `ShapeP = Perimeter * Area'
2020-11-20 13:56:05 +0100ski. o O ( <https://en.wikipedia.org/wiki/Additive_category#Matrix_representation_of_morphisms> )
2020-11-20 13:56:45 +0100Chi1thangoo(~Chi1thang@87.112.60.168)
2020-11-20 13:57:08 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2020-11-20 13:58:36 +0100 <ski> MarcelineVQ : "which one is better, if one does not have a ton of information on how the codebase will evolve?" -- i'm not sure there's a good general answer to this. "it depends"
2020-11-20 13:58:40 +0100 <ski> er, sorry
2020-11-20 13:58:44 +0100 <ski> Martinsos ^
2020-11-20 14:00:02 +0100directhex1(~directhex@195.206.169.184)
2020-11-20 14:00:59 +0100 <Martinsos> ski: Thanks for all these explanations, this is great! Hm hm hm. I will try to play with the example more later, but I think I do get the concept. I don't quite understand the problem with recursion, but I can tackle that once I encounter it. And thanks for that link, I will check it in more depth.
2020-11-20 14:01:50 +0100 <ski> Martinsos : you can also compare sum/variant/"FP" vs. product/record/"OO" with Deep vs. Shallow embedding, see <https://wiki.haskell.org/Embedded_domain_specific_language>. in this comparision, think of the record version as usually having just one field, but there's nothing stopping someone from doing a shallow embedding with "multiple alternative interpretations" (perhaps a "main/intended" one, and some
2020-11-20 14:01:56 +0100 <ski> auxilary ones)
2020-11-20 14:02:20 +0100gproto0023(~gproto23@unaffiliated/gproto23)
2020-11-20 14:02:20 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 14:02:27 +0100 <Martinsos> ski++
2020-11-20 14:02:30 +0100texasmynsted(~texasmyns@212.102.45.109)
2020-11-20 14:02:39 +0100skitwitches
2020-11-20 14:03:24 +0100acidjnk_new2(~acidjnk@p200300d0c719ff35956387e811e01df5.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2020-11-20 14:04:25 +0100gproto023(~gproto23@unaffiliated/gproto23) (Ping timeout: 240 seconds)
2020-11-20 14:05:04 +0100urodna(~urodna@unaffiliated/urodna)
2020-11-20 14:06:10 +0100 <ski> e.g. for an idiomatic/applicative parser, you could both compute the main parsing action, that is fed parsing input, and does its work. but also compute, "on the side" ("statically", before parsing even starts), `NULLABLE' (can it succeed, consuming no input),`FIRST' (what are the possible tokens that could start an input that is accepted by the parser), for efficiency purposes
2020-11-20 14:08:27 +0100 <ski> or, i once did a CGI monad thing, that contained a "play" and a "replay" part. when it emits a form, it generates a page. then when the form is filled in and replied, the computation starts over, but replaying the already done parts, until it gets to the point where it stopped last
2020-11-20 14:08:31 +0100 <dminuoso> I finally it, a use for unsafeCatchPure :: Exception e => a -> (e -> a) -> a
2020-11-20 14:08:34 +0100 <dminuoso> An evil one ontop!
2020-11-20 14:08:56 +0100 <merijn> Is there a non-evil one?
2020-11-20 14:09:25 +0100 <dminuoso> No idea, but it's either that or invest a lot of work in phadej's tree-diff
2020-11-20 14:09:28 +0100zariuq(~zar@fw1.ciirc.cvut.cz)
2020-11-20 14:09:35 +0100 <Martinsos> ski: You slightly lost me there :D, I am afraid this is beyond my current Haskell knowledge, but I stored these more advanced things you said for later reading once I am more knowleagdable :D!
2020-11-20 14:09:39 +0100 <dminuoso> Im gonna use pure exceptions to modify control flow!
2020-11-20 14:09:40 +0100 <merijn> tree-diif is some fantastic stuff
2020-11-20 14:09:53 +0100 <dminuoso> Indeed, it just lacks one thing we sorely miss
2020-11-20 14:09:56 +0100 <merijn> dminuoso: I will haunt you until your death
2020-11-20 14:10:08 +0100 <ski> (the category theory link is related, but will require some mbackground. and it's not too essential, it's just an "in case you know about CT, this might be interesting to compare to")
2020-11-20 14:11:08 +0100drbean(~drbean@TC210-63-209-197.static.apol.com.tw)
2020-11-20 14:11:36 +0100 <dminuoso> merijn: No but seriously. The main issue with tree-diff is if you have Rec "foo" (M.fromList [("keyA", 1), ("keyB", 2)]) vs Rec "foo" (M.fromList [("keyA", 1)])
2020-11-20 14:11:54 +0100 <dminuoso> There's sadly no way to represent deletion of keys
2020-11-20 14:12:00 +0100 <dminuoso> Which causes a lot of ugliness
2020-11-20 14:12:16 +0100 <dminuoso> or uh
2020-11-20 14:12:23 +0100 <dminuoso> Rec "foo" (M.fromList [("keyA", ...), ("keyB", ...)])
2020-11-20 14:12:33 +0100 <dminuoso> Rec "foo" (M.fromList [("keyA", ...)])
2020-11-20 14:12:58 +0100 <dminuoso> Instead, you get a Swp operation on the record, and del/add operations on the value pointed by the key
2020-11-20 14:13:12 +0100fendor_fendor
2020-11-20 14:13:19 +0100 <dminuoso> Im trying really hard to hack this into the Pretty dictionary
2020-11-20 14:14:07 +0100 <dminuoso> (or actually, I think its even a Cpy on the record?)
2020-11-20 14:14:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-20 14:16:44 +0100hlisp(~hlisp@223.71.166.151)
2020-11-20 14:18:11 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Remote host closed the connection)
2020-11-20 14:18:39 +0100hlisp(~hlisp@223.71.166.151) (Remote host closed the connection)
2020-11-20 14:19:39 +0100cfricke(~cfricke@unaffiliated/cfricke)
2020-11-20 14:21:38 +0100 <ski> Martinsos : anyway .. OO can also be related to lexical/static scoping (in particular non-local variable references. commonly implemented as "closures"), but alternatively also in terms of existential types. Abstract Data Types can also be related to existential types, but in a different way (leading to different ways of and issues with, structuring code)
2020-11-20 14:21:45 +0100 <ski> @where on-understanding
2020-11-20 14:21:45 +0100 <lambdabot> "On Understanding Types, Data Abstraction, and Polymorphism" by Luca Cardelli,Peter Wegner in 1985-12 at <http://lucacardelli.name/Papers/OnUnderstanding.A4.pdf>
2020-11-20 14:21:48 +0100 <ski> @where on-understanding-revisited
2020-11-20 14:21:48 +0100 <lambdabot> "On Understanding Data Abstraction, Revisited" by William R. Cook in 2009-10 at <http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf>
2020-11-20 14:23:33 +0100 <ski> the latter talks about this. the former talks about different senses of "polymorphism", and also about ADTs as existentials
2020-11-20 14:24:39 +0100mlugg(68eeaaef@104.238.170.239) (Ping timeout: 245 seconds)
2020-11-20 14:26:34 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Read error: Connection reset by peer)
2020-11-20 14:26:55 +0100 <ski> "Polymorphic Type Inference" by Michael I. Schwartzbach in 1995-03 at <https://cs.au.dk/~amoeller/mis/typeinf.p(sdf|df)>,<https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.57.1493> might be interesting to learn more basics of type systems, type inference, also mentioning universals and existentials
2020-11-20 14:27:05 +0100 <ski> .. but all this is probably a discussion for another day
2020-11-20 14:27:19 +0100gxt(~gxt@gateway/tor-sasl/gxt) (Quit: WeeChat 2.9)
2020-11-20 14:28:54 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-20 14:29:09 +0100 <dminuoso> [exa]: Btw, I decided to go with indents+parsec. The subtle edge cases of building up that tree kept building up.
2020-11-20 14:30:04 +0100 <dminuoso> `I.withBlock mkTree node tree` is much simpler to write, I was already at 150 lines and started to write an evaluator to build up my tree.
2020-11-20 14:32:51 +0100knupfer(~Thunderbi@200116b824bb7e0064810ffffed5e86a.dip.versatel-1u1.de)
2020-11-20 14:34:03 +0100jonatanb_(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 14:35:15 +0100knupfer(~Thunderbi@200116b824bb7e0064810ffffed5e86a.dip.versatel-1u1.de) (Remote host closed the connection)
2020-11-20 14:35:25 +0100knupfer(~Thunderbi@200116b824bb7e00edb32aa10920b88c.dip.versatel-1u1.de)
2020-11-20 14:37:28 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Ping timeout: 246 seconds)
2020-11-20 14:39:47 +0100rotty(rotty@ghost.xx.vu)
2020-11-20 14:42:52 +0100 <reactormonk> I've got a recursive datastructure with a Plated instance - How can I create a Lens where I have the already transformed children available in the transformation as well?
2020-11-20 14:43:19 +0100directhex1(~directhex@195.206.169.184) (Remote host closed the connection)
2020-11-20 14:48:03 +0100drbean(~drbean@TC210-63-209-197.static.apol.com.tw) (Ping timeout: 260 seconds)
2020-11-20 14:48:49 +0100Lowl3v3l(~Lowl3v3l@dslb-002-203-195-108.002.203.pools.vodafone-ip.de) (Ping timeout: 264 seconds)
2020-11-20 14:50:40 +0100theorbtwo(~theorb@cpc81822-swin19-2-0-cust3.3-1.cable.virginm.net)
2020-11-20 14:55:59 +0100 <[exa]> dminuoso: I always failed using the parsec/megaparsec indent blocks properly
2020-11-20 14:56:03 +0100 <[exa]> perhaps I should retry.
2020-11-20 14:56:16 +0100 <dminuoso> [exa]: Did you try by hands or using the indents library?
2020-11-20 14:56:26 +0100Kaivo(~Kaivo@104-200-86-99.mc.derytele.com)
2020-11-20 14:56:56 +0100 <[exa]> there's an extra library for that, aha.
2020-11-20 14:57:06 +0100 <[exa]> is there a megaparsec variant?
2020-11-20 14:57:51 +0100 <dminuoso> No, although one could write it. The implementation is fairly simple and straight forward.
2020-11-20 14:58:05 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Read error: Connection reset by peer)
2020-11-20 14:58:40 +0100 <[exa]> I always failed to make it work with parse items that span multiple lines
2020-11-20 14:58:58 +0100 <dminuoso> Well this is working just fine for me
2020-11-20 14:59:00 +0100 <[exa]> hm gonna retry. :]
2020-11-20 14:59:06 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de)
2020-11-20 14:59:07 +0100 <[exa]> you don't have multiline tokens right?
2020-11-20 14:59:35 +0100 <dminuoso> Right
2020-11-20 14:59:35 +0100bitmagie(~Thunderbi@200116b8063a3200b470a8e4f2a94e1e.dip.versatel-1u1.de) (Client Quit)
2020-11-20 14:59:43 +0100 <dminuoso> Im just parsing the cisco ios configuration language
2020-11-20 14:59:51 +0100 <Uniaika> dminuoso: RIP
2020-11-20 14:59:58 +0100 <[exa]> route in peace?
2020-11-20 15:00:01 +0100 <dminuoso> haha
2020-11-20 15:00:12 +0100 <dminuoso> That's not a bad one, I can see myself printing a shirt with that
2020-11-20 15:00:43 +0100 <[exa]> with cisco it may also be
2020-11-20 15:01:27 +0100 <[exa]> 'Reset without warning upon receiving an ASN >= 64k In Peace'
2020-11-20 15:01:43 +0100 <[exa]> (nah they already fixed that)
2020-11-20 15:02:10 +0100 <dminuoso> Wait. Received via BGP?
2020-11-20 15:02:25 +0100 <[exa]> you didn't hear the czech routing vs. cisco story?
2020-11-20 15:02:29 +0100 <dminuoso> Good thing we dont use Cisco for our external eBGP...
2020-11-20 15:02:31 +0100 <dminuoso> No did not
2020-11-20 15:02:39 +0100 <dminuoso> Peering is not my department
2020-11-20 15:02:40 +0100 <[exa]> I'll try to dig that up
2020-11-20 15:03:27 +0100Lowl3v3l(~Lowl3v3l@dslb-090-186-186-201.090.186.pools.vodafone-ip.de)
2020-11-20 15:04:56 +0100 <[exa]> basically this https://www.ciscozine.com/cisco-ios-causes-internet-disruption/ but there's a mailinglist post somewhere with the initial reaction of the administrators
2020-11-20 15:05:03 +0100[exa]---> #offtopic
2020-11-20 15:07:21 +0100carlomagno1(~cararell@148.87.23.6)
2020-11-20 15:08:06 +0100zebrag(~inkbottle@aaubervilliers-654-1-104-55.w86-212.abo.wanadoo.fr)
2020-11-20 15:08:29 +0100vicfred_(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-20 15:09:41 +0100carlomagno(~cararell@148.87.23.5) (Ping timeout: 256 seconds)
2020-11-20 15:10:12 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 15:11:17 +0100supercoven(~Supercove@dsl-hkibng31-54fae2-36.dhcp.inet.fi) (Ping timeout: 260 seconds)
2020-11-20 15:11:44 +0100hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus) (Remote host closed the connection)
2020-11-20 15:11:44 +0100denisse_(~spaceCat@gateway/tor-sasl/alephzer0) (Remote host closed the connection)
2020-11-20 15:12:15 +0100hekkaidekapus{(~tchouri@gateway/tor-sasl/hekkaidekapus)
2020-11-20 15:12:33 +0100denisse(~spaceCat@gateway/tor-sasl/alephzer0)
2020-11-20 15:13:41 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net) (Ping timeout: 265 seconds)
2020-11-20 15:14:47 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2020-11-20 15:16:21 +0100machinedgod(~machinedg@24.105.81.50)
2020-11-20 15:17:29 +0100acidjnk_new2(~acidjnk@p200300d0c719ff68956387e811e01df5.dip0.t-ipconnect.de)
2020-11-20 15:19:56 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-20 15:25:33 +0100gproto0023gproto23
2020-11-20 15:26:37 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2020-11-20 15:28:44 +0100todda7(~torstein@ppp-2-84-17-169.home.otenet.gr) (Ping timeout: 256 seconds)
2020-11-20 15:28:59 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 15:29:13 +0100todda7(~torstein@ppp-2-84-17-53.home.otenet.gr)
2020-11-20 15:32:06 +0100Yumasi(~guillaume@2a01cb09b06b29eabd8cf63c98e88a0f.ipv6.abo.wanadoo.fr)
2020-11-20 15:32:56 +0100todda7(~torstein@ppp-2-84-17-53.home.otenet.gr) (Excess Flood)
2020-11-20 15:33:44 +0100todda7(~torstein@ppp-2-84-17-53.home.otenet.gr)
2020-11-20 15:34:07 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-11-20 15:34:46 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:a955:27bd:b45b:9122)
2020-11-20 15:35:31 +0100 <ski> joel135 : hah, the state example on slide 8 made me think of Dialectica,PV,Chu, and now Uustalu, when talking about functor-functor interaction map (which looks suspiciously related to a dinatural transformation) mentions Chu :)
2020-11-20 15:35:32 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 256 seconds)
2020-11-20 15:35:37 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr) (Ping timeout: 260 seconds)
2020-11-20 15:35:38 +0100vicfred(~vicfred@unaffiliated/vicfred) (Quit: Leaving)
2020-11-20 15:36:27 +0100ski. o O ( "Questions and Answers -- A Category Arising in Linear Logic, Complexity Theory, and Set Theory" by Andreas Blass in 1993-09-16 at <https://arxiv.org/pdf/math/9309208v1.pdf> )
2020-11-20 15:38:24 +0100thc202(~thc202@unaffiliated/thc202) (Ping timeout: 240 seconds)
2020-11-20 15:38:51 +0100beng-nl1(~beng-nl@217.146.82.202)
2020-11-20 15:39:57 +0100thc202(~thc202@unaffiliated/thc202)
2020-11-20 15:41:27 +0100aarvar(~foewfoiew@50.35.43.33)
2020-11-20 15:42:46 +0100toorevitimirp(~tooreviti@117.182.180.118) (Remote host closed the connection)
2020-11-20 15:42:58 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 256 seconds)
2020-11-20 15:43:20 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2020-11-20 15:44:01 +0100enoq(~textual@194-208-146-143.lampert.tv) (Read error: Connection reset by peer)
2020-11-20 15:44:21 +0100toorevitimirp(~tooreviti@117.182.180.118)
2020-11-20 15:44:31 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2020-11-20 15:44:31 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2020-11-20 15:44:31 +0100neiluj(~jco@unaffiliated/neiluj)
2020-11-20 15:45:01 +0100infinity0(~infinity0@freenet/developer/infinity0)
2020-11-20 15:45:09 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2020-11-20 15:45:22 +0100enoq(~textual@194-208-146-143.lampert.tv)
2020-11-20 15:45:41 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt)
2020-11-20 15:46:16 +0100darjeeling_(~darjeelin@122.245.211.11) (Ping timeout: 272 seconds)
2020-11-20 15:47:49 +0100p-core1(~Thunderbi@2a0e:1c80:4:1024::1007)
2020-11-20 15:49:04 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Ping timeout: 240 seconds)
2020-11-20 15:49:06 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net)
2020-11-20 15:51:19 +0100p-core1p-core
2020-11-20 15:51:19 +0100p-core(~Thunderbi@2a0e:1c80:4:1024::1007) (Remote host closed the connection)
2020-11-20 15:51:40 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:a955:27bd:b45b:9122) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2020-11-20 15:54:12 +0100p-core(~Thunderbi@2a0e:1c80:4:1023::1004)
2020-11-20 15:56:52 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 15:58:53 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2020-11-20 15:59:36 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com)
2020-11-20 16:00:13 +0100 <dminuoso> % Foo { foo = const 1, bar = foo 10 }
2020-11-20 16:00:13 +0100 <yahb> dminuoso: ; <interactive>:61:28: error:; * Couldn't match expected type `Int' with actual type `String -> Int'; * Probable cause: `foo' is applied to too few arguments; In the `bar' field of a record; In the expression: Foo {foo = const 1, bar = foo 10}; In an equation for `it': it = Foo {foo = const 1, bar = foo 10}
2020-11-20 16:00:38 +0100 <dminuoso> Mmm, what is the idiomatic way to define a recursive data value?
2020-11-20 16:00:54 +0100 <dminuoso> Manually with fix?
2020-11-20 16:02:07 +0100 <merijn> or just a recursive binding
2020-11-20 16:02:25 +0100jonatanb_(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 16:02:37 +0100gproto23(~gproto23@unaffiliated/gproto23) (Ping timeout: 260 seconds)
2020-11-20 16:03:09 +0100 <dminuoso> merijn: Oh you mean some `let f = Foo { foo = const 1, bar = foo f 10 } in f` ?
2020-11-20 16:03:33 +0100conal(~conal@ip-66-115-176-195.creativelink.net)
2020-11-20 16:03:33 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 16:03:33 +0100conal(~conal@ip-66-115-176-195.creativelink.net) (Client Quit)
2020-11-20 16:03:35 +0100 <merijn> yeah
2020-11-20 16:03:43 +0100 <merijn> Like the classis
2020-11-20 16:03:51 +0100 <merijn> > let ones = 1 : ones in ones
2020-11-20 16:03:53 +0100 <lambdabot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
2020-11-20 16:03:57 +0100martin02(silas@hund.fs.lmu.de) (Ping timeout: 244 seconds)
2020-11-20 16:04:03 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 16:04:20 +0100 <merijn> Anyone happen to know how to set the default value of a UTCTime column to the epoch in persistent?
2020-11-20 16:04:24 +0100darjeeling_(~darjeelin@122.245.211.11)
2020-11-20 16:04:51 +0100conal(~conal@ip-66-115-176-195.creativelink.net)
2020-11-20 16:05:46 +0100ddellacosta(dd@gateway/vpn/mullvad/ddellacosta)
2020-11-20 16:05:58 +0100 <dminuoso> merijn: Mmm, cant you set default=CURRENT_TIME?
2020-11-20 16:06:15 +0100 <merijn> How is CURRENT_TIME the epoch?
2020-11-20 16:06:19 +0100 <dminuoso> Oh
2020-11-20 16:06:39 +0100hyperisco(~hyperisco@d192-186-117-226.static.comm.cgocable.net) (Read error: Connection reset by peer)
2020-11-20 16:06:55 +0100mstruebing(~mstruebin@2001:41d0:8:93c7::1) (Ping timeout: 240 seconds)
2020-11-20 16:07:17 +0100 <dminuoso> Curious, you say UTCTime but epoch
2020-11-20 16:07:25 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 16:07:33 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 16:07:35 +0100 <dminuoso> What kind of column does persistent map UTCTime to?
2020-11-20 16:08:34 +0100 <merijn> TIMESTAMP (in sqlite)
2020-11-20 16:08:54 +0100mstruebing(~mstruebin@2001:41d0:8:93c7::1)
2020-11-20 16:09:37 +0100hiroaki(~hiroaki@ip4d168e73.dynamic.kabel-deutschland.de)
2020-11-20 16:09:59 +0100connrs-(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 16:09:59 +0100connrs(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 16:10:19 +0100 <dminuoso> TIMESTAMP? Huh?
2020-11-20 16:10:21 +0100 <dminuoso> What's that?
2020-11-20 16:10:52 +0100 <dminuoso> Is that an alias for INTEGER?
2020-11-20 16:11:29 +0100 <merijn> TEXT
2020-11-20 16:11:41 +0100 <merijn> but as ISO8601 string
2020-11-20 16:12:22 +0100martin02(silas@hund.fs.lmu.de)
2020-11-20 16:12:40 +0100cheater(~user@unaffiliated/cheater) (Remote host closed the connection)
2020-11-20 16:12:51 +0100connrs(~connrs@runciter.connrs.uk)
2020-11-20 16:13:26 +0100connrs_(~connrs@runciter.connrs.uk)
2020-11-20 16:14:50 +0100cheater(~user@unaffiliated/cheater)
2020-11-20 16:15:10 +0100 <dminuoso> I wonder, does persistent accept `foo UTCTime default=(cast(strftime('%s','now') as int)` as a column?
2020-11-20 16:15:28 +0100 <dminuoso> Is that sort of what you meant?
2020-11-20 16:15:32 +0100 <merijn> No clue what it accepts, hence why I ask :p
2020-11-20 16:15:39 +0100 <dminuoso> heh
2020-11-20 16:15:56 +0100 <dminuoso> 68:You can use a @default=${sql expression}@ clause to set a default for a field.
2020-11-20 16:16:03 +0100 <dminuoso> So the above should work
2020-11-20 16:16:31 +0100hackageleb128-cereal 1.2 - LEB128 and SLEB128 encoding https://hackage.haskell.org/package/leb128-cereal-1.2 (JoachimBreitner)
2020-11-20 16:16:36 +0100 <dminuoso> (possibly without the cast if this goes into a text column)
2020-11-20 16:18:36 +0100texasmynsted(~texasmyns@212.102.45.109) ()
2020-11-20 16:18:43 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 16:19:06 +0100dyeplexer(~lol@unaffiliated/terpin)
2020-11-20 16:19:06 +0100p-core(~Thunderbi@2a0e:1c80:4:1023::1004) (Remote host closed the connection)
2020-11-20 16:19:26 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-20 16:20:07 +0100texasmynsted(~texasmyns@212.102.45.109)
2020-11-20 16:20:11 +0100solonarv(~solonarv@astrasbourg-653-1-156-4.w90-6.abo.wanadoo.fr)
2020-11-20 16:23:01 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 264 seconds)
2020-11-20 16:23:11 +0100oish(~charlie@185.107.80.85)
2020-11-20 16:25:05 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-20 16:25:28 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 2.9)
2020-11-20 16:26:52 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net)
2020-11-20 16:27:24 +0100knupfer(~Thunderbi@200116b824bb7e00edb32aa10920b88c.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-11-20 16:27:26 +0100nados(~dan@69-165-210-185.cable.teksavvy.com)
2020-11-20 16:27:57 +0100alp(~alp@2a01:e0a:58b:4920:d884:ceaa:fae:7708) (Ping timeout: 272 seconds)
2020-11-20 16:28:04 +0100oish(~charlie@185.107.80.85) (Ping timeout: 272 seconds)
2020-11-20 16:28:12 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl)
2020-11-20 16:28:51 +0100igghibu(~igghibu@91.193.5.30)
2020-11-20 16:29:20 +0100igghibu(~igghibu@91.193.5.30) (Client Quit)
2020-11-20 16:29:26 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 16:29:32 +0100acidjnk_new2(~acidjnk@p200300d0c719ff68956387e811e01df5.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-20 16:29:58 +0100aarvar(~foewfoiew@50.35.43.33) (Ping timeout: 272 seconds)
2020-11-20 16:31:33 +0100s00pcan(~chris@075-133-056-178.res.spectrum.com) (Ping timeout: 260 seconds)
2020-11-20 16:32:44 +0100borne(~fritjof@200116b86455d000f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2020-11-20 16:33:22 +0100s00pcan(~chris@107.181.165.217)
2020-11-20 16:33:36 +0100connrs_(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 16:33:37 +0100connrs(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 16:34:50 +0100connrs(~connrs@runciter.connrs.uk)
2020-11-20 16:35:26 +0100connrs_(~connrs@runciter.connrs.uk)
2020-11-20 16:37:08 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 16:37:44 +0100whatisRT(~whatisRT@ip5b416a33.dynamic.kabel-deutschland.de) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-20 16:38:30 +0100hackagephonetic-languages-permutations 0.2.0.0 - Commonly used versions of the phonetic-languages-common package https://hackage.haskell.org/package/phonetic-languages-permutations-0.2.0.0 (OleksandrZhabenko)
2020-11-20 16:39:45 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 240 seconds)
2020-11-20 16:41:01 +0100mrchampion(~mrchampio@216-26-218-246.dynamic.tbaytel.net) (Ping timeout: 264 seconds)
2020-11-20 16:41:48 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 16:42:07 +0100Sgeo(~Sgeo@ool-18b982ad.dyn.optonline.net)
2020-11-20 16:44:07 +0100mrchampion(~mrchampio@216-26-218-246.dynamic.tbaytel.net)
2020-11-20 16:47:56 +0100Gurkenglas(~Gurkengla@unaffiliated/gurkenglas)
2020-11-20 16:48:30 +0100hackagephonetic-languages-simplified-common 0.2.0.0 - A simplified version of the phonetic-languages-functionality https://hackage.haskell.org/package/phonetic-languages-simplified-common-0.2.0.0 (OleksandrZhabenko)
2020-11-20 16:50:07 +0100Merfont(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net) (Ping timeout: 246 seconds)
2020-11-20 16:50:14 +0100ubert(~Thunderbi@p200300ecdf1e5355e6b318fffe838f33.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-11-20 16:50:34 +0100ubert(~Thunderbi@p200300ecdf1e5355e6b318fffe838f33.dip0.t-ipconnect.de)
2020-11-20 16:53:25 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 16:54:58 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 16:54:59 +0100SanchayanMaity(~Sanchayan@223.226.123.235) (Quit: SanchayanMaity)
2020-11-20 16:55:01 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Ping timeout: 246 seconds)
2020-11-20 16:56:45 +0100_deepfire(~user@80.92.100.69) (Ping timeout: 240 seconds)
2020-11-20 16:57:41 +0100meck(~meck@li1809-18.members.linode.com) (Quit: ZNC 1.8.2 - https://znc.in)
2020-11-20 16:58:18 +0100_deepfire(~user@80.92.100.69)
2020-11-20 16:59:40 +0100borne(~fritjof@200116b86455d000f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-20 16:59:40 +0100LKoen(~LKoen@169.244.88.92.rev.sfr.net)
2020-11-20 17:00:04 +0100PotatoHatsue|T(berbermanm@gateway/shell/matrix.org/x-uhyqtdfvkudrmunh) (Quit: Idle for 30+ days)
2020-11-20 17:00:06 +0100kaychaks_riot(kaychaksma@gateway/shell/matrix.org/x-mkllmseyzgoebiyk) (Quit: Idle for 30+ days)
2020-11-20 17:00:59 +0100conal(~conal@ip-66-115-176-195.creativelink.net) (Quit: Computer has gone to sleep.)
2020-11-20 17:02:51 +0100connrs(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 17:02:52 +0100connrs_(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 17:03:03 +0100alp(~alp@2a01:e0a:58b:4920:e473:db5a:5f8a:8d59)
2020-11-20 17:03:55 +0100 <merijn> If I have a working ghcide, is there some way to dump out it's cradle config?
2020-11-20 17:04:05 +0100connrs(~connrs@runciter.connrs.uk)
2020-11-20 17:04:41 +0100connrs_(~connrs@runciter.connrs.uk)
2020-11-20 17:04:48 +0100toorevitimirp(~tooreviti@117.182.180.118) (Remote host closed the connection)
2020-11-20 17:05:27 +0100knupfer(~Thunderbi@200116b824bb7e002856a5fffe28fbf5.dip.versatel-1u1.de)
2020-11-20 17:05:56 +0100knupfer(~Thunderbi@200116b824bb7e002856a5fffe28fbf5.dip.versatel-1u1.de) (Remote host closed the connection)
2020-11-20 17:06:04 +0100knupfer(~Thunderbi@200116b824bb7e00d8226e797ccf94db.dip.versatel-1u1.de)
2020-11-20 17:06:40 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-11-20 17:06:50 +0100conal(~conal@64.71.133.70)
2020-11-20 17:08:09 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 17:08:42 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 17:09:11 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 17:09:36 +0100dyeplexer(~lol@unaffiliated/terpin) (Ping timeout: 240 seconds)
2020-11-20 17:10:37 +0100whatisRT(~whatisRT@2002:5b41:6a33:0:b44f:bf96:fd3:56a8)
2020-11-20 17:12:16 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 17:12:27 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 17:12:28 +0100renzhi(~renzhi@2607:fa49:655f:e600::28da)
2020-11-20 17:12:29 +0100gproto23(~gproto23@unaffiliated/gproto23)
2020-11-20 17:12:36 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 17:13:55 +0100darjeeling_(~darjeelin@122.245.211.11) (Ping timeout: 246 seconds)
2020-11-20 17:16:27 +0100kuribas(~user@ptr-25vy0i7lmmi4jlxzmxu.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2020-11-20 17:17:15 +0100meck(~meck@li1809-18.members.linode.com)
2020-11-20 17:18:53 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 256 seconds)
2020-11-20 17:19:22 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2020-11-20 17:20:41 +0100dyeplexer(~lol@unaffiliated/terpin)
2020-11-20 17:21:30 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 17:21:59 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 17:23:10 +0100sh9(~sh9@softbank060116136158.bbtec.net) (Quit: WeeChat 2.8)
2020-11-20 17:25:14 +0100 <dexterfoo> why does Map have both foldl and foldr? isn't it supposed to be unordered?
2020-11-20 17:25:30 +0100 <merijn> dexterfoo: eh, no?
2020-11-20 17:25:36 +0100 <merijn> Why would it be unordered
2020-11-20 17:26:02 +0100 <merijn> In fact, containers guarantees Foldable and Traversable are "least to greatest" order of keys/elements
2020-11-20 17:26:16 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Ping timeout: 240 seconds)
2020-11-20 17:26:39 +0100 <dexterfoo> i see. but the performance of foldl and foldr are the same, right?
2020-11-20 17:26:50 +0100 <merijn> "Yes, no, maybe, it depends"
2020-11-20 17:26:53 +0100Lycurgus(~niemand@cpe-45-46-142-188.buffalo.res.rr.com) (Quit: Exeunt)
2020-11-20 17:28:13 +0100acidjnk_new2(~acidjnk@p200300d0c719ff6800925201c24f6260.dip0.t-ipconnect.de)
2020-11-20 17:30:35 +0100darjeeling_(~darjeelin@122.245.211.11)
2020-11-20 17:32:37 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2020-11-20 17:33:01 +0100 <maerwald> The general answer is "no", unless you can be more explicit
2020-11-20 17:34:17 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-20 17:36:40 +0100christo(~chris@81.96.113.213)
2020-11-20 17:37:17 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 17:38:07 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:4914:be02:68a7:933e)
2020-11-20 17:40:04 +0100christo(~chris@81.96.113.213)
2020-11-20 17:40:20 +0100whatisRT(~whatisRT@2002:5b41:6a33:0:b44f:bf96:fd3:56a8) (Quit: ZNC 1.7.5 - https://znc.in)
2020-11-20 17:41:33 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2020-11-20 17:44:32 +0100acidjnk_new2(~acidjnk@p200300d0c719ff6800925201c24f6260.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-20 17:47:23 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 265 seconds)
2020-11-20 17:47:46 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-20 17:49:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 17:50:19 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se) (Ping timeout: 246 seconds)
2020-11-20 17:50:44 +0100noumenon(~daemon@113.51-175-156.customer.lyse.net)
2020-11-20 17:51:49 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Ping timeout: 264 seconds)
2020-11-20 17:51:49 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 17:51:58 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 17:53:15 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 17:53:17 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-eizsscpohqhxizqc)
2020-11-20 17:55:21 +0100Yumasi(~guillaume@2a01cb09b06b29eabd8cf63c98e88a0f.ipv6.abo.wanadoo.fr) (Ping timeout: 272 seconds)
2020-11-20 17:55:32 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 17:58:01 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-20 18:00:20 +0100noumenon(~daemon@113.51-175-156.customer.lyse.net) (Quit: Leaving)
2020-11-20 18:01:14 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Ping timeout: 256 seconds)
2020-11-20 18:01:26 +0100geekosaur(ac3a56ed@172.58.86.237)
2020-11-20 18:03:31 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-20 18:03:39 +0100Ariakenom(~Ariakenom@h-98-128-229-104.NA.cust.bahnhof.se)
2020-11-20 18:03:42 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2020-11-20 18:04:35 +0100electricityZZZZ(~electrici@108-216-157-17.lightspeed.sntcca.sbcglobal.net)
2020-11-20 18:04:51 +0100Saukk(~Saukk@2001:998:f9:2914:1c59:9bb5:b94c:4)
2020-11-20 18:05:20 +0100crdrost(~crdrost@2601:646:8280:85f0:90f7:1b03:f01f:afae)
2020-11-20 18:05:44 +0100cosimone(~cosimone@93-47-228-249.ip115.fastwebnet.it) (Read error: Connection reset by peer)
2020-11-20 18:05:59 +0100kritzefitz(~kritzefit@212.86.56.80)
2020-11-20 18:06:45 +0100alp(~alp@2a01:e0a:58b:4920:e473:db5a:5f8a:8d59) (Ping timeout: 272 seconds)
2020-11-20 18:11:35 +0100ubert1(~Thunderbi@p200300ecdf1e5361e6b318fffe838f33.dip0.t-ipconnect.de)
2020-11-20 18:12:32 +0100ubert(~Thunderbi@p200300ecdf1e5355e6b318fffe838f33.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2020-11-20 18:12:32 +0100ubert1ubert
2020-11-20 18:15:10 +0100dan64-(~dan64@dannyadam.com) (Quit: ZNC - http://znc.in)
2020-11-20 18:16:51 +0100Saukk(~Saukk@2001:998:f9:2914:1c59:9bb5:b94c:4) (Remote host closed the connection)
2020-11-20 18:17:00 +0100adamwespiser(~adamwespi@107.181.19.30) ()
2020-11-20 18:17:51 +0100dan64(~dan64@dannyadam.com)
2020-11-20 18:18:38 +0100 <sszark> I'm working on a module extension that adds new logic and re-exports the old one. but i can't figure out how to only import the things i'm using for the extension, while at the same time exporting everything the rest. https://termbin.com/0y6u
2020-11-20 18:18:54 +0100 <sszark> It seems like my local import for the extension part is overriding the full export in the module
2020-11-20 18:22:27 +0100s00pcan(~chris@107.181.165.217) (Ping timeout: 260 seconds)
2020-11-20 18:23:53 +0100s00pcan(~chris@075-133-056-178.res.spectrum.com)
2020-11-20 18:24:10 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 18:25:01 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl)
2020-11-20 18:27:51 +0100livvy(~livvy@gateway/tor-sasl/livvy)
2020-11-20 18:27:59 +0100 <geekosaur> you basically can't; if yiu're going to re-export the whole module, you need to import the whole module
2020-11-20 18:29:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2020-11-20 18:29:12 +0100 <sszark> Yeah, i figured as much. thanks
2020-11-20 18:29:15 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-20 18:30:00 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 18:31:19 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 18:31:26 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 18:32:09 +0100christo(~chris@81.96.113.213)
2020-11-20 18:35:36 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 18:36:16 +0100christo(~chris@81.96.113.213) (Ping timeout: 240 seconds)
2020-11-20 18:37:17 +0100knupfer(~Thunderbi@200116b824bb7e00d8226e797ccf94db.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2020-11-20 18:39:59 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net)
2020-11-20 18:40:24 +0100DataComputist(~lumeng@static-50-43-26-251.bvtn.or.frontiernet.net) ()
2020-11-20 18:41:18 +0100jonatanb(~jonatanb@83.24.155.27.ipv4.supernova.orange.pl) (Remote host closed the connection)
2020-11-20 18:49:38 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4)
2020-11-20 18:51:25 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-11-20 18:51:44 +0100connrs_(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 18:51:44 +0100connrs(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 18:52:01 +0100gproto23(~gproto23@unaffiliated/gproto23) (Ping timeout: 260 seconds)
2020-11-20 18:52:37 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 18:53:02 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Ping timeout: 260 seconds)
2020-11-20 18:55:07 +0100falafel_(~falafel@2601:547:1303:b30:7811:313f:d0f3:f9f4) (Ping timeout: 260 seconds)
2020-11-20 18:55:32 +0100gproto23(~gproto23@unaffiliated/gproto23)
2020-11-20 18:55:38 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Ping timeout: 272 seconds)
2020-11-20 18:55:56 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2020-11-20 18:56:42 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net)
2020-11-20 18:58:12 +0100connrs(~connrs@runciter.connrs.uk)
2020-11-20 18:58:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 18:58:50 +0100connrs_(~connrs@runciter.connrs.uk)
2020-11-20 18:59:06 +0100christo(~chris@81.96.113.213)
2020-11-20 18:59:12 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 19:00:34 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-20 19:00:53 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 19:00:53 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Read error: Connection reset by peer)
2020-11-20 19:01:10 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 19:01:14 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-20 19:01:32 +0100sand_dull(~theuser@c-73-149-95-105.hsd1.ct.comcast.net) (Ping timeout: 260 seconds)
2020-11-20 19:01:34 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 19:01:36 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Read error: Connection reset by peer)
2020-11-20 19:01:53 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 19:01:57 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Remote host closed the connection)
2020-11-20 19:02:54 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 19:03:46 +0100ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net)
2020-11-20 19:03:46 +0100ClaudiusMaximus(~claude@198.123.199.146.dyn.plus.net) (Changing host)
2020-11-20 19:03:46 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus)
2020-11-20 19:03:48 +0100 <tdammers> if the problem is that the full import clashes with names you define locally, you can do a qualified re-export
2020-11-20 19:04:17 +0100 <tdammers> module Foo (module Bar, overriddenStuff) where import qualified Bar
2020-11-20 19:04:36 +0100jespada(~jespada@90.254.245.49) (Quit: Leaving)
2020-11-20 19:04:57 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909)
2020-11-20 19:05:08 +0100qiu3344(~qiu3344@91.246.215.182)
2020-11-20 19:06:28 +0100Guest38767(~luke@24.148.52.186)
2020-11-20 19:06:34 +0100dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2020-11-20 19:06:42 +0100Guest38767(~luke@24.148.52.186) (Client Quit)
2020-11-20 19:08:58 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 19:10:39 +0100cosimone(~cosimone@2001:b07:ae5:db26:d821:4868:b9f6:2909) (Quit: cosimone)
2020-11-20 19:10:41 +0100Boomerang(~Boomerang@xd520f68c.cust.hiper.dk) (Ping timeout: 260 seconds)
2020-11-20 19:11:00 +0100whatisRT(~whatisRT@2002:5b41:6a33:0:b44f:bf96:fd3:56a8)
2020-11-20 19:11:07 +0100connrs(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 19:11:07 +0100connrs_(~connrs@runciter.connrs.uk) (Quit: ZNC 1.7.1 - https://znc.in)
2020-11-20 19:12:03 +0100livvy(~livvy@gateway/tor-sasl/livvy) (Ping timeout: 240 seconds)
2020-11-20 19:12:21 +0100connrs(~connrs@runciter.connrs.uk)
2020-11-20 19:12:29 +0100Entertainment(~entertain@104.246.132.210) ()
2020-11-20 19:12:58 +0100connrs_(~connrs@runciter.connrs.uk)
2020-11-20 19:13:03 +0100sondr3(54d33884@cm-84.211.56.132.getinternet.no)
2020-11-20 19:13:26 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 19:14:01 +0100Entertainment(~entertain@104.246.132.210)
2020-11-20 19:14:12 +0100christo(~chris@81.96.113.213)
2020-11-20 19:14:29 +0100 <sondr3> I'm tryng to get cabal repl to load a project local .ghci file but I can't get it to work, all I want to do is set OverloadedStrings by default and load another module as well
2020-11-20 19:14:34 +0100 <sondr3> No dice so far
2020-11-20 19:15:13 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Ping timeout: 264 seconds)
2020-11-20 19:15:50 +0100qiu3344(~qiu3344@91.246.215.182) (Quit: WeeChat 2.9)
2020-11-20 19:15:55 +0100 <sondr3> I'm on Cabal 3.2.0.0, and my .ghci file is :set -XOverloadedStrings\n:load Other.Thing
2020-11-20 19:16:00 +0100hidedagger(~nate@unaffiliated/hidedagger)
2020-11-20 19:16:15 +0100hidedagger(~nate@unaffiliated/hidedagger) (Client Quit)
2020-11-20 19:17:54 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 256 seconds)
2020-11-20 19:18:41 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2020-11-20 19:18:49 +0100christo(~chris@81.96.113.213) (Ping timeout: 264 seconds)
2020-11-20 19:19:04 +0100thc202(~thc202@unaffiliated/thc202) (Ping timeout: 240 seconds)
2020-11-20 19:20:08 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-20 19:20:24 +0100 <sondr3> Oh, it actually sets OverloadedStrings but don't load the other module
2020-11-20 19:20:48 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2020-11-20 19:20:57 +0100raichoo(~raichoo@213.240.178.58) (Quit: Lost terminal)
2020-11-20 19:23:24 +0100mstruebing(~mstruebin@2001:41d0:8:93c7::1) (Ping timeout: 240 seconds)
2020-11-20 19:25:38 +0100mstruebing(~mstruebin@ns399634.ip-5-39-81.eu)
2020-11-20 19:26:40 +0100conal(~conal@64.71.133.70) (Ping timeout: 272 seconds)
2020-11-20 19:27:54 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 19:29:42 +0100conal(~conal@66.115.157.112)
2020-11-20 19:30:44 +0100 <electricityZZZZ> so in 1990, designing novel chips was "too expensive", and this was also true in 2000, 2010,... but people have built a lot of fancy fab equipment now, and surely that equipment must last. can one do dirt cheap fabrication of ASICs on "outdated" nodes?
2020-11-20 19:30:47 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01f05e932a21001b8c.dip0.t-ipconnect.de)
2020-11-20 19:31:41 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2020-11-20 19:32:16 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 19:32:43 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2020-11-20 19:32:55 +0100conal(~conal@66.115.157.112) (Client Quit)
2020-11-20 19:34:39 +0100aarvar(~foewfoiew@50.35.43.33)
2020-11-20 19:35:42 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Quit: nineonine)
2020-11-20 19:36:01 +0100jedai42(~jedai@lfbn-dij-1-708-251.w90-100.abo.wanadoo.fr) (Ping timeout: 246 seconds)
2020-11-20 19:36:18 +0100rawles(~r@unaffiliated/rawles) (Ping timeout: 244 seconds)
2020-11-20 19:36:32 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se)
2020-11-20 19:37:30 +0100rawles(~r@unaffiliated/rawles)
2020-11-20 19:38:41 +0100christo(~chris@81.96.113.213)
2020-11-20 19:39:12 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2020-11-20 19:42:17 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 19:43:24 +0100geekosaur(ac3a56ed@172.58.86.237) (Ping timeout: 245 seconds)
2020-11-20 19:45:08 +0100hexfive(~hexfive@50-47-142-195.evrt.wa.frontiernet.net)
2020-11-20 19:45:13 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net)
2020-11-20 19:45:47 +0100turion(~turion@2a02:810d:8abf:c4a8:f450:eee7:f9b2:e5e6)
2020-11-20 19:46:20 +0100revprez_stg(~revprez_s@pool-108-49-213-40.bstnma.fios.verizon.net)
2020-11-20 19:46:46 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 265 seconds)
2020-11-20 19:53:00 +0100 <int-e> https://electronics.stackexchange.com/questions/7042/how-much-does-it-cost-to-have-a-custom-asic-m… hmm. interesting niche: turn working FPGAs into ASICs that have an FPGA-like fabric in the bottom layers, thereby saving on mask costs
2020-11-20 19:54:51 +0100jedai42(~jedai@lfbn-dij-1-708-251.w90-100.abo.wanadoo.fr)
2020-11-20 19:56:48 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 19:58:09 +0100geekosaur(ac3a56ed@172.58.86.237)
2020-11-20 20:01:02 +0100whatisRT(~whatisRT@2002:5b41:6a33:0:b44f:bf96:fd3:56a8) (Ping timeout: 260 seconds)
2020-11-20 20:01:16 +0100sondr3(54d33884@cm-84.211.56.132.getinternet.no) (Remote host closed the connection)
2020-11-20 20:01:25 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 264 seconds)
2020-11-20 20:01:50 +0100 <electricityZZZZ> right,... i'm saying that today, this might become more valuable than historically,...
2020-11-20 20:02:03 +0100 <electricityZZZZ> there also is https://www.intel.com/content/www/us/en/products/programmable/asic/easic-devices.html
2020-11-20 20:02:40 +0100 <electricityZZZZ> cloud services mean that if you make a special chip you can make it available to everybody pretty easily,...
2020-11-20 20:03:07 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 20:03:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 20:03:33 +0100berberman_(~berberman@unaffiliated/berberman)
2020-11-20 20:03:36 +0100 <geekosaur> but every time you turn around they come up with faster or more capable but more expensive fab, and people want to use that more capable
2020-11-20 20:03:58 +0100 <davean> electricityZZZZ: You can do cheap fabrication on old nodes - its common to do that. Its just that for computation its not useful.
2020-11-20 20:04:09 +0100 <electricityZZZZ> well it's a competition between what you can do in software on a CPU today and those gains
2020-11-20 20:04:12 +0100berberman(~berberman@unaffiliated/berberman) (Ping timeout: 260 seconds)
2020-11-20 20:04:25 +0100 <electricityZZZZ> vs an FPGA or an ASIC (fabricated on an old node, at least to begin with)
2020-11-20 20:04:32 +0100 <davean> electricityZZZZ: so they're used for non-computational things usually, or microcontrolers, etc.
2020-11-20 20:05:08 +0100alp(~alp@2a01:e0a:58b:4920:c40b:63d1:e6b8:9277)
2020-11-20 20:05:54 +0100 <electricityZZZZ> furthermore if your software can be programmed so that the process from CPU all the way to ASIC was smooth, that would be pretty great
2020-11-20 20:07:10 +0100tom__(~tom@2a00:23c8:970a:3501:38a6:4546:df42:c1cb)
2020-11-20 20:08:01 +0100salumu(~sMuNiX@vlnsm8-montreal02-142-122-8-233.internet.virginmobile.ca)
2020-11-20 20:08:40 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2020-11-20 20:10:38 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2020-11-20 20:11:12 +0100zincy__(~tom@2a00:23c8:970a:3501:9884:7ab1:3658:f1fb) (Ping timeout: 260 seconds)
2020-11-20 20:11:13 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 20:11:25 +0100sMuNiX(~sMuNiX@vlnsm8-montreal02-142-122-8-233.internet.virginmobile.ca) (Ping timeout: 265 seconds)
2020-11-20 20:11:54 +0100 <davean> electricityZZZZ: I find your tautology compelling.
2020-11-20 20:12:53 +0100 <electricityZZZZ> what are you referring to when you say my tautology
2020-11-20 20:13:00 +0100 <electricityZZZZ> the "smooth process from CPU to ASIC"?
2020-11-20 20:14:07 +0100 <davean> yes
2020-11-20 20:14:16 +0100 <electricityZZZZ> yeah
2020-11-20 20:14:42 +0100 <electricityZZZZ> furthermore, the ASIC aspect of things can help with revenue models
2020-11-20 20:15:35 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 20:15:54 +0100howdoi(uid224@gateway/web/irccloud.com/x-mmsjxvzuqvfjlnly)
2020-11-20 20:16:01 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 20:16:21 +0100 <int-e> ASIC for computation... I guess the famous examples where this has been done are ASIC bitcoin miners (sigh...) and Google's TPUs?
2020-11-20 20:16:41 +0100 <electricityZZZZ> yeah but wouldn't redis-as-an-ASIC make sense?
2020-11-20 20:16:59 +0100 <int-e> no
2020-11-20 20:17:07 +0100 <davean> int-e: thats the famous example vs. like network controllers?
2020-11-20 20:17:12 +0100 <int-e> too specific, and it's memory
2020-11-20 20:17:25 +0100 <electricityZZZZ> there might also be security advantages to having a firewall etched into an ASIC
2020-11-20 20:17:27 +0100 <int-e> davean: do those count as computation?
2020-11-20 20:17:29 +0100 <davean> electricityZZZZ: also a lot of NVMe drives?
2020-11-20 20:18:31 +0100 <davean> int-e: They run offload, application specific offload, packet routing, delivery, firewalls, etc? Its how we can manage multi 100Gb connections usefully to single systems and VMs.
2020-11-20 20:18:41 +0100luke(~luke@24.148.52.186)
2020-11-20 20:18:43 +0100 <davean> They run bytecode interpriters
2020-11-20 20:18:46 +0100 <electricityZZZZ> davean: are you saying that NVMe drives already have hardware key-value stores onboard?
2020-11-20 20:19:03 +0100 <davean> electricityZZZZ: No, but thats true. What I'm saying is higher end NVMe drives are run by FPGAs.
2020-11-20 20:19:05 +0100lukeGuest69432
2020-11-20 20:19:36 +0100 <electricityZZZZ> davean: yeah so that's "equivalent to an ASIC", mostly
2020-11-20 20:19:47 +0100 <davean> what?
2020-11-20 20:20:22 +0100 <int-e> FPGAs have a far lower one-time cost. That's basically their point.
2020-11-20 20:20:24 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 20:20:35 +0100Guest69432(~luke@24.148.52.186) (Client Quit)
2020-11-20 20:20:41 +0100christo(~chris@81.96.113.213)
2020-11-20 20:20:57 +0100 <davean> int-e: no, also reprogrammability. Which is why you see them in any non-low-end NIC
2020-11-20 20:21:04 +0100 <electricityZZZZ> i'm saying perhaps your FPGA-on-NVMe device sufficienly covers more efficient CPU offloading to the point that it isn't worth moving to ASIC in many/most applications
2020-11-20 20:21:10 +0100 <int-e> davean: Obviously there are tons of ASICs around. They are cheap *if* you buy them in the 100s of thousands or millions.
2020-11-20 20:21:13 +0100 <davean> Its not FPGA-on-NVMe
2020-11-20 20:21:30 +0100 <davean> Its FPGA-is-what-makes-it-NVMe
2020-11-20 20:21:36 +0100 <electricityZZZZ> oh wow really?
2020-11-20 20:21:52 +0100 <davean> int-e: Except they're not flexable.
2020-11-20 20:22:04 +0100 <davean> int-e: so their cheapness is moot in a lot of applications - like NICs
2020-11-20 20:22:05 +0100 <int-e> (And I do distinguish between FPGAs and ASICs)
2020-11-20 20:22:21 +0100luke_(~luke@bitnomial/staff/luke)
2020-11-20 20:22:34 +0100 <int-e> davean: I don't disagree.
2020-11-20 20:23:14 +0100 <electricityZZZZ> davean: but you said the FPGA applies to high end NVMe (i.e. lower end NVMe drives don't have the FPGA), so what you are saying isn't self-consistent
2020-11-20 20:23:29 +0100 <davean> No, it is, I think you're just lost.
2020-11-20 20:23:42 +0100 <davean> There has to be a controller to turn flash into NVMe
2020-11-20 20:23:50 +0100lambuf(~lambuf@95.164.72.231)
2020-11-20 20:23:59 +0100lambuf(~lambuf@95.164.72.231) (Remote host closed the connection)
2020-11-20 20:24:03 +0100 <davean> that controller on lower end devices is a small CPU. On higher end devices its a medium size FPGA.
2020-11-20 20:24:08 +0100 <electricityZZZZ> but my application doesn't distribute its program to that controller
2020-11-20 20:24:20 +0100 <davean> Some do
2020-11-20 20:24:46 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb)
2020-11-20 20:25:25 +0100 <davean> And the POINT of smartnics, etc is specificly to bake stuff the OS would be doing in software into the data plane of the NIC.
2020-11-20 20:25:26 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 20:26:20 +0100stree(~stree@50-108-97-52.adr01.mskg.mi.frontiernet.net) (Quit: Caught exception)
2020-11-20 20:26:20 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com) (Remote host closed the connection)
2020-11-20 20:26:38 +0100stree(~stree@50-108-97-52.adr01.mskg.mi.frontiernet.net)
2020-11-20 20:26:45 +0100 <electricityZZZZ> yeah,...
2020-11-20 20:26:52 +0100 <davean> And some NVMe is run as a KV store
2020-11-20 20:26:55 +0100 <davean> also some HDs
2020-11-20 20:27:04 +0100 <davean> there are NVMe modes
2020-11-20 20:27:06 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 20:27:10 +0100cosimone(~cosimone@5.171.24.75)
2020-11-20 20:27:35 +0100 <electricityZZZZ> ...and i guess some intel CPUs are going to be shipping with integrated FPGAs. ... shouldn't we have a way of programming that in a productive manner? that would be sort of the first step in this logical chain
2020-11-20 20:27:45 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com)
2020-11-20 20:28:15 +0100knupfer(~Thunderbi@i5E86B41D.versanet.de)
2020-11-20 20:28:37 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 20:28:51 +0100 <davean> Oh are Intel CPUs still relivent?
2020-11-20 20:28:53 +0100acidjnk_new2(~acidjnk@p200300d0c719ff68f4d20d2f20034438.dip0.t-ipconnect.de)
2020-11-20 20:29:41 +0100 <monochrom> Is it true that on Windows 64-bit, 64-bit GHC #defines mingw32_HOST_OS, and it's stlll "32" there?
2020-11-20 20:29:43 +0100 <int-e> davean: apart from wishful thinking, why would they go away...
2020-11-20 20:29:55 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 246 seconds)
2020-11-20 20:29:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2020-11-20 20:30:05 +0100 <davean> int-e: Because they've been pretty terrible for years and mostly uneconomical buys.
2020-11-20 20:30:30 +0100 <davean> Its sad
2020-11-20 20:31:04 +0100 <davean> They were still relivent in laptops, but recently that doesn't even seem true.
2020-11-20 20:31:25 +0100 <int-e> "relevant"
2020-11-20 20:31:50 +0100Wolperting(~Wolpertin@95.164.72.231)
2020-11-20 20:31:54 +0100dhouthoo(~dhouthoo@ptr-eiv6509pb4ifhdr9lsd.18120a2.ip6.access.telenet.be) (Quit: WeeChat 2.9)
2020-11-20 20:31:56 +0100 <monochrom> Actually I should hop over to #ghc for that.
2020-11-20 20:31:56 +0100vsiddharth(~user@135-180-144-154.fiber.dynamic.sonic.net)
2020-11-20 20:31:59 +0100 <electricityZZZZ> but they have so much fab infrastructure and so many people
2020-11-20 20:32:00 +0100christo(~chris@81.96.113.213)
2020-11-20 20:32:13 +0100 <geekosaur> so did itanium
2020-11-20 20:32:19 +0100 <electricityZZZZ> and they aren't that far behind
2020-11-20 20:32:24 +0100 <davean> electricityZZZZ: Uh, they aren't?
2020-11-20 20:32:33 +0100 <merijn> geekosaur: You misspelled the Itanic ;)
2020-11-20 20:32:33 +0100Wol(5fa448e7@95.164.72.231)
2020-11-20 20:32:51 +0100 <int-e> geekosaur: Even Itanium somehow took off for a while... I never understood why.
2020-11-20 20:33:03 +0100 <merijn> int-e: Because it's a super cool architecture
2020-11-20 20:33:21 +0100 <merijn> int-e: Itanium wasn't bad, it was just severely lacking in software support (i.e. compilers)
2020-11-20 20:33:22 +0100 <davean> int-e: I saw a big push to get it into places - I even ran some code on like I think it was a 32-way one? It was fun! But I certainly didn't have to pay for that ...
2020-11-20 20:33:24 +0100 <int-e> Larrabee is the only project that failed completely
2020-11-20 20:33:30 +0100 <merijn> int-e: Itanium taught is one thing
2020-11-20 20:33:32 +0100Wol(5fa448e7@95.164.72.231) (Remote host closed the connection)
2020-11-20 20:33:39 +0100gproto23(~gproto23@unaffiliated/gproto23) (Ping timeout: 265 seconds)
2020-11-20 20:34:00 +0100 <electricityZZZZ> merijn: yeah lack of software support for itanium is partially why i am asking about programming cpus with integrated FPGAs
2020-11-20 20:34:05 +0100 <int-e> merijn: at least two things... a) VLIW takes too much memory bandwidth b) VLIW and backward compatibility don't mix
2020-11-20 20:34:09 +0100Wol(5fa448e7@95.164.72.231)
2020-11-20 20:34:10 +0100 <merijn> "No one will buy shit if it can't run x86" :p ARM might stand a chance because they've built up software support via mobile and the big guys are interested to low server power
2020-11-20 20:34:29 +0100electricityZZZZwill be back later
2020-11-20 20:34:34 +0100 <merijn> electricityZZZZ: Man, the software for dedicated FPGAs is already shite :p
2020-11-20 20:34:40 +0100 <davean> merijn: Yah, I mean mobile is the main platform these days, so ...
2020-11-20 20:34:43 +0100 <merijn> How would you even reasonably use said FPGA :)
2020-11-20 20:34:46 +0100 <davean> Though x86 isn't going anywhere soon.
2020-11-20 20:35:07 +0100Wolperting(~Wolpertin@95.164.72.231) (Remote host closed the connection)
2020-11-20 20:35:13 +0100 <merijn> Oracle had integrated FPGA and was working on some cool hardware before they killed SPARC
2020-11-20 20:35:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2020-11-20 20:36:00 +0100Wol(5fa448e7@95.164.72.231) (Remote host closed the connection)
2020-11-20 20:36:02 +0100 <int-e> (b)... AIUI, the second generation Itaniums had pretty much all the superscalar architecture complexity that EPIC was supposed to do away with.)
2020-11-20 20:36:58 +0100christo(~chris@81.96.113.213) (Ping timeout: 272 seconds)
2020-11-20 20:38:36 +0100Rudd0(~Rudd0@185.189.115.98) (Ping timeout: 240 seconds)
2020-11-20 20:38:57 +0100dustypacer(~pi@2600:6c50:80:2f4a:e9d0:6569:1cea:d1d4) (Ping timeout: 260 seconds)
2020-11-20 20:39:48 +0100cosimone(~cosimone@5.171.24.75) (Quit: cosimone)
2020-11-20 20:39:52 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 20:39:54 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 20:40:45 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 240 seconds)
2020-11-20 20:42:25 +0100christo(~chris@81.96.113.213)
2020-11-20 20:42:35 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2020-11-20 20:44:16 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 20:46:05 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-11-20 20:46:32 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515) (Ping timeout: 260 seconds)
2020-11-20 20:46:37 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 20:49:31 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2020-11-20 20:49:42 +0100zariuq(~zar@fw1.ciirc.cvut.cz) (Quit: Leaving)
2020-11-20 20:49:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 20:52:30 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 20:53:36 +0100christo(~chris@81.96.113.213)
2020-11-20 20:54:15 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 20:55:36 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-11-20 20:56:05 +0100gproto23(~gproto23@unaffiliated/gproto23)
2020-11-20 20:56:31 +0100hackagediscord-haskell 1.8.1 - Write bots for Discord in Haskell https://hackage.haskell.org/package/discord-haskell-1.8.1 (Aquarial)
2020-11-20 20:56:34 +0100wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net)
2020-11-20 20:57:45 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 240 seconds)
2020-11-20 20:58:28 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net) (Ping timeout: 260 seconds)
2020-11-20 20:58:47 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 20:59:16 +0100MasseR(~MasseR@51.15.143.128) (Quit: The Lounge - https://thelounge.chat)
2020-11-20 20:59:51 +0100 <Sose> anyone had an issue with haskell LSP server where they can't use programs like "hlint" or a formatter? happens when I try from either Emacs or VSCode so it's probably not an editor integration issue...? here is a fresh log from VSCode doing clear log, restart server and format file... the weird bit is at the very end https://gist.github.com/Sose/dec29fa3781f2b3df1eab91fadf5f4df
2020-11-20 20:59:51 +0100MasseR(~MasseR@51.15.143.128)
2020-11-20 21:00:32 +0100 <Sose> it's looking for a file called "/opt/ghc/8.8.4/lib/ghc-8.8.4/settings" but there's not even a /opt/ghc directory on my system and rest of the server and integration seems to work okay
2020-11-20 21:00:40 +0100jonatanb(jonatanb@gateway/vpn/protonvpn/jonatanb) (Remote host closed the connection)
2020-11-20 21:04:53 +0100AlterEgo-(~ladew@124-198-158-163.dynamic.caiway.nl)
2020-11-20 21:07:06 +0100 <maerwald> does someone know what happens if the parser in Aesons fromJSONKey fails? It appears it still parses the json and defaults to something weird
2020-11-20 21:08:30 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 21:11:24 +0100p-core(~Thunderbi@2001:718:1e03:5128:2ab7:7f35:48a1:8515)
2020-11-20 21:13:17 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 265 seconds)
2020-11-20 21:14:37 +0100ronbrz(~ronbrz@207.229.174.134) (Ping timeout: 264 seconds)
2020-11-20 21:15:43 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-11-20 21:18:42 +0100 <Sose> regarding my issue, apparently it's known and there's a workaround for now. you always end up finding the solution 15 minutes after asking... https://github.com/haskell/haskell-language-server/issues/412
2020-11-20 21:18:58 +0100Kaivo(~Kaivo@104-200-86-99.mc.derytele.com) (Quit: offline for the weekend)
2020-11-20 21:19:21 +0100 <texasmynsted> Beyond this (https://github.com/joelburget/easytest) any recommendations for testing tutorials for Haskell?
2020-11-20 21:22:54 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 21:25:16 +0100yahb(xsbot@haskell/bot/yahb) (Ping timeout: 268 seconds)
2020-11-20 21:27:16 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 21:27:36 +0100ggole(~ggole@2001:8003:8119:7200:3080:9a4e:22db:fd6d) (Quit: Leaving)
2020-11-20 21:27:54 +0100yahb(xsbot@178.219.36.155)
2020-11-20 21:27:54 +0100yahb(xsbot@178.219.36.155) (Changing host)
2020-11-20 21:27:54 +0100yahb(xsbot@haskell/bot/yahb)
2020-11-20 21:29:26 +0100turion(~turion@2a02:810d:8abf:c4a8:f450:eee7:f9b2:e5e6) (Quit: Leaving.)
2020-11-20 21:30:45 +0100luke_luke
2020-11-20 21:30:55 +0100 <maerwald> https://github.com/bos/aeson/blob/8579faf30e0f977425fbf330038fb1d5c2c34727/Data/Aeson/Types/FromJS… hmm
2020-11-20 21:33:06 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com) (Ping timeout: 256 seconds)
2020-11-20 21:34:49 +0100bliminse(~bliminse@host109-156-197-211.range109-156.btcentralplus.com)
2020-11-20 21:36:26 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2020-11-20 21:37:23 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 21:40:02 +0100pavonia(~user@unaffiliated/siracusa)
2020-11-20 21:40:27 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 21:40:27 +0100DavidEichmann(~david@62.110.198.146.dyn.plus.net) (Remote host closed the connection)
2020-11-20 21:40:36 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Ping timeout: 240 seconds)
2020-11-20 21:41:30 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-fgwigxpmxrbdsiil)
2020-11-20 21:41:45 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 21:44:56 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Ping timeout: 240 seconds)
2020-11-20 21:45:36 +0100yummy(2fe3e53b@047-227-229-059.res.spectrum.com)
2020-11-20 21:45:38 +0100sulu(~sulu@unaffiliated/sulu) (Quit: goodbye)
2020-11-20 21:45:49 +0100 <yummy> what does the +d mean in :t +d (+)?
2020-11-20 21:46:30 +0100 <glguy> it looks like it defaults the type
2020-11-20 21:46:32 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 21:46:49 +0100 <glguy> :t +d (+)
2020-11-20 21:46:50 +0100 <lambdabot> Integer -> Integer -> Integer
2020-11-20 21:46:50 +0100 <glguy> :t (+)
2020-11-20 21:46:51 +0100 <lambdabot> Num a => a -> a -> a
2020-11-20 21:47:22 +0100 <yummy> is there documentation on this somewhere?
2020-11-20 21:47:33 +0100 <sm[m]> texasmynsted: check out tasty and hspec's docs, they are the big two
2020-11-20 21:47:41 +0100 <glguy> I'd guess it's in the GHC User's Guide
2020-11-20 21:47:52 +0100 <texasmynsted> okay.
2020-11-20 21:47:59 +0100 <texasmynsted> Switching to Tasty
2020-11-20 21:48:08 +0100 <glguy> https://downloads.haskell.org/ghc/latest/docs/html/users_guide/ghci.html#ghci-cmd-:type
2020-11-20 21:48:14 +0100 <texasmynsted> EasyTest was not compiling
2020-11-20 21:51:03 +0100aldum(~vishera@aldum.pw) (Quit: Lost terminal)
2020-11-20 21:51:20 +0100aldum(~vishera@aldum.pw)
2020-11-20 21:51:49 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 21:52:01 +0100Deide(~Deide@217.155.19.23)
2020-11-20 21:53:52 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 260 seconds)
2020-11-20 21:54:10 +0100sulu(~sulu@unaffiliated/sulu)
2020-11-20 21:54:15 +0100sulu(~sulu@unaffiliated/sulu) (Client Quit)
2020-11-20 21:54:45 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2020-11-20 21:56:16 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 240 seconds)
2020-11-20 21:57:45 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 265 seconds)
2020-11-20 21:58:10 +0100coot(~coot@37.30.49.253.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2020-11-20 21:58:38 +0100luke(~luke@bitnomial/staff/luke) (Quit: sleep)
2020-11-20 21:59:22 +0100 <dsal> I like tasty. I mostly aim towards quickcheck, with some plain assertions and occasionally golden tests.
2020-11-20 21:59:34 +0100 <dsal> But tasty does all the things I want.
2020-11-20 22:00:44 +0100conal(~conal@66.115.157.112)
2020-11-20 22:01:34 +0100siloxid(~user@unaffiliated/siloxid)
2020-11-20 22:03:47 +0100conal(~conal@66.115.157.112) (Client Quit)
2020-11-20 22:04:00 +0100oish(~charlie@228.25.169.217.in-addr.arpa)
2020-11-20 22:06:05 +0100vicfred(~vicfred@unaffiliated/vicfred)
2020-11-20 22:06:15 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 22:06:44 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net)
2020-11-20 22:08:14 +0100vishnix(~vishwas@c-24-14-13-197.hsd1.il.comcast.net)
2020-11-20 22:08:14 +0100vishnix(~vishwas@c-24-14-13-197.hsd1.il.comcast.net) (Client Quit)
2020-11-20 22:08:23 +0100vishnix(~vishwas@c-24-14-13-197.hsd1.il.comcast.net)
2020-11-20 22:08:29 +0100invaser(~Thunderbi@31.148.23.125)
2020-11-20 22:08:57 +0100conal(~conal@64.71.133.70)
2020-11-20 22:11:13 +0100alp(~alp@2a01:e0a:58b:4920:c40b:63d1:e6b8:9277) (Ping timeout: 272 seconds)
2020-11-20 22:11:20 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 272 seconds)
2020-11-20 22:12:14 +0100Inoperable(~PLAYER_1@fancydata.science)
2020-11-20 22:13:41 +0100nineonine_(~nineonine@50.216.62.2)
2020-11-20 22:14:36 +0100nineonine(~nineonine@S01061cabc0b095f3.vf.shawcable.net) (Ping timeout: 240 seconds)
2020-11-20 22:14:36 +0100nineonine_nineonine
2020-11-20 22:15:49 +0100conal(~conal@64.71.133.70) (Ping timeout: 264 seconds)
2020-11-20 22:16:43 +0100Kaiepi(~Kaiepi@nwcsnbsc03w-47-55-225-82.dhcp-dynamic.fibreop.nb.bellaliant.net)
2020-11-20 22:16:44 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2020-11-20 22:17:15 +0100luke(~luke@bitnomial/staff/luke)
2020-11-20 22:17:18 +0100conal(~conal@64.71.133.70)
2020-11-20 22:17:25 +0100jcd(~user@2601:282:1300:7cb0::5be7)
2020-11-20 22:17:52 +0100cads(~cads@ip-64-72-99-232.lasvegas.net) (Ping timeout: 256 seconds)
2020-11-20 22:17:59 +0100 <jcd> howdy
2020-11-20 22:19:27 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 272 seconds)
2020-11-20 22:19:27 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 22:20:04 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 22:23:10 +0100son0p(~son0p@181.136.122.143)
2020-11-20 22:23:15 +0100jwynn6(~jwynn6@050-088-122-078.res.spectrum.com) (Quit: The Lounge - https://thelounge.chat)
2020-11-20 22:23:22 +0100oish(~charlie@228.25.169.217.in-addr.arpa) (Ping timeout: 272 seconds)
2020-11-20 22:25:35 +0100 <Zetagon> hello!
2020-11-20 22:28:14 +0100borne(~fritjof@200116b86455d000f1dc39039d201adf.dip.versatel-1u1.de) (Ping timeout: 264 seconds)
2020-11-20 22:28:57 +0100vishnix(~vishwas@c-24-14-13-197.hsd1.il.comcast.net) (Quit: leaving)
2020-11-20 22:29:30 +0100hackageheap-console 0.1.0.0 - interactively inspect Haskell values at runtime https://hackage.haskell.org/package/heap-console-0.1.0.0 (TheMatten)
2020-11-20 22:29:37 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-kwmvlnupagfhstlw) (Quit: Connection closed for inactivity)
2020-11-20 22:29:55 +0100yummy(2fe3e53b@047-227-229-059.res.spectrum.com) (Remote host closed the connection)
2020-11-20 22:30:06 +0100 <texasmynsted> https://yannesposito.com/Scratch/en/blog/Holy-Haskell-Starter/ 😂
2020-11-20 22:30:06 +0100 <jcd> Hello! I need some help. I don't know what to do with monad that gets returned from a library function.
2020-11-20 22:30:26 +0100 <Rembane> jcd: Which monad and which library function?
2020-11-20 22:31:08 +0100 <jcd> The monad comes from a function called 'parseRequest' from the 'Network.HTTP.Client' module.
2020-11-20 22:31:17 +0100 <dminuoso> jcd: a "monad" is generally not something you get back, "monad" is just a bizarre name for an interface.
2020-11-20 22:31:45 +0100 <dminuoso> jcd: So say you get something back of type T, and T has monad, it may be less helpful to think "you're getting a monad back". You're just getting a value back.
2020-11-20 22:32:04 +0100 <dminuoso> (Or more correctly, you get something back of type `T S`, and T has monad)
2020-11-20 22:32:29 +0100 <jcd> Then how do I extract the 'Request' out of 'm0 Request'?
2020-11-20 22:32:34 +0100 <dminuoso> That depends!
2020-11-20 22:32:38 +0100 <dminuoso> jcd: parseRequest :: MonadThrow m => String -> m Request
2020-11-20 22:32:39 +0100 <jcd> I thought fmap-like functions were the way
2020-11-20 22:32:48 +0100 <dminuoso> Is a polymorphic value. First, you must understand that the choice of `m` is yours.
2020-11-20 22:32:54 +0100 <dminuoso> You decide what `m` you want.
2020-11-20 22:32:55 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2020-11-20 22:33:05 +0100chkno(~chkno@75-7-2-127.lightspeed.sntcca.sbcglobal.net)
2020-11-20 22:33:10 +0100 <jcd> then, 'Just'?
2020-11-20 22:33:15 +0100 <dminuoso> You can pick any `m` you like, under the constraint that it has an instance MonadThrow.
2020-11-20 22:33:27 +0100 <dminuoso> Well, let's see. Just is a data constructor, the matching type constructor is Maybe.
2020-11-20 22:33:34 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-20 22:33:37 +0100 <dminuoso> Check whether an `instance MonadThrow Maybe` exists to see whether its a valid choice
2020-11-20 22:33:53 +0100 <dminuoso> https://hackage.haskell.org/package/exceptions-0.10.4/docs/Control-Monad-Catch.html#t:MonadThrow
2020-11-20 22:33:59 +0100 <jcd> On it.
2020-11-20 22:35:37 +0100conal(~conal@64.71.133.70) (Ping timeout: 264 seconds)
2020-11-20 22:36:56 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Client Quit)
2020-11-20 22:37:56 +0100knupfer(~Thunderbi@i5E86B41D.versanet.de) (Ping timeout: 240 seconds)
2020-11-20 22:38:01 +0100Zetagon(~leo@c151-177-52-233.bredband.comhem.se) (Remote host closed the connection)
2020-11-20 22:38:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2020-11-20 22:38:49 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de)
2020-11-20 22:41:03 +0100 <jcd> So, I see that it is a valid choice! I don't know if it's the one I _should_ choose though.
2020-11-20 22:41:03 +0100conal(~conal@172.255.125.150)
2020-11-20 22:42:21 +0100nyaomi(~naomi@2604:6000:1509:c86e:c878:29ff:fedf:ce89) (Quit: meow)
2020-11-20 22:42:22 +0100geekosaur(ac3a56ed@172.58.86.237) (Remote host closed the connection)
2020-11-20 22:42:28 +0100 <dminuoso> That's up to you. In this case, the idea is "parseRequest" could fail. Rather than forcing the function to use say `Maybe` or `IO` to communicate failure in, it defers the choice to you.
2020-11-20 22:42:51 +0100 <sm[m]> interactively inspect Haskell values at runtime ... that's interesting
2020-11-20 22:42:51 +0100 <dminuoso> It says "Hey, you pick something of type `m`, as long as I can throw an exception with it", for some value of "exception"
2020-11-20 22:43:23 +0100 <sm[m]> doc: https://hackage.haskell.org/package/heap-console-0.1.0.0/docs/Heap-Console.html
2020-11-20 22:45:08 +0100 <dminuoso> Internally the package will use `throwM (InvalidUrlException s "Invalid URL")` if it failed to parse your input. What this ends up doing depends on your choice, if you pick Maybe, you get a Nothing back.
2020-11-20 22:45:12 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2020-11-20 22:45:19 +0100 <dminuoso> If you pick IO, you get an IO exception
2020-11-20 22:45:27 +0100 <dminuoso> And so forth
2020-11-20 22:45:30 +0100hackagepredicate-typed 0.7.4.5 - Predicates, Refinement types and Dsl https://hackage.haskell.org/package/predicate-typed-0.7.4.5 (gbwey)
2020-11-20 22:46:09 +0100 <jcd> Okay! Got it! How would I properly wrap it? Is there an approriate place to show a 3-line code example?
2020-11-20 22:46:20 +0100 <dminuoso> What do you mean with "wrap it"?
2020-11-20 22:46:25 +0100nyaomi(~naomi@cpe-74-75-6-125.maine.res.rr.com)
2020-11-20 22:46:27 +0100 <dminuoso> @where paste
2020-11-20 22:46:27 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at eg https://paste.tomsmeding.com
2020-11-20 22:47:10 +0100 <jcd> https://paste.tomsmeding.com/5trqeFMa
2020-11-20 22:47:35 +0100 <jcd> Would it be better to say 'assign'?
2020-11-20 22:47:59 +0100 <dminuoso> jcd: I see. So since httpLbs puts you into IO already, you could chose IO for parseRequest too
2020-11-20 22:48:38 +0100 <dminuoso> Also note that this use of `Maybe` is not valid
2020-11-20 22:48:50 +0100 <dminuoso> Sadly, there's not a very explicit way to make the choice, it is inferred on usage
2020-11-20 22:48:52 +0100 <dminuoso> Say, if you wrote:
2020-11-20 22:49:12 +0100johnw_(~johnw@haskell/developer/johnw)
2020-11-20 22:49:14 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com)
2020-11-20 22:49:18 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 22:49:22 +0100 <dminuoso> let f :: Maybe Request; f = parseRequest "https://google.de" in ...
2020-11-20 22:49:38 +0100 <dminuoso> Then the choice is made in the type signature. Equivalently if you wrote:
2020-11-20 22:49:49 +0100 <dminuoso> case parseRequest "https://google.de" of
2020-11-20 22:49:51 +0100 <dminuoso> Nothing -> ...
2020-11-20 22:49:54 +0100 <dminuoso> Just x -> ...
2020-11-20 22:49:57 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2020-11-20 22:50:19 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 22:50:21 +0100 <dminuoso> Then the choice is implicit because GHC can infer Maybe from the data constructors in the pattern matching.
2020-11-20 22:51:07 +0100 <dminuoso> For your case, IO is probably a fine choice. Then you can just write: https://paste.tomsmeding.com/USndzrdo
2020-11-20 22:51:20 +0100 <dminuoso> (The choice of IO is inferred based on the context automatically)
2020-11-20 22:51:56 +0100ubert(~Thunderbi@p200300ecdf1e5361e6b318fffe838f33.dip0.t-ipconnect.de) (Remote host closed the connection)
2020-11-20 22:52:31 +0100hackagephonetic-languages-simplified-common 0.2.1.0 - A simplified version of the phonetic-languages-functionality https://hackage.haskell.org/package/phonetic-languages-simplified-common-0.2.1.0 (OleksandrZhabenko)
2020-11-20 22:52:43 +0100 <jcd> Because of the 'do'!
2020-11-20 22:52:50 +0100 <dminuoso> no, not the do
2020-11-20 22:52:54 +0100 <jcd> Oh!
2020-11-20 22:52:59 +0100 <jcd> the '<-'
2020-11-20 22:53:04 +0100 <dminuoso> Also, no.
2020-11-20 22:53:12 +0100 <dminuoso> If you keep guessing, you'll eventually figure it out.
2020-11-20 22:53:14 +0100 <dminuoso> :)
2020-11-20 22:53:25 +0100 <dminuoso> Well, the `do` notation is related, but not quite the point
2020-11-20 22:53:33 +0100 <minimario> quick question: what's the logic behind making andM return Just False instead of Nothing when we call it on andM (Just False) Nothing?
2020-11-20 22:53:45 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 22:54:16 +0100elliott__(~elliott@pool-108-51-141-12.washdc.fios.verizon.net)
2020-11-20 22:54:50 +0100 <dminuoso> jcd: https://paste.tomsmeding.com/Xx49wa4s here there's two points of interest.
2020-11-20 22:55:04 +0100ski. o O ( <https://hackage.haskell.org/package/hood>,<https://hackage.haskell.org/package/GHood>,<https://wiki.haskell.org/Debugging#Printf_and_friends> )
2020-11-20 22:55:40 +0100 <dminuoso> jcd: First there's the type signature telling us the do-notation uses IO. You left it out, which gives us another point of inference
2020-11-20 22:55:44 +0100 <dminuoso> The type of httpLbs
2020-11-20 22:56:15 +0100 <jcd> Since the httpLbs is the expression that gets returned?
2020-11-20 22:56:27 +0100 <dminuoso> Not because it's returned, just its presence.
2020-11-20 22:56:33 +0100 <dminuoso> It could be on any line in the do block, in fact.
2020-11-20 22:56:50 +0100 <dminuoso> Roughly, do-notation is just a syntax desugarer
2020-11-20 22:57:15 +0100 <dminuoso> It desugars uses of line breaks and <- into (>>) and (>>=)
2020-11-20 22:57:32 +0100 <dminuoso> % :t (>>)
2020-11-20 22:57:33 +0100 <yahb> dminuoso: Monad m => m a -> m b -> m b
2020-11-20 22:57:34 +0100 <dminuoso> % :t (>>+)
2020-11-20 22:57:35 +0100 <yahb> dminuoso: ; <interactive>:1:1: error:; * Variable not in scope: >>+; * Perhaps you meant one of these: `>>=' (imported from Prelude), `>>' (imported from Prelude), `>>>' (imported from Control.Arrow)
2020-11-20 22:57:37 +0100 <dminuoso> % :t (>>=)
2020-11-20 22:57:37 +0100 <yahb> dminuoso: Monad m => m a -> (a -> m b) -> m b
2020-11-20 22:57:41 +0100 <ski> minimario : it's short-circuiting. since the first action (successfully) executes to `False', we abort and don't try the second
2020-11-20 22:57:56 +0100 <dminuoso> jcd: Do you see in each type, there's multiple occurences of the *same* m?
2020-11-20 22:58:35 +0100rprije(~rprije@124.148.131.132)
2020-11-20 22:58:42 +0100 <dminuoso> jcd: Recall, same story as above! This is a polymorphic value, *you* decide what you want for each of those type variables. So if you make the choice `IO` for the first `m` in say (>>=), then the other `m` in (>>=) become IO too.
2020-11-20 22:58:54 +0100 <ski> minimario : similarly, if you did `andM readLn readLn', and you typed in `False' for the first one, it would abort the `andM', and not try executing the second `readLn'
2020-11-20 22:59:45 +0100 <dminuoso> jcd: It's roughly similar to if you had `a + b + c + d`, and if `a` was of type Int, then `b`, `c` and `d` have to be of type Int.
2020-11-20 22:59:51 +0100 <dminuoso> % :t (+)
2020-11-20 22:59:51 +0100 <yahb> dminuoso: Num a => a -> a -> a
2020-11-20 22:59:52 +0100 <ski> minimario : if you don't want short-circuiting, you can use `liftM2 (&&)'/`liftA2 (&&)'. but the point here was exactly when you want short-circuiting
2020-11-20 23:00:18 +0100 <jcd> dminuoso: Yeah, I do! That explains the errors my REPL was dumping out.
2020-11-20 23:00:45 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 240 seconds)
2020-11-20 23:01:08 +0100 <jcd> dminuoso: Thank you so much for the help! Recommend any literature so I don't have cry anymore.
2020-11-20 23:01:27 +0100 <minimario> ski: ah ok that makes sense
2020-11-20 23:01:40 +0100 <ski> @hoogle Monad m => (a -> m Bool) -> [a] -> m Bool
2020-11-20 23:01:41 +0100 <lambdabot> Control.Monad.Extra anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool
2020-11-20 23:01:41 +0100 <lambdabot> Control.Monad.Extra allM :: Monad m => (a -> m Bool) -> [a] -> m Bool
2020-11-20 23:01:41 +0100 <lambdabot> Extra anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool
2020-11-20 23:01:50 +0100 <ski> @hoogle Monad m => [m Bool] -> m Bool
2020-11-20 23:01:51 +0100 <lambdabot> Control.Monad.Extra orM :: Monad m => [m Bool] -> m Bool
2020-11-20 23:01:51 +0100 <lambdabot> Control.Monad.Extra andM :: Monad m => [m Bool] -> m Bool
2020-11-20 23:01:51 +0100 <lambdabot> Extra orM :: Monad m => [m Bool] -> m Bool
2020-11-20 23:01:56 +0100 <ski> similar thing, in those
2020-11-20 23:02:17 +0100johnw_(~johnw@haskell/developer/johnw) (Quit: ZNC - http://znc.in)
2020-11-20 23:02:23 +0100 <ski> minimario : ooc, which module were you looking in ?
2020-11-20 23:02:27 +0100 <dminuoso> jcd: Im not good on book references. I keep suggesting CIS194 because it's the only reference material I looked at in the past 12 months and it looked decent.
2020-11-20 23:02:53 +0100 <dminuoso> And it happens to be one of the few resources that's not as dated
2020-11-20 23:02:58 +0100borne(~fritjof@200116b86455d000f1dc39039d201adf.dip.versatel-1u1.de)
2020-11-20 23:03:16 +0100invaser(~Thunderbi@31.148.23.125) (Ping timeout: 272 seconds)
2020-11-20 23:03:21 +0100 <ski> @where CIS194
2020-11-20 23:03:21 +0100 <lambdabot> https://www.seas.upenn.edu/~cis194/spring13/lectures.html
2020-11-20 23:03:43 +0100 <minimario> oh lol i was just doing an intro haskell tutorial and one of the exercises was to implement andM haha
2020-11-20 23:03:44 +0100 <dminuoso> There's also a more recent version of CIS194 from Joachim Breitner around, the style is slightly different.
2020-11-20 23:03:45 +0100hlisp(~hlisp@114.246.35.11)
2020-11-20 23:03:51 +0100 <dminuoso> https://www.seas.upenn.edu/~cis194/fall16/
2020-11-20 23:03:56 +0100 <ski> minimario : ah, okay
2020-11-20 23:04:08 +0100moet(~moet@mobile-166-137-178-165.mycingular.net)
2020-11-20 23:04:34 +0100Rudd0(~Rudd0@185.189.115.103)
2020-11-20 23:04:39 +0100 <moet> is there an equivalent to KnownNat(natVal) somewhere for types of kind Bool? .. or should i just define it?
2020-11-20 23:04:40 +0100 <ski> dminuoso : any overheard opinion on the relative merits ?
2020-11-20 23:05:24 +0100maroloccio(~marolocci@2a02:8084:221:ce00:164f:8aff:fed8:411d)
2020-11-20 23:05:33 +0100cads(~cads@ip-64-72-99-232.lasvegas.net)
2020-11-20 23:06:46 +0100conal(~conal@172.255.125.150) (Quit: Computer has gone to sleep.)
2020-11-20 23:07:05 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192) (Ping timeout: 240 seconds)
2020-11-20 23:07:15 +0100 <ski> minimario : btw, note that the `andM' you were using was a monadic version of the binary conjunction, while the one in e.g. <https://hackage.haskell.org/package/extra/docs/Control-Monad-Extra.html> is `Monad m => [m Bool] -> m Bool', a monadic version of `and :: [Bool] -> Bool', taking a list
2020-11-20 23:08:09 +0100 <minimario> oh hm there are two versions?
2020-11-20 23:08:10 +0100 <minimario> interesting
2020-11-20 23:08:17 +0100hlisp(~hlisp@114.246.35.11) (Ping timeout: 260 seconds)
2020-11-20 23:08:26 +0100 <minimario> second one is just a generalization i guess :)
2020-11-20 23:09:29 +0100 <dminuoso> ski: No.
2020-11-20 23:09:41 +0100__monty__(~toonn@unaffiliated/toonn) (Quit: leaving)
2020-11-20 23:10:12 +0100 <dminuoso> I only skimmed Brent's version, so Im not equipped to compare them well enough. But I know Brent spoke well of Joachim's take on the course.
2020-11-20 23:10:14 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 23:10:55 +0100 <dminuoso> And at least the entry seems a bit easier since the first weeks build up ontop of each other, giving coherent excercises leading to a sokoban clone.
2020-11-20 23:10:57 +0100 <ski> minimario : one is a monadic generalization of `(&&)'. the other of `and'
2020-11-20 23:11:01 +0100ronbrz(~ronbrz@207.229.174.134)
2020-11-20 23:11:34 +0100Feuermagier(~Feuermagi@213.178.26.41) (Remote host closed the connection)
2020-11-20 23:12:16 +0100 <ski> dminuoso : ok. i vaguely recall someone (in here), suggesting the 2013 spring version (over others). but it's possible that was before fall of 2016
2020-11-20 23:12:56 +0100 <dminuoso> ski: I picked up a few arguments for both, but I never noticed any criticism about either.
2020-11-20 23:13:17 +0100wh00(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net)
2020-11-20 23:13:37 +0100wh0(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net) (Ping timeout: 256 seconds)
2020-11-20 23:14:18 +0100hyiltiz(~quassel@unaffiliated/hyiltiz) (Remote host closed the connection)
2020-11-20 23:15:26 +0100hyiltiz(~quassel@unaffiliated/hyiltiz)
2020-11-20 23:16:24 +0100rawles(~r@unaffiliated/rawles) (Ping timeout: 240 seconds)
2020-11-20 23:17:31 +0100hackagedense 0.1.0.1 - Mutable and immutable dense multidimensional arrays https://hackage.haskell.org/package/dense-0.1.0.1 (cchalmers)
2020-11-20 23:17:35 +0100wh00(~wh0000@cpc152777-shef18-2-0-cust223.17-1.cable.virginm.net) (Ping timeout: 256 seconds)
2020-11-20 23:17:49 +0100 <johnw> I wonder why there is Data.ByteString.isInfixOf, but not Data.ByteString.Lazy.isInfixOf; the others are present
2020-11-20 23:17:56 +0100mputz(~Thunderbi@dslb-084-058-211-084.084.058.pools.vodafone-ip.de) (Ping timeout: 256 seconds)
2020-11-20 23:18:43 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Ping timeout: 256 seconds)
2020-11-20 23:19:22 +0100rawles(~r@unaffiliated/rawles)
2020-11-20 23:19:45 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 23:21:21 +0100conal(~conal@172.255.125.150)
2020-11-20 23:21:38 +0100jneira(02896ac0@gateway/web/cgi-irc/kiwiirc.com/ip.2.137.106.192)
2020-11-20 23:25:28 +0100wroathe(~wroathe@c-73-24-27-54.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2020-11-20 23:25:57 +0100 <dminuoso> johnw: Mmm, even the isSuffixOf implementation is a bit questionable.
2020-11-20 23:26:09 +0100 <dminuoso> Guess the reason seems that bytestring has no streaming facilities
2020-11-20 23:26:51 +0100 <dminuoso> Is https://hackage.haskell.org/package/text-1.2.4.0/docs/src/Data.Text.Internal.Lazy.Search.html#indi… portable to bytestring perhaps?
2020-11-20 23:28:02 +0100alp(~alp@88.126.45.36)
2020-11-20 23:29:40 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2020-11-20 23:33:01 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com) (Remote host closed the connection)
2020-11-20 23:34:16 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2020-11-20 23:35:13 +0100conal(~conal@172.255.125.150) (Quit: Computer has gone to sleep.)
2020-11-20 23:35:16 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2020-11-20 23:39:24 +0100Franciman(~francesco@host-79-27-199-238.retail.telecomitalia.it) (Quit: Leaving)
2020-11-20 23:39:27 +0100conal(~conal@64.71.133.70)
2020-11-20 23:40:01 +0100luke(~luke@bitnomial/staff/luke) (Quit: sleep)
2020-11-20 23:42:09 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Ping timeout: 265 seconds)
2020-11-20 23:44:39 +0100christo(~chris@81.96.113.213) (Remote host closed the connection)
2020-11-20 23:44:54 +0100FreeBirdLjj(~freebirdl@101.228.42.108)
2020-11-20 23:49:14 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2020-11-20 23:49:57 +0100caasih(sid13241@gateway/web/irccloud.com/x-terlgyaghsopjzfx) (Ping timeout: 260 seconds)
2020-11-20 23:49:57 +0100cemerick(sid54985@gateway/web/irccloud.com/x-sezszkubzwzwoedv) (Ping timeout: 260 seconds)
2020-11-20 23:50:11 +0100caasih(sid13241@gateway/web/irccloud.com/x-odjkianrohgyrvme)
2020-11-20 23:50:32 +0100jbetz(sid283648@gateway/web/irccloud.com/x-lgtmgjydvhzpefgi) (Ping timeout: 260 seconds)
2020-11-20 23:50:32 +0100trevorriles(sid469656@gateway/web/irccloud.com/x-vcwwrvniknzblcpg) (Ping timeout: 260 seconds)
2020-11-20 23:50:32 +0100metadave(sid28102@gateway/web/irccloud.com/x-wybfodxjmjkizymy) (Ping timeout: 260 seconds)
2020-11-20 23:50:32 +0100ibloom(sid350277@gateway/web/irccloud.com/x-hlioyajxeywwuxmx) (Ping timeout: 260 seconds)
2020-11-20 23:50:43 +0100ibloom(sid350277@gateway/web/irccloud.com/x-ftwuwcmqpnbfrqgs)
2020-11-20 23:50:51 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 23:52:07 +0100chaosmasttter(~chaosmast@p200300c4a70b2a01f05e932a21001b8c.dip0.t-ipconnect.de) (Quit: WeeChat 2.9)
2020-11-20 23:52:30 +0100conal(~conal@64.71.133.70)
2020-11-20 23:52:41 +0100trevorriles(sid469656@gateway/web/irccloud.com/x-cfgejkqvovtgjbpt)
2020-11-20 23:52:43 +0100metadave(sid28102@gateway/web/irccloud.com/x-bjrjtdehstdxjwgn)
2020-11-20 23:52:47 +0100jbetz(sid283648@gateway/web/irccloud.com/x-sdqysuekfefsmces)
2020-11-20 23:52:48 +0100cemerick(sid54985@gateway/web/irccloud.com/x-bubkwfmgbakwqyik)
2020-11-20 23:53:03 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2020-11-20 23:53:04 +0100FreeBirdLjj(~freebirdl@101.228.42.108) (Ping timeout: 256 seconds)
2020-11-20 23:53:20 +0100heatsink(~heatsink@107-136-5-69.lightspeed.sntcca.sbcglobal.net)
2020-11-20 23:54:36 +0100conal(~conal@64.71.133.70) (Client Quit)
2020-11-20 23:56:01 +0100conal(~conal@64.71.133.70)
2020-11-20 23:59:48 +0100vhs(~vhs@41.239.254.104)