IRCBrowse

2023/01/24

2023-01-24 00:04:35 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 255 seconds)
2023-01-24 00:05:10 +0100mechap1(~mechap@user/mechap) (Quit: WeeChat 3.8)
2023-01-24 00:05:24 +0100mechap(~mechap@user/mechap)
2023-01-24 00:07:40 +0100barium(~barium@user/oldfashionedcow/bot/barium)
2023-01-24 00:07:52 +0100barium(~barium@user/oldfashionedcow/bot/barium) ()
2023-01-24 00:10:25 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 252 seconds)
2023-01-24 00:12:08 +0100mizlan(~mizlan@2607:f010:2a7:1005:9ca4:ebdf:8ee7:9f2e)
2023-01-24 00:16:44 +0100gurkenglas(~gurkengla@dynamic-046-114-181-040.46.114.pool.telefonica.de) (Ping timeout: 255 seconds)
2023-01-24 00:20:11 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-24 00:20:50 +0100mcglk(~mcglk@131.191.49.120) (Quit: (zzz))
2023-01-24 00:21:27 +0100astra_astra
2023-01-24 00:25:58 +0100 <alexfmpe[m]> uuuh where to import floating point's infinity from? ghci knows about it but I can't get it in scope
2023-01-24 00:25:58 +0100 <alexfmpe[m]> > read "Infinity" :: Double
2023-01-24 00:25:58 +0100 <alexfmpe[m]> Infinity
2023-01-24 00:25:58 +0100 <alexfmpe[m]> closest I find is GHC.Real.infinity which is Rational
2023-01-24 00:25:59 +0100 <lambdabot> Infinity
2023-01-24 00:26:28 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Ping timeout: 265 seconds)
2023-01-24 00:26:54 +0100 <alexfmpe[m]> I guess 1/0 works, shrug
2023-01-24 00:30:01 +0100 <geekosaur> "Infinity" is a hack for read since it can't use 1/0; conversely; "Infinity" can't be a constructor for Double or Float or Rational
2023-01-24 00:30:42 +0100CiaoSen(~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 255 seconds)
2023-01-24 00:31:08 +0100mizlan(~mizlan@2607:f010:2a7:1005:9ca4:ebdf:8ee7:9f2e) (Ping timeout: 255 seconds)
2023-01-24 00:33:24 +0100 <EvanR> 1/0 is fine
2023-01-24 00:33:38 +0100 <monochrom> I bet converting GHC.Real.infinity to Double does the right thing. For the former is merely 1 :% 0, using :% the internal data constructor of Rational, the intention being that a:%b is always converted to a/b when converting.
2023-01-24 00:33:58 +0100mizlan(~mizlan@169.150.203.45)
2023-01-24 00:33:58 +0100 <EvanR> it has theoretical justification on graphical linear algebra blog xD
2023-01-24 00:34:12 +0100 <monochrom> Similarly for notANumber = 0 :% 0.
2023-01-24 00:34:49 +0100 <EvanR> > 1 % 0
2023-01-24 00:34:51 +0100 <lambdabot> *Exception: Ratio has zero denominator
2023-01-24 00:35:38 +0100 <monochrom> Yeah this is why they use the internal data constructor :% directly and avoid the restrictive smart constructor %
2023-01-24 00:35:47 +0100 <monochrom> even circumvent
2023-01-24 00:37:06 +0100 <monochrom> A life hack that exploits how fromRational is usually just \(a :% b) -> a/b
2023-01-24 00:38:54 +0100 <Maxdamantus> Out of interest, why couldn't they use "1/0"? So people can construct `ReadS` parsers that consume the "/" after reading a double?
2023-01-24 00:39:06 +0100 <Maxdamantus> > readsPrec 0 "1/0" :: [(Double, String)]
2023-01-24 00:39:09 +0100 <lambdabot> [(1.0,"/0")]
2023-01-24 00:40:03 +0100 <Maxdamantus> Presumably that could just be worked around by adding "(..)" if the precedence is too high.
2023-01-24 00:40:34 +0100 <geekosaur> maybe it could get away with it for Float or Double. Rational would be more difficult because of the :% thing
2023-01-24 00:41:15 +0100 <geekosaur> but yes, there's a conflict between reading "1/0" as a Double vs. someone using a ReadS parser to parse an expression
2023-01-24 00:41:17 +0100 <Maxdamantus> Does `Rational` have infinity?
2023-01-24 00:41:30 +0100 <monochrom> Consider what the Read instance for Double should do instead.
2023-01-24 00:41:56 +0100 <monochrom> Or better yet, what geekosaur just said.
2023-01-24 00:42:03 +0100mikoto-chan(~mikoto-ch@2001:999:400:22bc:5dfb:b243:3fed:bd17) (Ping timeout: 260 seconds)
2023-01-24 00:42:26 +0100 <geekosaur> hm, right re Rational, it doesn't do infinity
2023-01-24 00:42:32 +0100 <Maxdamantus> It could always just use "(1/0)" to be safe.
2023-01-24 00:42:42 +0100 <monochrom> Does GHC.Real.infinity count? :)
2023-01-24 00:44:47 +0100telser(~quassel@user/telser) (Ping timeout: 268 seconds)
2023-01-24 00:45:04 +0100telser(~quassel@user/telser)
2023-01-24 00:45:21 +0100 <geekosaur> Maxdamantus, the more you complicate it, the more complicated the edge cases get
2023-01-24 00:45:58 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a9a4:a50f:5f82:e15)
2023-01-24 00:46:03 +0100 <Maxdamantus> It doesn't seem particularly complicated. It's really just replacing the special case for "Infinity" with the special case for "(1/0)"
2023-01-24 00:46:04 +0100 <geekosaur> you basically end up saying "ReadS can only be used by `read`/`readsPrec`. although one could argue that you should say that…
2023-01-24 00:46:17 +0100 <Maxdamantus> and it means the output is valid Haskell code.
2023-01-24 00:46:58 +0100 <Maxdamantus> You mean that `Show` can only be used by `read`/`readsPrec`?
2023-01-24 00:47:24 +0100 <Maxdamantus> but yeah, I think that's already the case with "Infinity"
2023-01-24 00:47:52 +0100 <Maxdamantus> "Infinity" doesn't even normally work as a Haskell expression. It *only* works with `read`.
2023-01-24 00:48:10 +0100 <geekosaur> no, I mean you steal more and more of ReadP's expressiveness and reserve it to Double/Float parsing, so you can't use a more generl ReadP parser
2023-01-24 00:49:24 +0100 <geekosaur> which will among other things annoy the folks who used general ReadP parsers for AoC
2023-01-24 00:49:41 +0100 <Maxdamantus> How does it steal from ReadP's expressiveness?
2023-01-24 00:50:11 +0100 <geekosaur> you just took away use of parentheses and /
2023-01-24 00:50:20 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a9a4:a50f:5f82:e15) (Ping timeout: 246 seconds)
2023-01-24 00:50:33 +0100 <Maxdamantus> No I didn't. Other parsers can still use parentheses.
2023-01-24 00:51:01 +0100 <geekosaur> but you can't reuse existing parsers, you must reimplement them to avoiid the cases you took away for `read`
2023-01-24 00:51:02 +0100 <Maxdamantus> The "/" is also unaffected using my latest suggestion (always using parentheses)
2023-01-24 00:51:11 +0100 <Maxdamantus> gtg
2023-01-24 00:55:02 +0100 <monochrom> No, I write ReadP parsers all the time, and I use readS_to_P for the lexical level all the time.
2023-01-24 00:56:05 +0100 <monochrom> And I would still like to write a ReadP parser for "data X = Lit Double | Div X X" and I would still like to parse "(((1/0)))" to Div 1 0 not infinity.
2023-01-24 00:56:38 +0100 <monochrom> So if the Read instance for Double stole my 1/0 or (1/0) or (((1/0))) or what have you, I would be pissed.
2023-01-24 00:59:00 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-24 01:00:36 +0100iteratee(~kyle@162.218.222.107) (Read error: Connection reset by peer)
2023-01-24 01:03:28 +0100Midjak(~Midjak@82.66.147.146) (Quit: This computer has gone to sleep)
2023-01-24 01:04:35 +0100iteratee(~kyle@162.218.222.107)
2023-01-24 01:07:34 +0100 <EvanR> Show and Read aren't for pretty printing, but seat of your pants debugging in which case their behavior can be totally automated. Get rid of them xD
2023-01-24 01:09:59 +0100 <geekosaur> until you need to debug that record with the inconvenient function within it, so you want to write your own Show instance
2023-01-24 01:11:18 +0100 <geekosaur> (yes, there's the function instance somewhere in Data.Function, but that's a generalization of this)
2023-01-24 01:13:11 +0100 <geekosaur> also, even automated they'll still use some framework underneath like ShowS and ReadS
2023-01-24 01:16:57 +0100 <EvanR> records with a function in them should also work </heresy>
2023-01-24 01:17:30 +0100 <EvanR> ghc "you can't show a function" me "I don't care!"
2023-01-24 01:17:59 +0100 <EvanR> a lot of times I implement a Show instance for a record with a function in some ad hoc way that doesn't show anything use for the function field
2023-01-24 01:18:07 +0100 <EvanR> useful
2023-01-24 01:19:09 +0100 <geekosaur> sorry, I was thinking of https://downloads.haskell.org/ghc/9.2.5/docs/html/libraries/base-4.16.4.0/Text-Show-Functions.html
2023-01-24 01:24:18 +0100Guest75(~Guest75@178.141.138.233) (Ping timeout: 260 seconds)
2023-01-24 01:24:40 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-24 01:26:20 +0100acidjnk_new(~acidjnk@p200300d6e715c429c1bce9b910063906.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-24 01:28:40 +0100Lycurgus(~juan@user/Lycurgus) (Client Quit)
2023-01-24 01:31:59 +0100angelore(~angelore@5.46.161.208)
2023-01-24 01:37:47 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Quit: Leaving)
2023-01-24 01:45:25 +0100 <carbolymer> @hoogle Int -> Natural
2023-01-24 01:45:26 +0100 <lambdabot> GHC.Natural intToNatural :: Int -> Natural
2023-01-24 01:45:26 +0100 <lambdabot> Basement.Numerical.Number toNatural :: IsNatural a => a -> Natural
2023-01-24 01:45:26 +0100 <lambdabot> Foundation toNatural :: IsNatural a => a -> Natural
2023-01-24 01:45:35 +0100 <carbolymer> where intToNatural comes from?
2023-01-24 01:45:45 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 01:46:28 +0100angelore(~angelore@5.46.161.208) (Ping timeout: 260 seconds)
2023-01-24 01:48:26 +0100 <monochrom> Interesting, GHC.Numeric doesn't actually have intToNatural.
2023-01-24 01:48:32 +0100jeetelongname(~jeet@217.79.169.181)
2023-01-24 01:48:39 +0100 <monochrom> Do you mind naturalFromInteger?
2023-01-24 01:48:42 +0100angelore(~angelore@5.46.161.208)
2023-01-24 01:49:11 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8)
2023-01-24 01:49:18 +0100 <carbolymer> yeah that should do the trick, thx
2023-01-24 01:49:56 +0100 <carbolymer> also idk why but numbers conversion is totally not obvious for me in Haskell
2023-01-24 01:51:08 +0100 <monochrom> Interesting, naturalFromInteger (-2) = 2
2023-01-24 01:51:51 +0100 <monochrom> Generally speaking, fromIntegral and realToFrac cover most cases. Although, they don't do range checks.
2023-01-24 01:52:00 +0100 <c_wraith> The basic principle is that numbers never change types. The normal operators require two operands of the same type and return a value of that type. Literals are polymorphic in ways that are often, but not always convenient. And whenever you need to do a numeric type conversion, choose a function very carefully.
2023-01-24 01:52:20 +0100 <c_wraith> monochrom: don't forget the floor, ceil, round family for non-integral to integral
2023-01-24 01:52:33 +0100 <monochrom> Ah right.
2023-01-24 01:52:57 +0100opticblast(~Thunderbi@secure-165.caltech.edu)
2023-01-24 01:53:21 +0100 <geekosaur> it went away with ghc-bignum
2023-01-24 01:53:28 +0100angelore(~angelore@5.46.161.208) (Ping timeout: 260 seconds)
2023-01-24 01:54:32 +0100 <jeetelongname> @pl twiceSum x + y = 2 * (x + y)
2023-01-24 01:54:32 +0100 <lambdabot> (line 1, column 17):
2023-01-24 01:54:33 +0100 <lambdabot> unexpected " "
2023-01-24 01:54:33 +0100 <lambdabot> expecting operator
2023-01-24 01:54:48 +0100 <jeetelongname> whoops
2023-01-24 01:54:53 +0100 <jeetelongname> @pl twiceSum x y = 2 * (x + y)
2023-01-24 01:54:54 +0100 <lambdabot> twiceSum = ((2 *) .) . (+)
2023-01-24 01:55:02 +0100 <jeetelongname> good to know
2023-01-24 01:57:04 +0100angelore(~angelore@5.46.161.208)
2023-01-24 01:58:03 +0100 <c_wraith> You can rewrite that one with the distributive property to use funnier combinators, which isn't generally possible
2023-01-24 01:58:12 +0100 <c_wraith> > let f = (+) `on` (2*) in f 4 5
2023-01-24 01:58:14 +0100 <lambdabot> 18
2023-01-24 01:59:39 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-01-24 01:59:39 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-01-24 01:59:39 +0100wroathe(~wroathe@user/wroathe)
2023-01-24 01:59:42 +0100angelore(~angelore@5.46.161.208) ()
2023-01-24 01:59:42 +0100 <monochrom> Generally pl'ing curried functions is a pain.
2023-01-24 02:00:39 +0100 <monochrom> Morally you should be looking at \(x,y) -> 2*(x+y) which is straightforwardly (2 *) . (uncurry (+)), a simple pipeline indeed.
2023-01-24 02:01:40 +0100 <c_wraith> and then you just curry the composition!
2023-01-24 02:04:11 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad)
2023-01-24 02:04:33 +0100carbolymersaw curry trees in africa
2023-01-24 02:04:52 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi) (Quit: Leaving.)
2023-01-24 02:05:45 +0100 <c_wraith> the source of the magical curry powder!
2023-01-24 02:06:46 +0100mizlan(~mizlan@169.150.203.45) (Remote host closed the connection)
2023-01-24 02:06:49 +0100 <jeetelongname> Curry leaves are also a very underated flavour
2023-01-24 02:08:06 +0100 <jeetelongname> monochrom: I did not think to use a tuple. It is very neat
2023-01-24 02:08:38 +0100 <c_wraith> > let f = curry $ (2 *) . uncurry (+) in f 6 7
2023-01-24 02:08:39 +0100 <lambdabot> 26
2023-01-24 02:09:06 +0100 <monochrom> > let f = curry $ (2 *) . uncurry (+) in f x y
2023-01-24 02:09:07 +0100 <lambdabot> 2 * (x + y)
2023-01-24 02:09:10 +0100 <monochrom> :)
2023-01-24 02:09:23 +0100 <monochrom> "Aim higher" >:D
2023-01-24 02:11:02 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-24 02:11:15 +0100mizlan(~mizlan@169.150.203.45)
2023-01-24 02:12:55 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad) (Quit: (zzz))
2023-01-24 02:15:26 +0100jeetelongname(~jeet@217.79.169.181) (Ping timeout: 268 seconds)
2023-01-24 02:17:09 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-24 02:20:13 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds)
2023-01-24 02:22:27 +0100 <Maxdamantus> monochrom: okay, I guess that's partly fair. I guess you do always have to reason to some extent about the parser that you're invoking.
2023-01-24 02:22:46 +0100 <Maxdamantus> eg, if the parser is a double parser, you can't expect to have created some input with a "0" immediately after the double.
2023-01-24 02:24:10 +0100 <EvanR> greedy parser, maximal munch
2023-01-24 02:36:51 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-01-24 02:38:57 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-01-24 02:39:48 +0100codaraxis__(~codaraxis@user/codaraxis) (Remote host closed the connection)
2023-01-24 02:39:58 +0100mizlan(~mizlan@169.150.203.45) (Remote host closed the connection)
2023-01-24 02:40:12 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-01-24 02:40:44 +0100xff0x_(~xff0x@2405:6580:b080:900:2967:46fd:7767:4b83) (Ping timeout: 255 seconds)
2023-01-24 02:41:12 +0100codaraxis__(~codaraxis@user/codaraxis) (Max SendQ exceeded)
2023-01-24 02:41:14 +0100Guest75(~Guest75@178.141.138.233)
2023-01-24 02:41:42 +0100codaraxis__(~codaraxis@user/codaraxis)
2023-01-24 02:42:35 +0100codaraxis(~codaraxis@user/codaraxis) (Ping timeout: 248 seconds)
2023-01-24 02:44:27 +0100mizlan(~mizlan@169.150.203.45)
2023-01-24 02:44:50 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-24 02:46:50 +0100mizlan(~mizlan@169.150.203.45) (Remote host closed the connection)
2023-01-24 02:47:31 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 02:51:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Ping timeout: 255 seconds)
2023-01-24 02:52:47 +0100masterbuilder(~master@user/masterbuilder)
2023-01-24 02:56:29 +0100mizlan(~mizlan@169.150.203.45)
2023-01-24 02:59:03 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad)
2023-01-24 03:00:07 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad) (Client Quit)
2023-01-24 03:05:30 +0100m1dnight(~christoph@78-22-0-121.access.telenet.be) (Ping timeout: 256 seconds)
2023-01-24 03:06:09 +0100m1dnight(~christoph@78-22-0-121.access.telenet.be)
2023-01-24 03:07:39 +0100ddellacosta(~ddellacos@143.244.47.89) (Ping timeout: 248 seconds)
2023-01-24 03:08:25 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad)
2023-01-24 03:10:29 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad) (Client Quit)
2023-01-24 03:18:38 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-24 03:19:48 +0100gmg(~user@user/gehmehgeh)
2023-01-24 03:23:48 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-01-24 03:26:16 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 265 seconds)
2023-01-24 03:28:42 +0100razetime(~Thunderbi@117.193.5.253)
2023-01-24 03:34:01 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2023-01-24 03:35:34 +0100mizlan(~mizlan@169.150.203.45) (Ping timeout: 252 seconds)
2023-01-24 03:35:46 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-24 03:39:35 +0100mizlan(~mizlan@169.150.203.65)
2023-01-24 03:42:08 +0100gehmehgeh(~user@user/gehmehgeh)
2023-01-24 03:43:23 +0100gmg(~user@user/gehmehgeh) (Ping timeout: 255 seconds)
2023-01-24 03:51:50 +0100sgarcia(sgarcia@swarm.znchost.com) (Ping timeout: 255 seconds)
2023-01-24 03:52:12 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 252 seconds)
2023-01-24 03:54:01 +0100sgarcia(sgarcia@swarm.znchost.com)
2023-01-24 03:58:39 +0100jero98772(~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c) (Remote host closed the connection)
2023-01-24 04:14:19 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-24 04:16:28 +0100thegeekinside(~thegeekin@189.180.66.244) (Remote host closed the connection)
2023-01-24 04:20:16 +0100discuss9128(~discuss91@bb119-74-93-26.singnet.com.sg)
2023-01-24 04:21:44 +0100discuss9128(~discuss91@bb119-74-93-26.singnet.com.sg) (Client Quit)
2023-01-24 04:22:07 +0100justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
2023-01-24 04:23:42 +0100thegeekinside(~thegeekin@189.180.66.244)
2023-01-24 04:26:23 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net)
2023-01-24 04:27:13 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-24 04:30:01 +0100mizlan(~mizlan@169.150.203.65) (Ping timeout: 252 seconds)
2023-01-24 04:32:46 +0100thegeekinside(~thegeekin@189.180.66.244) (Ping timeout: 252 seconds)
2023-01-24 04:35:05 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad)
2023-01-24 04:38:39 +0100mei(~mei@user/mei) (Ping timeout: 260 seconds)
2023-01-24 04:40:39 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 260 seconds)
2023-01-24 04:40:53 +0100razetime(~Thunderbi@117.193.5.253) (Ping timeout: 255 seconds)
2023-01-24 04:42:27 +0100mei(~mei@user/mei)
2023-01-24 04:44:44 +0100justsomeguy(~justsomeg@user/justsomeguy)
2023-01-24 04:47:33 +0100discuss9128(~discuss91@bb119-74-93-26.singnet.com.sg)
2023-01-24 04:48:38 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-24 04:48:41 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-01-24 04:48:41 +0100finn_elijaFinnElija
2023-01-24 04:48:55 +0100td_(~td@83.135.9.19) (Ping timeout: 265 seconds)
2023-01-24 04:50:33 +0100td_(~td@i53870917.versanet.de)
2023-01-24 04:56:29 +0100mizlan(~mizlan@89.46.114.51)
2023-01-24 04:58:26 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-24 05:02:54 +0100Sciencentistguy9(~sciencent@hacksoc/ordinary-member)
2023-01-24 05:03:57 +0100mechap1(~mechap@user/mechap)
2023-01-24 05:05:35 +0100Sciencentistguy(~sciencent@hacksoc/ordinary-member) (Ping timeout: 264 seconds)
2023-01-24 05:05:36 +0100Sciencentistguy9Sciencentistguy
2023-01-24 05:07:29 +0100mechap(~mechap@user/mechap) (Ping timeout: 268 seconds)
2023-01-24 05:11:16 +0100Guest|11(~Guest|11@c-76-22-56-82.hsd1.wa.comcast.net)
2023-01-24 05:16:15 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 05:22:35 +0100justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.6)
2023-01-24 05:23:07 +0100razetime(~Thunderbi@117.193.5.253)
2023-01-24 05:26:18 +0100razetime(~Thunderbi@117.193.5.253) (Client Quit)
2023-01-24 05:28:21 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com)
2023-01-24 05:32:57 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 05:34:03 +0100 <segfaultfizzbuzz> ok i asked about this in #haskell-offtopic but didn't get much of a response so i thought i would ask here,... are there any automatic differentiation nerds here?
2023-01-24 05:34:46 +0100 <Axman6> don't ask to ask, just ask - the answer is probably yes but no one is going to stick their hand up to answer a question if they don't know what it is
2023-01-24 05:35:03 +0100mizlan(~mizlan@89.46.114.51) (Remote host closed the connection)
2023-01-24 05:35:56 +0100 <segfaultfizzbuzz> i have heard that whether to use forward propagation, backprop, or some other thing is context dependent--where can i find more information on this
2023-01-24 05:36:01 +0100 <segfaultfizzbuzz> or is that false
2023-01-24 05:36:32 +0100 <segfaultfizzbuzz> i don't care about optimality, just a "good solution"
2023-01-24 05:39:32 +0100mizlan(~mizlan@89.46.114.51)
2023-01-24 05:39:33 +0100 <jackdk> https://hackage.haskell.org/package/ad probably, but I'm not an AD nerd
2023-01-24 05:40:02 +0100 <segfaultfizzbuzz> well yeah i mean as you can see you have to pick how you want it to do AD
2023-01-24 05:42:37 +0100 <segfaultfizzbuzz> also, regarding ad in particular, usually there needs to be an associated matrix math library (blas etc) but i don't see that mentioned in the repo or on hackage?
2023-01-24 05:43:16 +0100 <jackdk> The contents page seems to map methods to use cases, even if you have to pick specific functions yourself
2023-01-24 05:44:11 +0100 <segfaultfizzbuzz> i don't think this is going to really be at a level of performance with consideration unless it has BLAS etc
2023-01-24 05:44:49 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net) (Ping timeout: 252 seconds)
2023-01-24 05:45:28 +0100 <jackdk> I would be surprised if Ed released something that was unavoidably slow, but you should definitely benchmark
2023-01-24 05:46:08 +0100 <segfaultfizzbuzz> uh i doubt even super haskell programmers can go up against really well established linalg libraries,... but who knows
2023-01-24 05:48:58 +0100ub(~Thunderbi@p200300ecdf264e3f7f9ba4aff8511836.dip0.t-ipconnect.de)
2023-01-24 05:49:49 +0100discuss9128(~discuss91@bb119-74-93-26.singnet.com.sg) (Quit: Client closed)
2023-01-24 05:50:21 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds)
2023-01-24 05:50:24 +0100ubert(~Thunderbi@p548c9ce5.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-24 05:50:24 +0100ububert
2023-01-24 05:50:41 +0100 <segfaultfizzbuzz> yeah i mean if you look at the *one* example, this is a very low dimensional function https://github.com/ekmett/ad/blob/master/bench/BlackScholes.hs
2023-01-24 05:51:25 +0100 <segfaultfizzbuzz> i can count the number of parameters by hand, so they aren't thinking about like comparatively serious linalg here
2023-01-24 05:52:25 +0100 <davean> ad has ABSOLUTELY been used in extremely high dimensional cases, thats an *example*
2023-01-24 05:52:58 +0100 <jackdk> this is all a lot of context that you did not put in your original question. I don't know enough about this stuff to help you or evaluate what fits your needs, and the issue trackers seem to have a bunch of open loops around ad/accelerate or ad/hmatrix integrations but it's all several years old. You may want to try to work on one of those open loops — I wish you luck.
2023-01-24 05:53:27 +0100 <segfaultfizzbuzz> yes integration of ad with accelerate would be an example of something necessary here
2023-01-24 05:53:32 +0100 <segfaultfizzbuzz> thanks
2023-01-24 05:53:34 +0100 <davean> IIRC you want the jet stuff for high dimension case
2023-01-24 05:54:08 +0100 <segfaultfizzbuzz> davean: https://hackage.haskell.org/package/ad-4.3.2/docs/Numeric-AD-Jet.html - this?
2023-01-24 05:54:12 +0100 <jackdk> I also note that we've gone from "i don't care about optimality, just a \"good solution\"" to "i don't think this is going to really be a at a level of performance with[sic] consideration unless it has BLAS etc"
2023-01-24 05:55:31 +0100Vajb(~Vajb@2001:999:78d:d7:457c:7773:573e:6903) (Read error: Connection reset by peer)
2023-01-24 05:56:01 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi)
2023-01-24 05:56:32 +0100 <segfaultfizzbuzz> as was mentioned: https://github.com/ekmett/ad/issues/70
2023-01-24 05:59:33 +0100Vajb(~Vajb@hag-jnsbng11-58c3a5-27.dhcp.inet.fi) (Read error: Connection reset by peer)
2023-01-24 06:00:04 +0100Guest75(~Guest75@178.141.138.233) (Quit: Client closed)
2023-01-24 06:00:13 +0100Vajb(~Vajb@2001:999:78d:d7:457c:7773:573e:6903)
2023-01-24 06:00:37 +0100 <davean> well if you want matrixes thats a bit different than wanting a lot of variables.
2023-01-24 06:01:28 +0100 <segfaultfizzbuzz> 🤯
2023-01-24 06:03:02 +0100 <davean> matrixes are a set of structured variables with optimizable relations
2023-01-24 06:03:50 +0100 <segfaultfizzbuzz> ok
2023-01-24 06:07:57 +0100 <davean> matrix operations decompose into more primitive operations in the components but we don't like to talk about them like that. If you shove the decomposition into AD - or use AD "under" the matrix library - it'll crunch away on the equation, but it won't give it to you in matrix terms
2023-01-24 06:09:03 +0100 <davean> You'd be unhappy, but if the variables have no relation, thats how you expect it
2023-01-24 06:11:06 +0100 <segfaultfizzbuzz> i think you are saying to use AD to do algebra and then translate the algebra to matrix operations...?
2023-01-24 06:12:26 +0100 <davean> No, I'm saying you want AD to know matrixs natively so its not a mess, I'm also saying there are MANY times matrixes are not how you get a lot of variables.
2023-01-24 06:13:16 +0100 <segfaultfizzbuzz> ok...
2023-01-24 06:14:10 +0100 <davean> something like https://github.com/Mikolaj/horde-ad orients towards matrixes, but thats a VERY different use case. (I don't know that library because my equations are not matrix like)
2023-01-24 06:16:24 +0100 <segfaultfizzbuzz> ah interesting thanks for the suggestion i will look at this library
2023-01-24 06:17:06 +0100 <davean> I don't know that library to be clear
2023-01-24 06:17:14 +0100 <segfaultfizzbuzz> gotta start somewhere
2023-01-24 06:18:21 +0100 <segfaultfizzbuzz> hmatrix is basically openblas btw
2023-01-24 06:20:21 +0100mizlan(~mizlan@89.46.114.51) (Remote host closed the connection)
2023-01-24 06:20:28 +0100 <davean> Yah which is why its too annoying to work with
2023-01-24 06:21:05 +0100 <davean> https://hackage.haskell.org/package/hmatrix-0.20.2/docs/Numeric-LinearAlgebra.html#t:Numeric <-- damning
2023-01-24 06:23:11 +0100 <segfaultfizzbuzz> yeahhhhhh
2023-01-24 06:24:50 +0100mizlan(~mizlan@89.46.114.51)
2023-01-24 06:25:39 +0100 <davean> I mean what more do you expect of blas?
2023-01-24 06:25:50 +0100mizlan(~mizlan@89.46.114.51) (Remote host closed the connection)
2023-01-24 06:26:04 +0100 <segfaultfizzbuzz> idk i've used plenty of matlab,... isn't that blas under the hood or,...?
2023-01-24 06:26:58 +0100 <segfaultfizzbuzz> sometimes i am thinking maybe i should just do the linear algebra myself as crazy as that sounds and then just find ways to offset the fact that my implementation is slow
2023-01-24 06:27:20 +0100int-index(~Vladislav@2a00:1370:8178:5994:b468:f8e7:cc8e:1c79)
2023-01-24 06:29:15 +0100int-index-r(~Vladislav@2a00:1370:8178:5994:10dc:d324:9b0e:2d30)
2023-01-24 06:32:41 +0100int-index(~Vladislav@2a00:1370:8178:5994:b468:f8e7:cc8e:1c79) (Ping timeout: 246 seconds)
2023-01-24 06:33:38 +0100barzo(~hd@31.223.41.44)
2023-01-24 06:35:19 +0100int-index-rint-index
2023-01-24 06:43:03 +0100mizlan(~mizlan@89.46.114.169)
2023-01-24 06:48:00 +0100mizlan(~mizlan@89.46.114.169) (Ping timeout: 268 seconds)
2023-01-24 06:51:45 +0100caef^(~caef@c-24-30-76-89.hsd1.ga.comcast.net)
2023-01-24 06:52:35 +0100int-index(~Vladislav@2a00:1370:8178:5994:10dc:d324:9b0e:2d30) (Ping timeout: 246 seconds)
2023-01-24 06:56:42 +0100rekahsoft(~rekahsoft@bras-base-orllon1122w-grc-07-174-95-68-39.dsl.bell.ca) (Ping timeout: 256 seconds)
2023-01-24 06:57:42 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 255 seconds)
2023-01-24 07:18:44 +0100mizlan(~mizlan@169.150.203.62)
2023-01-24 07:23:09 +0100mizlan(~mizlan@169.150.203.62) (Ping timeout: 268 seconds)
2023-01-24 07:27:30 +0100ubert(~Thunderbi@p200300ecdf264e3f7f9ba4aff8511836.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-01-24 07:27:44 +0100trev(~trev@user/trev)
2023-01-24 07:27:48 +0100ubert(~Thunderbi@p200300ecdf264e3f7f9ba4aff8511836.dip0.t-ipconnect.de)
2023-01-24 07:28:59 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 07:31:39 +0100ddellacosta(~ddellacos@143.244.47.100)
2023-01-24 07:33:32 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 256 seconds)
2023-01-24 07:33:47 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-01-24 07:36:21 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2023-01-24 07:37:13 +0100gehmehgeh(~user@user/gehmehgeh)
2023-01-24 07:41:28 +0100mizlan(~mizlan@169.150.203.51)
2023-01-24 07:43:08 +0100phma_(~phma@host-67-44-208-249.hnremote.net)
2023-01-24 07:46:03 +0100phma(~phma@2001:5b0:211c:c048:963e:eaf4:804a:2fe0) (Ping timeout: 248 seconds)
2023-01-24 07:46:45 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 07:54:43 +0100potash(~foghorn@user/foghorn) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-24 08:07:40 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-24 08:14:11 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net)
2023-01-24 08:14:20 +0100mizlan(~mizlan@169.150.203.51) (Ping timeout: 256 seconds)
2023-01-24 08:15:38 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-24 08:17:18 +0100phma_(~phma@host-67-44-208-249.hnremote.net) (Read error: Connection reset by peer)
2023-01-24 08:17:32 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net)
2023-01-24 08:17:51 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-24 08:18:11 +0100phma_(phma@2001:5b0:210d:1408:a51f:2104:bbf6:4363)
2023-01-24 08:18:17 +0100mikoto-chan(~mikoto-ch@2001:999:400:22bc:5dfb:b243:3fed:bd17)
2023-01-24 08:19:42 +0100potash(~foghorn@user/foghorn)
2023-01-24 08:20:26 +0100phma_phma
2023-01-24 08:22:18 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 255 seconds)
2023-01-24 08:22:23 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-24 08:31:05 +0100mizlan(~mizlan@89.46.114.43)
2023-01-24 08:45:13 +0100waleee(~waleee@2001:9b0:213:7200:cc36:a556:b1e8:b340) (Ping timeout: 252 seconds)
2023-01-24 08:46:53 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net) (Remote host closed the connection)
2023-01-24 08:47:46 +0100Square(~a@user/square) (Ping timeout: 256 seconds)
2023-01-24 08:48:05 +0100hrberg(~quassel@171.79-160-161.customer.lyse.net)
2023-01-24 08:51:09 +0100potash(~foghorn@user/foghorn) (Read error: Connection reset by peer)
2023-01-24 08:51:50 +0100Square(~a@user/square)
2023-01-24 08:51:55 +0100phma_(~phma@host-67-44-208-205.hnremote.net)
2023-01-24 08:52:07 +0100merijn(~merijn@86-86-29-250.fixed.kpn.net) (Ping timeout: 256 seconds)
2023-01-24 08:53:28 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 252 seconds)
2023-01-24 08:53:52 +0100phma__(~phma@2001:5b0:210d:1698:e52:a359:3461:7a25)
2023-01-24 08:54:25 +0100phma(phma@2001:5b0:210d:1408:a51f:2104:bbf6:4363) (Ping timeout: 252 seconds)
2023-01-24 08:55:08 +0100ubert(~Thunderbi@p200300ecdf264e3f7f9ba4aff8511836.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-24 08:55:26 +0100ubert(~Thunderbi@p548c9ce5.dip0.t-ipconnect.de)
2023-01-24 08:56:16 +0100phma_(~phma@host-67-44-208-205.hnremote.net) (Ping timeout: 256 seconds)
2023-01-24 09:00:20 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-24 09:01:48 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-01-24 09:05:56 +0100phma__phma
2023-01-24 09:09:24 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow) (Quit: WeeChat 3.8)
2023-01-24 09:12:29 +0100opticblast(~Thunderbi@secure-165.caltech.edu) (Ping timeout: 260 seconds)
2023-01-24 09:13:31 +0100mmhat(~mmh@p200300f1c7123c98ee086bfffe095315.dip0.t-ipconnect.de)
2023-01-24 09:13:36 +0100mmhat(~mmh@p200300f1c7123c98ee086bfffe095315.dip0.t-ipconnect.de) (Client Quit)
2023-01-24 09:16:29 +0100mikoto-chan(~mikoto-ch@2001:999:400:22bc:5dfb:b243:3fed:bd17) (Ping timeout: 256 seconds)
2023-01-24 09:19:42 +0100manwithluck(~manwithlu@194.177.28.192) (Ping timeout: 268 seconds)
2023-01-24 09:20:20 +0100theproffesor(~theproffe@user/theproffesor) (Ping timeout: 246 seconds)
2023-01-24 09:20:35 +0100manwithluck(~manwithlu@194.177.28.155)
2023-01-24 09:20:35 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 264 seconds)
2023-01-24 09:21:09 +0100theproffesor(~theproffe@user/theproffesor)
2023-01-24 09:21:34 +0100MajorBiscuit(~MajorBisc@2001:1c00:2402:2d00:9eeb:34cf:63b3:9e5b)
2023-01-24 09:22:20 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp)
2023-01-24 09:28:54 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-01-24 09:29:05 +0100chele(~chele@user/chele)
2023-01-24 09:29:29 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 09:30:12 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-24 09:30:47 +0100mizlan(~mizlan@89.46.114.43) (Ping timeout: 246 seconds)
2023-01-24 09:30:58 +0100Sgeo_(~Sgeo@user/sgeo)
2023-01-24 09:31:00 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-24 09:31:55 +0100poljar(~poljar@93-139-120-188.adsl.net.t-com.hr) (Read error: Connection reset by peer)
2023-01-24 09:32:19 +0100poljar(~poljar@93-139-120-188.adsl.net.t-com.hr)
2023-01-24 09:32:48 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-24 09:33:18 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 09:33:39 +0100 <Inst_> is there a way to turn a type of kind Nat into a type of kind String?
2023-01-24 09:33:43 +0100 <Inst_> kind coercion?
2023-01-24 09:37:21 +0100fserucas(~fserucas@2001:818:e376:a400:fb92:70c1:dd88:c7d7)
2023-01-24 09:42:09 +0100acidjnk_new(~acidjnk@p200300d6e715c483c1bce9b910063906.dip0.t-ipconnect.de)
2023-01-24 09:43:01 +0100manwithl-(~manwithlu@194.177.28.192)
2023-01-24 09:43:52 +0100manwithluck(~manwithlu@194.177.28.155) (Ping timeout: 256 seconds)
2023-01-24 09:48:17 +0100kuribas(~user@ptr-17d51emsiv9cd4oypbm.18120a2.ip6.access.telenet.be)
2023-01-24 09:48:45 +0100mizlan(~mizlan@169.150.203.51)
2023-01-24 09:48:47 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:cd53:505b:6825:9d7f)
2023-01-24 09:48:49 +0100 <merijn> Inst_: There is no type of kind String
2023-01-24 09:48:56 +0100 <merijn> Inst_: Are you maybe thinking of Symbol?
2023-01-24 09:48:59 +0100 <Inst_> Symbol
2023-01-24 09:49:15 +0100 <Inst_> I'm trying to handwrite a type family for this now
2023-01-24 09:49:16 +0100 <dminuoso> What would that "turning Nat into Symbol" even do?
2023-01-24 09:49:31 +0100 <dminuoso> Do you mean a type level Show?
2023-01-24 09:50:36 +0100 <Inst_> yeah
2023-01-24 09:50:54 +0100Inst_Isnt
2023-01-24 09:51:13 +0100IsntInst
2023-01-24 09:52:42 +0100codaraxis___(~codaraxis@user/codaraxis)
2023-01-24 09:54:28 +0100codaraxis(~codaraxis@user/codaraxis)
2023-01-24 09:56:21 +0100codaraxis__(~codaraxis@user/codaraxis) (Ping timeout: 255 seconds)
2023-01-24 09:57:13 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-01-24 09:57:45 +0100codaraxis___(~codaraxis@user/codaraxis) (Ping timeout: 260 seconds)
2023-01-24 10:01:20 +0100 <albet70> :t filter
2023-01-24 10:01:22 +0100 <lambdabot> (a -> Bool) -> [a] -> [a]
2023-01-24 10:02:51 +0100 <albet70> :t filter @((->)_)
2023-01-24 10:02:53 +0100 <lambdabot> error: parse error on input ‘->’
2023-01-24 10:06:44 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32)
2023-01-24 10:06:47 +0100kuribas(~user@ptr-17d51emsiv9cd4oypbm.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2023-01-24 10:12:42 +0100CiaoSen(~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-24 10:17:42 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de) (Quit: leaving)
2023-01-24 10:21:17 +0100gurkenglas(~gurkengla@dynamic-046-114-181-040.46.114.pool.telefonica.de)
2023-01-24 10:21:22 +0100caef^(~caef@c-24-30-76-89.hsd1.ga.comcast.net) (Ping timeout: 268 seconds)
2023-01-24 10:25:09 +0100mikoto-chan(~mikoto-ch@2001:999:705:2347:8a80:665c:2482:fb76)
2023-01-24 10:27:54 +0100BasL(~BasL@92-108-215-26.cable.dynamic.v4.ziggo.nl)
2023-01-24 10:29:50 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2023-01-24 10:36:12 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2023-01-24 10:36:22 +0100eggplantade(~Eggplanta@104-55-37-220.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2023-01-24 10:43:17 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-24 10:44:12 +0100Guest|11(~Guest|11@c-76-22-56-82.hsd1.wa.comcast.net) (Quit: Connection closed)
2023-01-24 10:46:17 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 10:47:11 +0100mizlan(~mizlan@169.150.203.51) (Ping timeout: 255 seconds)
2023-01-24 10:51:56 +0100 <tomsmeding> segfaultfizzbuzz: I happen to know that horde-ad library, and while it does indeed do AD on programs with matrices, it's in active development and not necessarily ready for public usage
2023-01-24 10:52:16 +0100 <tomsmeding> sharp edges and breaking changes are to be expected
2023-01-24 10:53:03 +0100 <tomsmeding> re AD on accelerate: this is one of the things I'd like to achieve/get done in my phd, so get in touch if you'd like to work on that :p
2023-01-24 10:53:16 +0100 <Inst> ugh
2023-01-24 10:53:24 +0100 <Inst> do you know how to get rid of a known symbol constraint?
2023-01-24 10:54:11 +0100 <tomsmeding> Inst: is that related to horde-ad or a general question?
2023-01-24 10:54:25 +0100 <Inst> general question
2023-01-24 10:54:56 +0100 <tomsmeding> Inst: haddocs seem to say " There are instances of the class for every concrete literal: "hello", etc."
2023-01-24 10:55:49 +0100 <Inst> yes, but i'm getting type checker errors; I'm trying to work with reify on Data.Reflection
2023-01-24 10:58:27 +0100BasL(~BasL@92-108-215-26.cable.dynamic.v4.ziggo.nl) (Quit: Client closed)
2023-01-24 10:58:30 +0100 <tomsmeding> code?
2023-01-24 10:59:29 +0100 <Inst> https://paste.tomsmeding.com/a7QY0RQo
2023-01-24 11:00:25 +0100Sgeo_(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-01-24 11:00:36 +0100mikoto-chan(~mikoto-ch@2001:999:705:2347:8a80:665c:2482:fb76) (Ping timeout: 265 seconds)
2023-01-24 11:00:43 +0100 <Inst> it won't work with reify or reify nat
2023-01-24 11:03:02 +0100mizlan(~mizlan@169.150.203.52)
2023-01-24 11:04:39 +0100 <tomsmeding> Inst: problem seems to be that ConsSymbol doesn't have KnownSymbol on it
2023-01-24 11:05:16 +0100 <Inst> lol
2023-01-24 11:05:22 +0100 <Inst> there's no type-level show, is there?
2023-01-24 11:06:40 +0100 <tomsmeding> Inst: KnownSymbol seems to just be a class with 1 method producing an SSymbol, defined as `newtype SSymbol (s :: Symbol) = SSymbol String`
2023-01-24 11:07:08 +0100 <tomsmeding> but that stuff is not exported, not sure why
2023-01-24 11:07:15 +0100 <tomsmeding> probably a good reason for it
2023-01-24 11:07:44 +0100xff0x_(~xff0x@125x103x176x34.ap125.ftth.ucom.ne.jp) (Ping timeout: 256 seconds)
2023-01-24 11:07:54 +0100 <Inst> so there's no way to "show" a Nat?
2023-01-24 11:08:28 +0100 <dminuoso> In principle you can write that type family I suppose.
2023-01-24 11:08:55 +0100 <tomsmeding> dminuoso: they did
2023-01-24 11:09:16 +0100 <tomsmeding> % :set -XDataKinds
2023-01-24 11:09:16 +0100 <yahb2> <no output>
2023-01-24 11:09:28 +0100 <tomsmeding> % import GHC.TypeLits
2023-01-24 11:09:29 +0100 <yahb2> <no output>
2023-01-24 11:09:47 +0100 <tomsmeding> % symbolVal (Data.Proxy.Proxy @(ConsSymbol 'h' "ello"))
2023-01-24 11:09:47 +0100 <yahb2> "hello"
2023-01-24 11:09:52 +0100 <tomsmeding> so that's not the issue
2023-01-24 11:11:10 +0100 <Inst> am i screwed?
2023-01-24 11:11:29 +0100 <tomsmeding> Inst: what are you trying to call, fizzString (Proxy @3)?
2023-01-24 11:11:41 +0100 <Inst> reify
2023-01-24 11:11:54 +0100 <Inst> reify or reifyNat
2023-01-24 11:11:55 +0100 <tomsmeding> package?
2023-01-24 11:12:09 +0100 <Inst> toFizz u = reifyNat u fizzString
2023-01-24 11:12:18 +0100 <tomsmeding> reify from which package
2023-01-24 11:12:43 +0100 <Inst> https://hackage.haskell.org/package/reflection-2.1.6/docs/Data-Reflection.html
2023-01-24 11:13:31 +0100 <tomsmeding> I mean, the semantics sort of check out
2023-01-24 11:13:44 +0100 <tomsmeding> if you know the Nat only at runtime, then surely the string isn't known statically
2023-01-24 11:13:56 +0100 <tomsmeding> which is what the Known typeclasses sort of mean
2023-01-24 11:14:33 +0100 <Inst> so i'd need to play with SomeString types?
2023-01-24 11:14:49 +0100 <tomsmeding> you need the string on the value level as well, so for example that way, yes
2023-01-24 11:14:56 +0100 <tomsmeding> types are erased at runtime
2023-01-24 11:15:03 +0100 <tomsmeding> so type-level computation at runtime is not a thing you can do
2023-01-24 11:15:23 +0100 <tomsmeding> or just, you know, do the whole thing on the value level :p
2023-01-24 11:15:51 +0100 <Inst> yeah but this is the most trivial one, ugh
2023-01-24 11:15:59 +0100 <Inst> people already solved this, maybe i can crib from them
2023-01-24 11:16:09 +0100 <tomsmeding> people did type-level computation at runtime?
2023-01-24 11:16:11 +0100 <tomsmeding> I'd like to see that
2023-01-24 11:16:20 +0100 <tomsmeding> because ostensibly that is impossible in haskell
2023-01-24 11:16:35 +0100 <tomsmeding> without having some witnesses at the value level
2023-01-24 11:16:53 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:eb4b:602d:4e:447d)
2023-01-24 11:17:11 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 246 seconds)
2023-01-24 11:17:40 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-24 11:17:44 +0100 <Inst> https://gist.github.com/cdepillabout/d63fcbf8e343b691681f43d287d9d191#file-fizzbuzzone-hs
2023-01-24 11:18:11 +0100 <c_wraith> that's importing singletons and doing SNat stuff
2023-01-24 11:18:23 +0100 <tomsmeding> and even doing some stuff value-level only
2023-01-24 11:20:10 +0100mokee(~mokee@37.228.215.106)
2023-01-24 11:23:30 +0100 <boxscape_> and singletons has Show_ which is pretty much type-level show https://hackage.haskell.org/package/singletons-base-3.1.1/docs/Prelude-Singletons.html#t:Show_
2023-01-24 11:24:28 +0100 <boxscape_> more specifically, this is where the Nat instance is generated https://hackage.haskell.org/package/singletons-base-3.1.1/docs/src/Text.Show.Singletons.html#Shows…
2023-01-24 11:28:14 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-24 11:29:06 +0100 <Inst> shit, i don't think Show_ guarantees KnownSymbol
2023-01-24 11:30:43 +0100 <boxscape_> I imagine you'd have to use sShow_ to get something like that, i.e. operate on a singleton of a Nat to get a Singleton of a Symbol
2023-01-24 11:31:54 +0100 <boxscape_> tomsmeding SSymbol probably isn't exported so that it can be changed later without backcompat concerns, the whole Symbol/String thing is still in flux, see e.g. https://github.com/ghc-proposals/ghc-proposals/pull/562
2023-01-24 11:33:33 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:7175:25c6:a924:f8cd)
2023-01-24 11:34:46 +0100ub(~Thunderbi@p200300ecdf264e3f7f9ba4aff8511836.dip0.t-ipconnect.de)
2023-01-24 11:35:53 +0100ubert(~Thunderbi@p548c9ce5.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2023-01-24 11:35:53 +0100ububert
2023-01-24 11:35:53 +0100ubert078AAJKZH
2023-01-24 11:35:53 +0100ubert1082AAKLAD
2023-01-24 11:36:53 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 11:38:23 +0100 <boxscape_> fyi maybe you know this but having a "KnownSymbol" instance on a Symbol is essentially the same thing as having a singleton of that Symbol
2023-01-24 11:38:54 +0100 <boxscape_> (I meant to ping Inst)
2023-01-24 11:41:20 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Ping timeout: 246 seconds)
2023-01-24 11:44:24 +0100 <tomsmeding> boxscape_: Inst: Show_ seems to take a _value_ and show that into a SomeSymbol, which it then throws away the value-level info of
2023-01-24 11:44:30 +0100 <tomsmeding> not sure why that would be useful
2023-01-24 11:45:14 +0100 <tomsmeding> Inst: to do computation at runtime, you must have values :p
2023-01-24 11:45:40 +0100 <boxscape_> tomsmeding that doesn't sound right? e.g. I have a ghci instance where I type `ghci> :kind! Show_ 12`, and as result it prints the type `"12"`
2023-01-24 11:45:48 +0100 <tomsmeding> boxscape_: that's static computation
2023-01-24 11:45:54 +0100 <boxscape_> sure
2023-01-24 11:45:55 +0100 <tomsmeding> oh right
2023-01-24 11:46:08 +0100 <tomsmeding> right, but that means Show_ is only ever useful on statically-known values
2023-01-24 11:46:11 +0100 <tomsmeding> which is a use-case
2023-01-24 11:46:19 +0100 <tomsmeding> but not Inst's one
2023-01-24 11:46:28 +0100 <boxscape_> yeah I think Inst needs to use sShow_
2023-01-24 11:46:31 +0100 <tomsmeding> yeah
2023-01-24 11:46:41 +0100 <Inst> sigh
2023-01-24 11:47:16 +0100 <tomsmeding> I think even in Agda and Idris, types are erased at runtime if you extract to haskell?
2023-01-24 11:47:24 +0100 <tomsmeding> but not sure about that
2023-01-24 11:47:31 +0100 <boxscape_> hmm not sure how that works
2023-01-24 11:47:54 +0100 <boxscape_> (sShow_ example: `ghci> sShow_ (sing @12)` produces `SSym @"12"`)
2023-01-24 11:48:53 +0100 <tomsmeding> iirc at least agda just extracts the value-level part of your program and puts unsafeCoerce everywhere the haskell typesystem cannot express agda's derived equalities
2023-01-24 11:49:02 +0100 <tomsmeding> s/express/prove/
2023-01-24 11:49:23 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2023-01-24 11:50:14 +0100 <boxscape_> btw there might be a difference here between compiling to haskell and extracting to haskell
2023-01-24 11:50:29 +0100 <boxscape_> i.e. in the latter case you care about what your code looks like
2023-01-24 11:53:39 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-01-24 11:54:04 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 11:58:45 +0100xff0x_(~xff0x@2405:6580:b080:900:ece5:bb89:923a:51c8)
2023-01-24 12:00:56 +0100acidjnk_new(~acidjnk@p200300d6e715c483c1bce9b910063906.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2023-01-24 12:01:02 +0100082AAKLAD(~Thunderbi@2a02:8109:abc0:6434:7175:25c6:a924:f8cd) (Quit: 082AAKLAD)
2023-01-24 12:01:14 +0100ubert(~Thunderbi@2a02:8109:abc0:6434:7175:25c6:a924:f8cd)
2023-01-24 12:01:19 +0100 <albet70> can filter apply on function?
2023-01-24 12:01:39 +0100mizlan(~mizlan@169.150.203.52) (Ping timeout: 260 seconds)
2023-01-24 12:01:45 +0100 <juri_> filterWith
2023-01-24 12:02:03 +0100 <albet70> :t filterWith
2023-01-24 12:02:04 +0100 <lambdabot> error:
2023-01-24 12:02:04 +0100 <lambdabot> • Variable not in scope: filterWith
2023-01-24 12:02:04 +0100 <lambdabot> • Perhaps you meant one of these:
2023-01-24 12:02:09 +0100 <juri_> er. gah, by brain's not working.
2023-01-24 12:02:18 +0100 <albet70> :t filter
2023-01-24 12:02:19 +0100 <lambdabot> (a -> Bool) -> [a] -> [a]
2023-01-24 12:02:57 +0100 <albet70> this could be more general? [a] to m a or t a?
2023-01-24 12:03:25 +0100 <albet70> :t fmap
2023-01-24 12:03:25 +0100 <lambdabot> Functor f => (a -> b) -> f a -> f b
2023-01-24 12:03:38 +0100 <albet70> :t foldl1
2023-01-24 12:03:40 +0100 <lambdabot> Foldable t => (a -> a -> a) -> t a -> a
2023-01-24 12:03:41 +0100 <boxscape_> albet70 see https://hackage.haskell.org/package/witherable-0.4.2/docs/Witherable.html
2023-01-24 12:05:16 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 12:06:11 +0100 <albet70> boxscape_ , Reader isn't Filterable?
2023-01-24 12:07:03 +0100 <carbolymer> why GHC is complaining here: https://bpa.st/W4QLC ? shouldn't this record update be unambiguous in this case, because the type S is specified?
2023-01-24 12:07:23 +0100 <albet70> (a->Bool) -> (a->b) -> a -> b isn't possible for filter?
2023-01-24 12:07:41 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-24 12:08:05 +0100 <carbolymer> even with patterh matching of a constructor I still get the warning
2023-01-24 12:08:10 +0100boxscape_(~boxscape_@213.52.37.155) (Ping timeout: 252 seconds)
2023-01-24 12:09:32 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 255 seconds)
2023-01-24 12:10:31 +0100jonathanx_(~jonathan@h-178-174-176-109.A357.priv.bahnhof.se) (Remote host closed the connection)
2023-01-24 12:12:26 +0100 <carbolymer> oh, when I update two fields, everything is fine suddenly, even if records contains 1034876 fields
2023-01-24 12:12:43 +0100 <carbolymer> fine then https://www.youtube.com/watch?v=caXeAMseve0
2023-01-24 12:13:04 +0100gurkenglas(~gurkengla@dynamic-046-114-181-040.46.114.pool.telefonica.de) (Ping timeout: 252 seconds)
2023-01-24 12:14:54 +0100Midjak(~Midjak@82.66.147.146)
2023-01-24 12:15:08 +0100jonathanx(~jonathan@h-178-174-176-109.a357.priv.bahnhof.se)
2023-01-24 12:18:25 +0100 <lyxia> carbolymer: disambiguation happens before type-checking. At that point it doesn't know the type of r yet. Disambiguation relies on it being written literally as (r :: S).
2023-01-24 12:18:46 +0100 <carbolymer> lyxia: that sheds some light, thanks
2023-01-24 12:19:42 +0100mizlan(~mizlan@169.150.203.64)
2023-01-24 12:20:48 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-01-24 12:24:39 +0100 <jackdk> albet70: just from looking at that type signature, I can say that function _must_ apply the `a -> b` parameter to the `a` parameter, because I _must_ return a `b`.
2023-01-24 12:28:55 +0100 <lyxia> carbolymer: more precisely it is considered a misfeature that it works currently (too complicated implementation, non-intuitive behavior beyond the simplest cases), and the warning was added in prevision for phasing that feature out so that explicit signatures are the only way to disambiguate record updates
2023-01-24 12:28:57 +0100 <lyxia> https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0366-no-ambiguous-field-acces…
2023-01-24 12:36:30 +0100razetime(~Thunderbi@117.193.5.253)
2023-01-24 12:36:36 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf)
2023-01-24 12:37:44 +0100trev(~trev@user/trev) (Remote host closed the connection)
2023-01-24 12:37:49 +0100 <carbolymer> lyxia: it feels like it. thanks for the link, those workarounds are useful
2023-01-24 12:37:55 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:44e8:662a:49b5:c27) (Ping timeout: 260 seconds)
2023-01-24 12:37:55 +0100use-value1use-value
2023-01-24 12:38:46 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:cd53:505b:6825:9d7f) (Quit: Leaving)
2023-01-24 12:41:35 +0100 <jackdk> See also https://github.com/ghc-proposals/ghc-proposals/pull/537 - the disambiguation story could remain
2023-01-24 12:45:56 +0100jonathanx(~jonathan@h-178-174-176-109.a357.priv.bahnhof.se) (Remote host closed the connection)
2023-01-24 12:47:41 +0100jonathanx(~jonathan@h-178-174-176-109.a357.priv.bahnhof.se)
2023-01-24 12:49:02 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-24 12:51:09 +0100boxscape_(~boxscape_@213.52.37.155)
2023-01-24 12:55:44 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 13:00:20 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 260 seconds)
2023-01-24 13:05:10 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:1128:5091:e8f3:b17a)
2023-01-24 13:06:51 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:75c2:a71f:beaa:29bf) (Ping timeout: 260 seconds)
2023-01-24 13:06:51 +0100use-value1use-value
2023-01-24 13:08:33 +0100michalz(~michalz@185.246.207.200)
2023-01-24 13:10:07 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:1128:5091:e8f3:b17a)
2023-01-24 13:11:17 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:1128:5091:e8f3:b17a) (Ping timeout: 246 seconds)
2023-01-24 13:11:17 +0100use-value1use-value
2023-01-24 13:21:08 +0100mizlan(~mizlan@169.150.203.64) (Ping timeout: 246 seconds)
2023-01-24 13:23:08 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-24 13:34:41 +0100stiell_(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds)
2023-01-24 13:36:08 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 13:36:33 +0100acidjnk_new(~acidjnk@p200300d6e715c483f5265d28049d82bf.dip0.t-ipconnect.de)
2023-01-24 13:37:00 +0100eruditass(uid248673@id-248673.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-24 13:39:03 +0100ddellacosta(~ddellacos@143.244.47.100) (Ping timeout: 260 seconds)
2023-01-24 13:39:32 +0100Inst(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 255 seconds)
2023-01-24 13:41:00 +0100ddellacosta(~ddellacos@static-198-44-136-184.cust.tzulo.com)
2023-01-24 13:42:01 +0100anpad(~pandeyan@user/anpad) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-24 13:45:23 +0100anpad(~pandeyan@user/anpad)
2023-01-24 13:46:32 +0100stiell_(~stiell@gateway/tor-sasl/stiell)
2023-01-24 13:46:37 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 13:46:43 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 268 seconds)
2023-01-24 13:48:19 +0100mei(~mei@user/mei) (Remote host closed the connection)
2023-01-24 13:48:49 +0100mei(~mei@user/mei)
2023-01-24 13:50:35 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-01-24 13:50:39 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 13:50:41 +0100mizlan(~mizlan@169.150.203.51)
2023-01-24 13:50:53 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 246 seconds)
2023-01-24 13:56:08 +0100ubert(~Thunderbi@2a02:8109:abc0:6434:7175:25c6:a924:f8cd) (Remote host closed the connection)
2023-01-24 13:56:08 +0100078AAJKZHubert
2023-01-24 13:56:22 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:8ea:a44d:5c6d:60e6)
2023-01-24 13:59:11 +0100cheater_(~Username@user/cheater)
2023-01-24 14:01:42 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2023-01-24 14:01:48 +0100cheater_cheater
2023-01-24 14:04:10 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com)
2023-01-24 14:12:55 +0100Bocaneri(~sauvin@user/Sauvin)
2023-01-24 14:12:56 +0100Lears(~Leary]@user/Leary/x-0910699)
2023-01-24 14:13:18 +0100BocaneriGuest4358
2023-01-24 14:13:22 +0100EvanR_(~EvanR@user/evanr)
2023-01-24 14:13:23 +0100the_proffesor(~theproffe@2601:282:8800:3f30::b942)
2023-01-24 14:13:23 +0100the_proffesor(~theproffe@2601:282:8800:3f30::b942) (Changing host)
2023-01-24 14:13:23 +0100the_proffesor(~theproffe@user/theproffesor)
2023-01-24 14:13:31 +0100dagi41990(~dagit@c-24-21-226-72.hsd1.or.comcast.net)
2023-01-24 14:13:34 +0100raoul9(~raoul@95.179.203.88)
2023-01-24 14:13:34 +0100\yrlnry(~yrlnry@2600:4040:738e:5400:b8c6:a4da:9f09:51fa)
2023-01-24 14:13:38 +0100jelewis2(~lewisje@72.49.207.113)
2023-01-24 14:13:42 +0100raehik_(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 14:14:03 +0100tabemann_(~tabemann@2600:1700:7990:24e0:2b1c:a4e:d843:5301)
2023-01-24 14:14:11 +0100Midjak2(~Midjak@82.66.147.146)
2023-01-24 14:14:28 +0100AndreasK_(sid320732@id-320732.uxbridge.irccloud.com)
2023-01-24 14:14:28 +0100jtmar(~james@jtmar.me)
2023-01-24 14:14:45 +0100pjlsergeant__(sid143467@id-143467.hampstead.irccloud.com)
2023-01-24 14:14:48 +0100img_(~img@user/img)
2023-01-24 14:14:50 +0100dysfigured(dfg@dfg.rocks)
2023-01-24 14:14:57 +0100Taneb0(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0)
2023-01-24 14:15:03 +0100natto17(~natto@140.238.225.67)
2023-01-24 14:15:05 +0100jinsl-(~jinsl@2408:8207:255b:27c0:211:32ff:fec8:6aea)
2023-01-24 14:15:08 +0100comerijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 14:15:26 +0100johnw_(~johnw@2600:1700:cf00:db0:ed68:6ce8:98a1:2c83)
2023-01-24 14:15:34 +0100gawen_(~gawen@user/gawen)
2023-01-24 14:15:52 +0100kadobanana(~mud@user/kadoban)
2023-01-24 14:15:53 +0100jrm2(~jrm@user/jrm)
2023-01-24 14:16:04 +0100burakcan-(burakcank@has.arrived.and.is.ready-to.party)
2023-01-24 14:16:22 +0100hololeap_(~quassel@user/hololeap)
2023-01-24 14:16:34 +0100piele_(~piele@tbonesteak.creativeserver.net)
2023-01-24 14:16:52 +0100glguy_(~glguy@libera/staff-emeritus/glguy)
2023-01-24 14:16:52 +0100_mokee_(~mokee@37.228.215.106)
2023-01-24 14:16:58 +0100some02(~cat@user/sudden)
2023-01-24 14:17:07 +0100shachaf_(~shachaf@li227-219.members.linode.com)
2023-01-24 14:17:10 +0100gentauro_(~gentauro@cgn-cgn11-185-107-12-141.static.kviknet.net)
2023-01-24 14:17:22 +0100pja_(~pja@2a02:8010:6098:0:e65f:1ff:fe1f:660f)
2023-01-24 14:17:33 +0100takuan_dozo(~takuan@178-116-218-225.access.telenet.be)
2023-01-24 14:17:50 +0100Momentum_(momentum@tilde.team)
2023-01-24 14:17:51 +0100tessier_(~treed@98.171.210.130)
2023-01-24 14:17:55 +0100Major_Biscuit(~MajorBisc@2001:1c00:2402:2d00:9eeb:34cf:63b3:9e5b)
2023-01-24 14:17:56 +0100cstml(cstml@tilde.club)
2023-01-24 14:18:13 +0100k33(~~kee@user/wizzwizz4)
2023-01-24 14:18:25 +0100mei(~mei@user/mei) (Killed (copper.libera.chat (Nickname regained by services)))
2023-01-24 14:18:30 +0100mei(~mei@user/mei)
2023-01-24 14:19:05 +0100Maxdaman1us(~Maxdamant@user/maxdamantus)
2023-01-24 14:20:36 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (*.net *.split)
2023-01-24 14:20:36 +0100anpad(~pandeyan@user/anpad) (*.net *.split)
2023-01-24 14:20:36 +0100Midjak(~Midjak@82.66.147.146) (*.net *.split)
2023-01-24 14:20:36 +0100mokee(~mokee@37.228.215.106) (*.net *.split)
2023-01-24 14:20:36 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (*.net *.split)
2023-01-24 14:20:36 +0100MajorBiscuit(~MajorBisc@2001:1c00:2402:2d00:9eeb:34cf:63b3:9e5b) (*.net *.split)
2023-01-24 14:20:36 +0100theproffesor(~theproffe@user/theproffesor) (*.net *.split)
2023-01-24 14:20:36 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (*.net *.split)
2023-01-24 14:20:36 +0100pjlsergeant_(sid143467@id-143467.hampstead.irccloud.com) (*.net *.split)
2023-01-24 14:20:36 +0100johnw(~johnw@76-234-69-149.lightspeed.frokca.sbcglobal.net) (*.net *.split)
2023-01-24 14:20:36 +0100dfg(dfg@user/dfg) (*.net *.split)
2023-01-24 14:20:36 +0100jinsl(~jinsl@2408:8207:255b:27c0:211:32ff:fec8:6aea) (*.net *.split)
2023-01-24 14:20:36 +0100tessier(~treed@98.171.210.130) (*.net *.split)
2023-01-24 14:20:36 +0100shachaf(~shachaf@user/shachaf) (*.net *.split)
2023-01-24 14:20:36 +0100yrlnry(~yrlnry@2600:4040:738e:5400:b8c6:a4da:9f09:51fa) (*.net *.split)
2023-01-24 14:20:36 +0100natto(~natto@140.238.225.67) (*.net *.split)
2023-01-24 14:20:36 +0100dagit(~dagit@2001:558:6025:38:71c6:9d58:7252:8976) (*.net *.split)
2023-01-24 14:20:36 +0100sudden(~cat@user/sudden) (*.net *.split)
2023-01-24 14:20:36 +0100Momentum(momentum@tilde.team) (*.net *.split)
2023-01-24 14:20:36 +0100_koolazer(~koo@user/koolazer) (*.net *.split)
2023-01-24 14:20:36 +0100hololeap(~quassel@user/hololeap) (*.net *.split)
2023-01-24 14:20:36 +0100img(~img@user/img) (*.net *.split)
2023-01-24 14:20:36 +0100EvanR(~EvanR@user/evanr) (*.net *.split)
2023-01-24 14:20:36 +0100tabemann(~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net) (*.net *.split)
2023-01-24 14:20:36 +0100[Leary](~Leary]@user/Leary/x-0910699) (*.net *.split)
2023-01-24 14:20:36 +0100Maxdamantus(~Maxdamant@user/maxdamantus) (*.net *.split)
2023-01-24 14:20:36 +0100pja(~pja@2a02:8010:6098:0:e65f:1ff:fe1f:660f) (*.net *.split)
2023-01-24 14:20:36 +0100Taneb(~Taneb@2001:41c8:51:10d:aaaa:0:aaaa:0) (*.net *.split)
2023-01-24 14:20:36 +0100cstml_(cstml@tilde.club) (*.net *.split)
2023-01-24 14:20:36 +0100son0p(~ff@181.136.122.143) (*.net *.split)
2023-01-24 14:20:36 +0100arflech__(~lewisje@72.49.207.113) (*.net *.split)
2023-01-24 14:20:36 +0100tureba(~tureba@tureba.org) (*.net *.split)
2023-01-24 14:20:36 +0100burakcank(burakcank@has.arrived.and.is.ready-to.party) (*.net *.split)
2023-01-24 14:20:36 +0100jrm(~jrm@user/jrm) (*.net *.split)
2023-01-24 14:20:36 +0100Sauvin(~sauvin@user/Sauvin) (*.net *.split)
2023-01-24 14:20:36 +0100gentauro(~gentauro@user/gentauro) (*.net *.split)
2023-01-24 14:20:36 +0100glguy(~glguy@libera/staff-emeritus/glguy) (*.net *.split)
2023-01-24 14:20:36 +0100kee(~~kee@user/wizzwizz4) (*.net *.split)
2023-01-24 14:20:36 +0100gawen(~gawen@user/gawen) (*.net *.split)
2023-01-24 14:20:36 +0100raoul(~raoul@95.179.203.88) (*.net *.split)
2023-01-24 14:20:36 +0100piele(~piele@tbonesteak.creativeserver.net) (*.net *.split)
2023-01-24 14:20:36 +0100mud(~mud@user/kadoban) (*.net *.split)
2023-01-24 14:20:37 +0100peutri(~peutri@bobo.desast.re) (*.net *.split)
2023-01-24 14:20:37 +0100AndreasK(sid320732@id-320732.uxbridge.irccloud.com) (*.net *.split)
2023-01-24 14:20:37 +0100jamestmartin(~james@jtmar.me) (*.net *.split)
2023-01-24 14:20:37 +0100jjhoo(~jahakala@user/jjhoo) (*.net *.split)
2023-01-24 14:20:38 +0100AndreasK_AndreasK
2023-01-24 14:20:40 +0100burakcan-burakcank
2023-01-24 14:20:46 +0100jrm2jrm
2023-01-24 14:20:46 +0100raoul9raoul
2023-01-24 14:21:42 +0100 <dminuoso> Mmm, Im beginning to really like haskell.nix.
2023-01-24 14:21:50 +0100peutri(~peutri@bobo.desast.re)
2023-01-24 14:22:01 +0100koolazer(~koo@user/koolazer)
2023-01-24 14:22:16 +0100jjhoo(jahakala@user/jjhoo)
2023-01-24 14:22:39 +0100 <boxscape_> what do you like about it?
2023-01-24 14:23:19 +0100 <dminuoso> It gives me coherences with non-nix builds, and doesnt have this stupid "stack-like" curated but buggy and not-well-maintained subset of hackage
2023-01-24 14:23:33 +0100 <dminuoso> And unlike the nixpkgs builders stuff, its very well documented
2023-01-24 14:23:38 +0100 <boxscape_> hm I see
2023-01-24 14:23:54 +0100Niclelscore(~Niclelsco@94.25.229.249)
2023-01-24 14:23:55 +0100 <boxscape_> I have had trouble with documentation when using non-haskell.nix nix with haskell
2023-01-24 14:23:59 +0100 <dminuoso> Like, it describes every function, every argument, tells you what kind of "types" go in and out
2023-01-24 14:24:32 +0100 <dminuoso> with callCabal2nix, its mostly "screw you, here's some absurdly obfuscated nix code with zero comments, and zero documentation, zero guides"
2023-01-24 14:24:51 +0100opticblast(~Thunderbi@secure-165.caltech.edu)
2023-01-24 14:26:10 +0100tureba(tureba@tureba.org)
2023-01-24 14:26:14 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-24 14:26:19 +0100 <boxscape_> the solution I used a few years ago was this sort of file https://github.com/JakobBruenker/assembler/blob/master/default.nix but I don't know if that still works, and yeah if you wanted to do anything non-standard it was pretty difficult to figure out how
2023-01-24 14:27:05 +0100Niclelscore(~Niclelsco@94.25.229.249) (Client Quit)
2023-01-24 14:27:11 +0100jao(~jao@cpc103048-sgyl39-2-0-cust502.18-2.cable.virginm.net)
2023-01-24 14:27:14 +0100 <dminuoso> Ah yeah
2023-01-24 14:27:33 +0100 <dminuoso> I mean nixpkgs has improved much over the past few months, but honestly I still have a sore taste in my mouth
2023-01-24 14:27:40 +0100 <fendor[m]> :k '['()]
2023-01-24 14:27:41 +0100 <lambdabot> error: parse error on input ‘'’
2023-01-24 14:27:41 +0100 <dminuoso> And the code quality is often subpar
2023-01-24 14:27:51 +0100 <dminuoso> :k [()]
2023-01-24 14:27:52 +0100 <lambdabot> *
2023-01-24 14:27:55 +0100 <fendor[m]> :k '[ '()]
2023-01-24 14:27:56 +0100 <lambdabot> [()]
2023-01-24 14:28:18 +0100 <fendor[m]> any idea why the space is needed here
2023-01-24 14:28:28 +0100Midjak2(~Midjak@82.66.147.146) (Quit: Leaving)
2023-01-24 14:28:29 +0100 <boxscape_> because otherwise '[' is parsed as a character
2023-01-24 14:28:53 +0100 <boxscape_> or, reserved to be parsed as character? not sure, especially since it's lambdabot
2023-01-24 14:29:03 +0100 <dminuoso> Its not just lambdabot
2023-01-24 14:29:04 +0100Midjak(~Midjak@82.66.147.146)
2023-01-24 14:29:07 +0100 <dminuoso> ghci chokes as well
2023-01-24 14:29:13 +0100 <fendor[m]> it happens in ghci and ghc as well
2023-01-24 14:29:33 +0100 <boxscape_> but it has a different parse error
2023-01-24 14:29:39 +0100 <boxscape_> because I think it does parse it as character
2023-01-24 14:29:45 +0100 <fendor[m]> but that parsing ambiguity makes sense, I didn't of it
2023-01-24 14:29:49 +0100 <dminuoso> 14:28:29 boxscape_ | because otherwise '[' is parsed as a characte
2023-01-24 14:29:51 +0100 <dminuoso> ^-
2023-01-24 14:29:55 +0100 <dminuoso> Well lexing ambiguity.
2023-01-24 14:29:59 +0100 <boxscape_> right
2023-01-24 14:30:00 +0100 <dminuoso> The parser could deal with it, but not the lexer
2023-01-24 14:30:25 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-24 14:30:33 +0100 <dminuoso> Though Im not sure, are characters promoted as well?
2023-01-24 14:30:34 +0100 <boxscape_> % :k '['
2023-01-24 14:30:34 +0100 <yahb2> '[' :: Char
2023-01-24 14:30:38 +0100 <boxscape_> :k '['
2023-01-24 14:30:39 +0100 <lambdabot> error: parse error on input ‘'’
2023-01-24 14:30:41 +0100 <fendor[m]> reminds me of the time I forgot about comments in ghci
2023-01-24 14:30:47 +0100anpad(~pandeyan@user/anpad)
2023-01-24 14:30:47 +0100 <boxscape_> the character kind is newish but does exist, yeah
2023-01-24 14:30:53 +0100 <dminuoso> % f :: Const () '['; f = undefined
2023-01-24 14:30:53 +0100 <yahb2> <no output>
2023-01-24 14:30:57 +0100 <dminuoso> Ahh. Here.
2023-01-24 14:31:10 +0100 <dminuoso> ^- so I guess that conclusively proves that character literals are promoted as well
2023-01-24 14:32:07 +0100razetime(~Thunderbi@117.193.5.253) (Quit: See You Space Cowboy)
2023-01-24 14:32:09 +0100 <dminuoso> fendor[m]: https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/data_kinds.html#distinguishing-between-typ…
2023-01-24 14:32:13 +0100 <dminuoso> its even explicitly documented
2023-01-24 14:32:17 +0100 <dminuoso> ```Just as in the case of Template Haskell (Syntax), GHC gets confused if you put a quote mark before a data constructor whose second character is a quote mark. In this case, just put a space between the promotion quote and the data constructor:
2023-01-24 14:32:21 +0100 <boxscape_> % :kind! UnconsSymbol "foo"
2023-01-24 14:32:22 +0100 <yahb2> UnconsSymbol "foo" :: Maybe (Char, Symbol) ; = 'Just '('f', "oo")
2023-01-24 14:32:42 +0100 <dminuoso> :S
2023-01-24 14:32:53 +0100 <dminuoso> Now we just need an IO kind
2023-01-24 14:32:59 +0100 <boxscape_> true
2023-01-24 14:33:03 +0100 <dminuoso> So we can do things like launch missiles during type checking
2023-01-24 14:34:14 +0100 <dminuoso> Just imagine the fun of working with PrimTypes, something as mundane as `IO \rw -> case f rw of (rw', a) -> ...` would be a lot of gibberish spaghetti code
2023-01-24 14:34:20 +0100 <fendor[m]> dminuoso, thank you very much!
2023-01-24 14:36:11 +0100 <boxscape_> I guess having IO alone isn't enough, you also need a typeruntime to execute the effects
2023-01-24 14:36:21 +0100 <boxscape_> s/typeruntime/compile-time runtime
2023-01-24 14:36:39 +0100 <dminuoso> boxscape_: The end of the story is just: Just use idris.
2023-01-24 14:36:41 +0100michalzmichalz_
2023-01-24 14:36:49 +0100 <boxscape_> can you use IO during type checking in Idris though
2023-01-24 14:36:56 +0100 <dminuoso> Yup
2023-01-24 14:37:00 +0100 <boxscape_> oh, neat
2023-01-24 14:37:10 +0100 <dminuoso> Well no sorry
2023-01-24 14:37:13 +0100 <dminuoso> I misread
2023-01-24 14:37:15 +0100 <boxscape_> oh :(
2023-01-24 14:37:31 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch)
2023-01-24 14:37:39 +0100 <dminuoso> But for what its worth, you can always insert a type checker plugin to do anything you want in GHC
2023-01-24 14:38:11 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-01-24 14:41:21 +0100 <boxscape_> or do arbitrary IO with TH
2023-01-24 14:42:48 +0100 <dminuoso> Im a bit sad you can do that
2023-01-24 14:43:06 +0100 <dminuoso> I kind of wish we had a more limited macro subsystem that can do some limited effects, but not full blown IO
2023-01-24 14:43:15 +0100 <dminuoso> Something standardized, not tied to GHCs internal representation
2023-01-24 14:43:27 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2023-01-24 14:43:27 +0100 <boxscape_> yeah sounds useful
2023-01-24 14:44:12 +0100 <comerijn> I (kinda) like (T)TH, but it's a bit unfortunate there was not though given to how it interacts/should interact with cross-compilation
2023-01-24 14:44:19 +0100 <comerijn> and retro-fitting sane semantics for that is hard
2023-01-24 14:46:05 +0100jero98772(~jero98772@2800:484:1d80:d8ce:3490:26c5:1782:da8c)
2023-01-24 14:48:13 +0100xff0x_(~xff0x@2405:6580:b080:900:ece5:bb89:923a:51c8) (Ping timeout: 252 seconds)
2023-01-24 14:48:35 +0100xff0x_(~xff0x@178.255.149.135)
2023-01-24 14:48:35 +0100Guest|20(~Guest|20@c-73-176-81-178.hsd1.il.comcast.net) (Ping timeout: 260 seconds)
2023-01-24 14:48:47 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-24 14:49:15 +0100michalz(~michalz@185.246.207.221)
2023-01-24 14:51:26 +0100mizlan(~mizlan@169.150.203.51) (Ping timeout: 246 seconds)
2023-01-24 14:52:33 +0100ccapndave(~ccapndave@xcpe-62-167-164-99.cgn.res.adslplus.ch) (Quit: Textual IRC Client: www.textualapp.com)
2023-01-24 14:56:43 +0100raehik_(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-01-24 15:01:07 +0100acidjnk_new(~acidjnk@p200300d6e715c483f5265d28049d82bf.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-01-24 15:01:19 +0100xff0x_(~xff0x@178.255.149.135) (Ping timeout: 260 seconds)
2023-01-24 15:01:25 +0100acidjnk_new(~acidjnk@p200300d6e715c48339b8d345b07b8534.dip0.t-ipconnect.de)
2023-01-24 15:02:48 +0100xff0x_(~xff0x@2405:6580:b080:900:ece5:bb89:923a:51c8)
2023-01-24 15:06:02 +0100kurbus(~kurbus@user/kurbus)
2023-01-24 15:09:09 +0100Axman6(~Axman6@user/axman6) (Ping timeout: 268 seconds)
2023-01-24 15:10:13 +0100hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 252 seconds)
2023-01-24 15:11:06 +0100Axman6(~Axman6@user/axman6)
2023-01-24 15:16:52 +0100hugo(znc@verdigris.lysator.liu.se)
2023-01-24 15:18:51 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-24 15:19:12 +0100comerijnsighs
2023-01-24 15:19:20 +0100mizlan(~mizlan@89.46.114.27)
2023-01-24 15:19:28 +0100 <comerijn> That moment where you gotta modify 98 modules for a simple refactor >.>
2023-01-24 15:20:51 +0100 <dminuoso> Be glad it is Haskell.
2023-01-24 15:21:05 +0100 <comerijn> I am, but still
2023-01-24 15:21:26 +0100comerijnmerijn
2023-01-24 15:22:06 +0100 <merijn> Also simple enough I can macro it in vim, but horrible diff >.>
2023-01-24 15:24:21 +0100michalz_(~michalz@185.246.207.200) (Quit: Client closed)
2023-01-24 15:25:21 +0100 <boxscape_> tomsmeding I was wrong, SSymbol is exported in base 4.18
2023-01-24 15:25:35 +0100 <boxscape_> see https://github.com/haskell/core-libraries-committee/issues/85
2023-01-24 15:25:51 +0100thegeekinside(~thegeekin@189.180.66.244)
2023-01-24 15:26:01 +0100kurbus(~kurbus@user/kurbus)
2023-01-24 15:27:33 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 15:31:48 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 252 seconds)
2023-01-24 15:35:59 +0100acidjnk_new(~acidjnk@p200300d6e715c48339b8d345b07b8534.dip0.t-ipconnect.de) (Remote host closed the connection)
2023-01-24 15:36:23 +0100acidjnk_new(~acidjnk@p200300d6e715c483e1c7cd94b291a585.dip0.t-ipconnect.de)
2023-01-24 15:41:29 +0100wombat8756(~wombat875@2600:4041:5bea:f800:83f2:bf42:de49:b596) (Ping timeout: 246 seconds)
2023-01-24 15:41:56 +0100razetime(~Thunderbi@117.193.5.253)
2023-01-24 15:41:57 +0100caef^(~caef@c-24-30-76-89.hsd1.ga.comcast.net)
2023-01-24 15:43:04 +0100wombat8756(~wombat875@2600:4041:5bea:f800:da64:71f6:cfa2:558)
2023-01-24 15:44:29 +0100barzo(~hd@31.223.41.44) (Ping timeout: 260 seconds)
2023-01-24 15:47:40 +0100shawwwn_shawwwn
2023-01-24 15:50:38 +0100Inst__(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 15:52:55 +0100 <alexfmpe[m]> <boxscape_> "can you use IO during type..." <- I dunno about arbitrary IO, but type providers do some of that - https://docs.idris-lang.org/en/latest/guides/type-providers-ffi.html#a-simple-example
2023-01-24 15:53:17 +0100 <boxscape_> oh, interesting
2023-01-24 15:54:05 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 255 seconds)
2023-01-24 15:54:57 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-24 15:54:59 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-24 15:59:20 +0100 <kuribas> but idris2 doesn't have type providers...
2023-01-24 16:00:12 +0100 <kuribas> but type providers can be done easily in haskell with TH.
2023-01-24 16:05:59 +0100mc47(~mc47@xmonad/TheMC47)
2023-01-24 16:07:01 +0100Guest75(~Guest75@178.141.138.233)
2023-01-24 16:10:43 +0100acidjnk_new(~acidjnk@p200300d6e715c483e1c7cd94b291a585.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-01-24 16:16:54 +0100barzo(~hd@31.223.41.44)
2023-01-24 16:19:11 +0100mizlan(~mizlan@89.46.114.27) (Ping timeout: 252 seconds)
2023-01-24 16:20:15 +0100 <boxscape_> right, true
2023-01-24 16:21:33 +0100 <carbolymer> `%=` is analogous to `modify`, so is there a lens doing what `state` is doing?
2023-01-24 16:21:55 +0100 <carbolymer> i.e. `s -> (a, s)`
2023-01-24 16:22:40 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-24 16:22:57 +0100 <dminuoso> carbolymer: l %= f = State.modify (l %~ f)
2023-01-24 16:23:05 +0100 <dminuoso> It's nothing special, just a very minor convenience thing
2023-01-24 16:23:28 +0100 <geekosaur> AIUI lens does not incorporate state, just some helpers for it
2023-01-24 16:23:46 +0100son0p(~ff@181.136.122.143)
2023-01-24 16:24:07 +0100 <dminuoso> So its not "analogous" to modify, it's just a wrapper around modify + %~ :)
2023-01-24 16:24:17 +0100Niclelscore(~Niclelsco@94.25.229.249)
2023-01-24 16:24:19 +0100 <dminuoso> (Or it *is* modify)
2023-01-24 16:25:02 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 16:25:41 +0100 <kuribas> IMO 95% of lens is convenience things
2023-01-24 16:25:52 +0100 <kuribas> the other 5% is very handy.
2023-01-24 16:25:54 +0100 <boxscape_> does `\l f -> state (l %~ f)` do anything sensible?
2023-01-24 16:26:15 +0100GoldsteinQ(~goldstein@goldstein.rs) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-24 16:26:19 +0100 <kuribas> :t state
2023-01-24 16:26:20 +0100 <lambdabot> MonadState s m => (s -> (a, s)) -> m a
2023-01-24 16:26:51 +0100 <boxscape_> I guess you need a fairly strange Setter for that to work out
2023-01-24 16:26:54 +0100 <kuribas> :t (%~)
2023-01-24 16:26:55 +0100 <lambdabot> ASetter s t a b -> (a -> b) -> s -> t
2023-01-24 16:27:25 +0100 <geekosaur> `state` is what used to be `State` before `State s` was made a type alias for `StateT s Identity`
2023-01-24 16:27:48 +0100GoldsteinQ(~goldstein@goldstein.rs)
2023-01-24 16:28:32 +0100 <carbolymer> dminuoso: those are only setters, but I'd like to combine getter with setter
2023-01-24 16:29:05 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 246 seconds)
2023-01-24 16:29:37 +0100 <carbolymer> @hoogle <.~
2023-01-24 16:29:37 +0100 <lambdabot> Control.Lens.Operators (<.~) :: ASetter s t a b -> b -> s -> (b, t)
2023-01-24 16:29:37 +0100 <lambdabot> Control.Lens.Setter (<.~) :: ASetter s t a b -> b -> s -> (b, t)
2023-01-24 16:29:37 +0100 <lambdabot> Diagrams.Prelude (<.~) :: () => ASetter s t a b -> b -> s -> (b, t)
2023-01-24 16:29:46 +0100 <carbolymer> looks like what I need
2023-01-24 16:30:23 +0100Guest4358Sauvin
2023-01-24 16:30:43 +0100 <carbolymer> except not in MonadState
2023-01-24 16:30:46 +0100 <dminuoso> carbolymer: ah heh I misread your question, pardon me
2023-01-24 16:30:56 +0100 <dminuoso> carbolymer: yes thats fine, you can just use `lift`
2023-01-24 16:31:12 +0100 <dminuoso> or `state` rather
2023-01-24 16:31:36 +0100 <kuribas> This all looks like line-noise to me.
2023-01-24 16:31:49 +0100 <dminuoso> make up your own operator name, sau s <.= f = state (l <.~ f)
2023-01-24 16:32:04 +0100 <boxscape_> :t <.=
2023-01-24 16:32:05 +0100 <lambdabot> error: parse error on input ‘<.=’
2023-01-24 16:32:10 +0100 <boxscape_> :t (<.=)
2023-01-24 16:32:11 +0100 <lambdabot> MonadState s m => ASetter s s a b -> b -> m b
2023-01-24 16:32:26 +0100 <carbolymer> kuribas: that's where name came from: LinE NoiSe = LENS
2023-01-24 16:32:40 +0100 <kuribas> carbolymer: heheh
2023-01-24 16:33:06 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 16:33:18 +0100 <geekosaur> those who don't know Perl are doomed to repeat it?
2023-01-24 16:33:19 +0100 <carbolymer> dminuoso: yep, I'll probably do that, thanks
2023-01-24 16:35:45 +0100 <boxscape_> carbolymer but it already exists? See my lambdabot message above
2023-01-24 16:36:25 +0100Inst__(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 252 seconds)
2023-01-24 16:37:54 +0100carbolymersquints harder at the operator
2023-01-24 16:38:39 +0100 <geekosaur> you might want to look up the table of operators; they all follow patterns, so you can often construct an operator name just by knowing what you want to do
2023-01-24 16:38:43 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Read error: Connection reset by peer)
2023-01-24 16:38:44 +0100 <carbolymer> boxscape_: it's not what I need, I need exactly `state` but in lens form
2023-01-24 16:38:52 +0100 <boxscape_> ah
2023-01-24 16:39:06 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 16:39:28 +0100 <dminuoso> carbolymer: You can also just use `state` yourself. :p
2023-01-24 16:39:35 +0100 <dminuoso> state (l <.~ f) is not unreadable
2023-01-24 16:39:50 +0100 <carbolymer> yeah, I'm going into that direction
2023-01-24 16:39:54 +0100 <boxscape_> state (l <.~ f) is the same as <.=
2023-01-24 16:40:01 +0100 <boxscape_> well, the types are anyway
2023-01-24 16:40:02 +0100 <dminuoso> Ahh heh
2023-01-24 16:40:05 +0100 <dminuoso> boxscape_: that already exists :p
2023-01-24 16:40:09 +0100 <boxscape_> yep :)
2023-01-24 16:40:10 +0100 <dminuoso> https://hackage.haskell.org/package/lens-5.2/docs/Control-Lens-Operators.html#v:-60-.-61-
2023-01-24 16:40:22 +0100 <dminuoso> But thats a different thing
2023-01-24 16:40:37 +0100 <dminuoso> So no, its not the same
2023-01-24 16:40:53 +0100 <dminuoso> % :t \l f -> state (l <.~ f)
2023-01-24 16:40:53 +0100 <yahb2> <interactive>:1:9: error: Variable not in scope: state :: t0 -> t2 ; ; <interactive>:1:18: error: ; Variable not in scope: (<.~) :: t -> t1 -> t0
2023-01-24 16:41:01 +0100 <dminuoso> :t \l f -> state (l <.~ f)
2023-01-24 16:41:03 +0100 <lambdabot> MonadState s m => ASetter s s a1 a2 -> a2 -> m a2
2023-01-24 16:41:10 +0100 <dminuoso> uh oh maybe it is the same
2023-01-24 16:41:27 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 16:41:34 +0100 <dminuoso> % :t (%=)
2023-01-24 16:41:34 +0100 <yahb2> <interactive>:1:1: error: ; • Variable not in scope: %= ; • Perhaps you meant one of these: ; ‘/=’ (imported from Prelude), ‘<=’ (imported from Prelude), ; ‘==’ (imported fr...
2023-01-24 16:41:36 +0100 <dminuoso> :t (%=)
2023-01-24 16:41:37 +0100 <lambdabot> MonadState s m => ASetter s s a b -> (a -> b) -> m ()
2023-01-24 16:44:09 +0100acidjnk_new(~acidjnk@p200300d6e715c483e1c7cd94b291a585.dip0.t-ipconnect.de)
2023-01-24 16:45:51 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Ping timeout: 255 seconds)
2023-01-24 16:48:54 +0100caef^(~caef@c-24-30-76-89.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-01-24 16:49:17 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 16:50:17 +0100mizlan(~mizlan@169.150.203.59)
2023-01-24 16:53:39 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-24 16:53:43 +0100epolanski(uid312403@id-312403.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-24 16:55:05 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 16:56:06 +0100 <raehik> if I want the best performance possible (for a low level lib which most users won't see), must I use unboxed values everywhere? How "reliable" is GHC's unboxing?
2023-01-24 16:56:43 +0100 <raehik> is `Addr#` better than `Ptr a`; is `Word#` better than `Word`
2023-01-24 16:57:11 +0100chiselfuse(~chiselfus@user/chiselfuse) (Ping timeout: 255 seconds)
2023-01-24 16:57:51 +0100 <merijn> I don't think you can generalise like that
2023-01-24 16:58:03 +0100chiselfuse(~chiselfus@user/chiselfuse)
2023-01-24 16:58:20 +0100 <merijn> Outside of your hot loop the difference shouldn't be giant
2023-01-24 16:58:39 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 17:01:26 +0100 <raehik> ok. I don't have a good feel for how GHC will and won't optimize yet and have been lured in by the recent primitives improvements
2023-01-24 17:01:49 +0100 <raehik> I think eventually I will try both and have a look at the core
2023-01-24 17:01:54 +0100 <geekosaur> your best bet is to examine Core, yeh
2023-01-24 17:02:15 +0100 <merijn> It's not even necessarily about "will GHC always optimise unboxing things" it's also just that unboxed values are just more inconvenient to work with, so you don't wanna unbox values where it doesn't matter
2023-01-24 17:02:43 +0100 <merijn> And outside of your hot loop it should (generally) not matter *that* much
2023-01-24 17:02:56 +0100halting(~Oliver@177.129.53.34)
2023-01-24 17:03:06 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 252 seconds)
2023-01-24 17:04:27 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 17:04:31 +0100 <raehik> merijn: I appreciate it generally should not matter. I don't touch the stuff in regular boring code
2023-01-24 17:04:52 +0100 <raehik> I wouldn't mind some inconvenience for additional performance or less mem usage
2023-01-24 17:05:11 +0100 <raehik> (in this one place)
2023-01-24 17:06:38 +0100stiell_(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 255 seconds)
2023-01-24 17:07:05 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 255 seconds)
2023-01-24 17:07:26 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Remote host closed the connection)
2023-01-24 17:08:21 +0100q0r(~user@162.255.84.96) (Ping timeout: 255 seconds)
2023-01-24 17:08:30 +0100mixphix(~cigsender@74.124.58.162)
2023-01-24 17:08:59 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2023-01-24 17:09:34 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:eb4b:602d:4e:447d) (Ping timeout: 252 seconds)
2023-01-24 17:10:36 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-01-24 17:17:14 +0100Niclelscore(~Niclelsco@94.25.229.249) (Ping timeout: 260 seconds)
2023-01-24 17:22:39 +0100stiell_(~stiell@gateway/tor-sasl/stiell)
2023-01-24 17:24:12 +0100k33kee
2023-01-24 17:24:20 +0100opticblast(~Thunderbi@secure-165.caltech.edu) (Ping timeout: 246 seconds)
2023-01-24 17:24:42 +0100halting(~Oliver@177.129.53.34) (Quit: Leaving)
2023-01-24 17:26:47 +0100shriekingnoise_(~shrieking@186.137.175.87)
2023-01-24 17:28:26 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-01-24 17:29:19 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-01-24 17:30:04 +0100shriekingnoise(~shrieking@186.137.175.87) (Ping timeout: 260 seconds)
2023-01-24 17:31:42 +0100troydm(~troydm@user/troydm) (Ping timeout: 252 seconds)
2023-01-24 17:35:52 +0100Sgeo(~Sgeo@user/sgeo)
2023-01-24 17:36:44 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 268 seconds)
2023-01-24 17:41:44 +0100boxscape_(~boxscape_@213.52.37.155) (Ping timeout: 260 seconds)
2023-01-24 17:48:37 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 252 seconds)
2023-01-24 17:48:43 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 17:50:19 +0100mizlan(~mizlan@169.150.203.59) (Ping timeout: 248 seconds)
2023-01-24 17:53:34 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)
2023-01-24 17:57:11 +0100shriekingnoise(~shrieking@186.137.175.87)
2023-01-24 17:59:39 +0100shriekingnoise_(~shrieking@186.137.175.87) (Ping timeout: 252 seconds)
2023-01-24 18:00:44 +0100 <carbolymer> how can I build an infinite list with `State`? https://bpa.st/7PVMG this doesn't seem to be cutting it
2023-01-24 18:00:53 +0100q0r(~user@162.255.84.96)
2023-01-24 18:02:18 +0100 <int-e> You don't... intuitively, there's no point in that evaluation where it's clear that the state can't be reset completely. You can use a Writer instead.
2023-01-24 18:03:34 +0100 <int-e> > execWriter $ forever (tell [True])
2023-01-24 18:03:35 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 246 seconds)
2023-01-24 18:03:36 +0100 <lambdabot> [True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,...
2023-01-24 18:03:37 +0100oldfashionedcow(~Rahul_San@user/oldfashionedcow)
2023-01-24 18:04:00 +0100 <carbolymer> hmm... so what's the purpose of lazy State?
2023-01-24 18:04:36 +0100 <c_wraith> in most cases, creating a space leak
2023-01-24 18:05:04 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 18:05:33 +0100 <carbolymer> so if I need state to compute my list, I should layer writer on top of state...
2023-01-24 18:05:40 +0100 <int-e> knot-tying through the state; you can also build a result lazily: inflist = do ...; xs <- inflist; return (True : inflist) will work, and the ... part is allowed to modify the state.
2023-01-24 18:05:57 +0100barzo(~hd@31.223.41.44) (Quit: Leaving)
2023-01-24 18:06:04 +0100 <int-e> But the final state can't be produced lazily.
2023-01-24 18:06:05 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 18:06:10 +0100russruss(~russruss@my.russellmcc.com) (Quit: The Lounge - https://thelounge.chat)
2023-01-24 18:06:20 +0100barzo(~hd@31.223.41.44)
2023-01-24 18:06:23 +0100 <carbolymer> I see
2023-01-24 18:06:26 +0100 <carbolymer> i'll try that
2023-01-24 18:06:31 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2023-01-24 18:06:33 +0100 <carbolymer> I mean, writer
2023-01-24 18:06:35 +0100 <carbolymer> thanks
2023-01-24 18:07:45 +0100russruss(~russruss@my.russellmcc.com)
2023-01-24 18:08:05 +0100mizlan(~mizlan@89.46.114.150)
2023-01-24 18:08:15 +0100 <c_wraith> > take 10 $ evalState (let s = do { x <- get ; put (x + 1) ; xs <- s ; pure (x:xs) } in s) 0
2023-01-24 18:08:17 +0100 <lambdabot> [0,1,2,3,4,5,6,7,8,9]
2023-01-24 18:09:05 +0100 <c_wraith> that requires lazy state
2023-01-24 18:16:18 +0100mei(~mei@user/mei) (Quit: mei)
2023-01-24 18:17:27 +0100michalz(~michalz@185.246.207.221) (Remote host closed the connection)
2023-01-24 18:18:46 +0100stiell_(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2023-01-24 18:19:11 +0100stiell_(~stiell@gateway/tor-sasl/stiell)
2023-01-24 18:22:34 +0100mechap1(~mechap@user/mechap) (Ping timeout: 260 seconds)
2023-01-24 18:22:54 +0100cheater_(~Username@user/cheater)
2023-01-24 18:23:08 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 255 seconds)
2023-01-24 18:23:42 +0100mei(~mei@user/mei)
2023-01-24 18:24:25 +0100mechap1(~mechap@user/mechap)
2023-01-24 18:26:03 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-01-24 18:26:35 +0100cheater(~Username@user/cheater) (Ping timeout: 264 seconds)
2023-01-24 18:26:41 +0100cheater_cheater
2023-01-24 18:30:03 +0100 <raehik> I have `data A (a :: Bool) = A`, and some `instance C (A 'True)`, `instance C (A 'False)`. Why can't GHC figure out "ok, `instance C (A a)`"?
2023-01-24 18:31:03 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2023-01-24 18:31:31 +0100 <raehik> I use a pattern like this to bring together a bunch of types under one newtype constructor, and I often have to add "obvious" contexts to deriving clauses
2023-01-24 18:31:48 +0100 <raehik> I get the gist as to why, but I always wonder if there's another way
2023-01-24 18:32:32 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2023-01-24 18:33:18 +0100 <geekosaur> not with ghc, unless there's a plugin that fills in the holes. I still think ghc is kinda pretend type level and if you really want this stuff you should be using a stronger language
2023-01-24 18:35:11 +0100 <raehik> geekosaur: would you have an example? (you're probably gonna tell me to look at Agda or Idris ;_;)
2023-01-24 18:35:21 +0100 <geekosaur> pretty much, yes 🙂
2023-01-24 18:35:52 +0100 <raehik> heheh. maybe next time I will play with Idris, in the knowledge that it's more Haskell-y
2023-01-24 18:35:59 +0100 <raehik> thx
2023-01-24 18:36:12 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Remote host closed the connection)
2023-01-24 18:37:13 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2023-01-24 18:37:34 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 252 seconds)
2023-01-24 18:40:56 +0100ubert1(~Thunderbi@2a02:8109:abc0:6434:8ea:a44d:5c6d:60e6) (Remote host closed the connection)
2023-01-24 18:41:46 +0100econo(uid147250@user/econo)
2023-01-24 18:45:28 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-24 18:47:21 +0100Major_Biscuit(~MajorBisc@2001:1c00:2402:2d00:9eeb:34cf:63b3:9e5b) (Ping timeout: 255 seconds)
2023-01-24 18:49:56 +0100sajith(~sajith@user/sajith) (Quit: Gone)
2023-01-24 18:49:56 +0100nonzen(~nonzen@user/nonzen) (Quit: Gone)
2023-01-24 18:50:13 +0100nonzen(~nonzen@user/nonzen)
2023-01-24 18:50:45 +0100sajith(~sajith@user/sajith)
2023-01-24 18:51:32 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95)
2023-01-24 18:52:08 +0100Inst__(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240)
2023-01-24 18:54:33 +0100dunj3(~dunj3@kingdread.de) (Quit: ZNC 1.7.2+deb3 - https://znc.in)
2023-01-24 18:54:43 +0100dunj3(~dunj3@kingdread.de)
2023-01-24 18:55:10 +0100Inst_(~Inst@2601:6c4:4081:54f0:d621:5cdd:9051:c240) (Ping timeout: 252 seconds)
2023-01-24 18:57:20 +0100dunj3(~dunj3@kingdread.de) (Client Quit)
2023-01-24 18:57:57 +0100CiaoSen(~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 252 seconds)
2023-01-24 18:59:23 +0100razetime(~Thunderbi@117.193.5.253) (Quit: See You Space Cowboy)
2023-01-24 19:01:39 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 260 seconds)
2023-01-24 19:04:00 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-24 19:07:07 +0100segfaultfizzbuzz(~segfaultf@2602:306:cd3c:9350:f9f2:82c3:f192:7b95) (Ping timeout: 248 seconds)
2023-01-24 19:09:03 +0100segfaultfizzbuzz(~segfaultf@2607:fb91:1104:3754:64cc:21ba:e1db:e740)
2023-01-24 19:12:20 +0100slack1256(~slack1256@181.42.52.9)
2023-01-24 19:13:04 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-24 19:17:49 +0100Guest75(~Guest75@178.141.138.233) (Quit: Client closed)
2023-01-24 19:19:23 +0100rustisafungus(~segfaultf@108.211.201.53)
2023-01-24 19:20:12 +0100segfaultfizzbuzz(~segfaultf@2607:fb91:1104:3754:64cc:21ba:e1db:e740) (Ping timeout: 255 seconds)
2023-01-24 19:21:56 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2023-01-24 19:23:31 +0100shachaf_shachaf
2023-01-24 19:23:56 +0100shachaf(~shachaf@li227-219.members.linode.com) (Changing host)
2023-01-24 19:23:56 +0100shachaf(~shachaf@user/shachaf)
2023-01-24 19:25:29 +0100avicenzi(~avicenzi@2a00:ca8:a1f:b004::c32) (Ping timeout: 246 seconds)
2023-01-24 19:28:10 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 252 seconds)
2023-01-24 19:32:03 +0100mizlan(~mizlan@89.46.114.150) (Ping timeout: 252 seconds)
2023-01-24 19:36:28 +0100codaraxis(~codaraxis@user/codaraxis) (Quit: Leaving)
2023-01-24 19:38:28 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-24 19:38:30 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt)
2023-01-24 19:42:58 +0100beteigeuze(~Thunderbi@a79-169-109-107.cpe.netcabo.pt) (Ping timeout: 252 seconds)
2023-01-24 19:44:50 +0100Maxdaman1usMaxdamantus
2023-01-24 19:47:56 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Remote host closed the connection)
2023-01-24 19:48:03 +0100kurbus(~kurbus@user/kurbus)
2023-01-24 19:53:44 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt)
2023-01-24 19:57:04 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Remote host closed the connection)
2023-01-24 19:57:29 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 19:58:59 +0100mizlan(~mizlan@169.150.203.52)
2023-01-24 19:59:59 +0100barzo(~hd@31.223.41.44) (Ping timeout: 260 seconds)
2023-01-24 20:03:50 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2023-01-24 20:03:56 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 255 seconds)
2023-01-24 20:04:45 +0100ec(~ec@gateway/tor-sasl/ec)
2023-01-24 20:06:36 +0100Lycurgus(~juan@user/Lycurgus)
2023-01-24 20:12:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2023-01-24 20:15:32 +0100mizlan(~mizlan@169.150.203.52) (Ping timeout: 246 seconds)
2023-01-24 20:17:30 +0100mizlan(~mizlan@169.150.203.45)
2023-01-24 20:20:24 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 260 seconds)
2023-01-24 20:21:04 +0100mizlan(~mizlan@169.150.203.45) (Remote host closed the connection)
2023-01-24 20:27:51 +0100hugo(znc@verdigris.lysator.liu.se) (Ping timeout: 260 seconds)
2023-01-24 20:30:11 +0100AlexNoo(~AlexNoo@178.34.160.228) (Read error: Connection reset by peer)
2023-01-24 20:30:34 +0100AlexNoo(~AlexNoo@178.34.160.228)
2023-01-24 20:32:57 +0100nehsou^(~nehsou@c-24-30-76-89.hsd1.ga.comcast.net)
2023-01-24 20:33:32 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-01-24 20:34:02 +0100rustisafungus(~segfaultf@108.211.201.53) (Ping timeout: 246 seconds)
2023-01-24 20:35:28 +0100ft(~ft@p4fc2a257.dip0.t-ipconnect.de)
2023-01-24 20:35:34 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 20:35:42 +0100hugo(znc@verdigris.lysator.liu.se)
2023-01-24 20:40:44 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds)
2023-01-24 20:41:09 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 20:42:28 +0100jmdaemon(~jmdaemon@user/jmdaemon)
2023-01-24 20:43:38 +0100mizlan(~mizlan@131.179.77.187)
2023-01-24 20:48:30 +0100Lycurgus(~juan@user/Lycurgus) (Quit: Exeunt: personae.ai-integration.biz)
2023-01-24 20:48:37 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba)
2023-01-24 20:49:03 +0100troydm(~troydm@user/troydm)
2023-01-24 20:55:45 +0100mizlan(~mizlan@131.179.77.187) (Ping timeout: 256 seconds)
2023-01-24 21:01:47 +0100bgs(~bgs@212-85-160-171.dynamic.telemach.net) (Remote host closed the connection)
2023-01-24 21:02:15 +0100beteigeuze(~Thunderbi@bl14-81-220.dsl.telepac.pt) (Ping timeout: 252 seconds)
2023-01-24 21:06:46 +0100slack1256(~slack1256@181.42.52.9) (Remote host closed the connection)
2023-01-24 21:07:13 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Quit: ZNC 1.8.2 - https://znc.in)
2023-01-24 21:07:38 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 246 seconds)
2023-01-24 21:08:22 +0100mikoto-chan(~mikoto-ch@2001:999:784:4cb8:d8e9:51ca:a70:b0e5)
2023-01-24 21:08:53 +0100asivitz(uid178348@id-178348.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-01-24 21:08:56 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2023-01-24 21:09:06 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds)
2023-01-24 21:11:17 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 21:13:41 +0100 <monochrom> > take 10 (execState (let m n = do { m (n+1); s <- get; put (n : s)} in m 0) undefined)
2023-01-24 21:13:43 +0100 <lambdabot> [0,1,2,3,4,5,6,7,8,9]
2023-01-24 21:14:01 +0100 <monochrom> That is the "final" state being a bit lazy, too. :D
2023-01-24 21:16:59 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:13ef:295c:1ca0:c7a2)
2023-01-24 21:20:05 +0100pavonia(~user@user/siracusa)
2023-01-24 21:21:53 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Remote host closed the connection)
2023-01-24 21:22:21 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 21:25:18 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:21ed:337e:734b:fe6a)
2023-01-24 21:25:23 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Remote host closed the connection)
2023-01-24 21:26:41 +0100angelore(~u0_a291@5.46.161.208) (WeeChat 3.8)
2023-01-24 21:26:46 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 21:28:29 +0100smol-hors(sid524992@smol/hors)
2023-01-24 21:36:56 +0100 <int-e> monochrom: ah good point
2023-01-24 21:39:02 +0100Tuplanolla(~Tuplanoll@91-159-68-152.elisa-laajakaista.fi)
2023-01-24 21:39:06 +0100kurbus(~kurbus@user/kurbus) (Quit: Client closed)
2023-01-24 21:40:03 +0100coot(~coot@2a02:a310:e241:1b00:ec1a:e9df:79ac:66ba) (Quit: coot)
2023-01-24 21:40:23 +0100 <int-e> > execState $ do undefined; put 42
2023-01-24 21:40:24 +0100 <lambdabot> <Integer -> Integer>
2023-01-24 21:40:26 +0100waleee(~waleee@h-176-10-137-138.NA.cust.bahnhof.se)
2023-01-24 21:40:35 +0100 <int-e> > execState (do undefined; put 42) undefined
2023-01-24 21:40:36 +0100 <lambdabot> 42
2023-01-24 21:40:54 +0100manwithl-(~manwithlu@194.177.28.192) (Ping timeout: 260 seconds)
2023-01-24 21:41:16 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2023-01-24 21:45:29 +0100mikoto-chan(~mikoto-ch@2001:999:784:4cb8:d8e9:51ca:a70:b0e5) (Ping timeout: 246 seconds)
2023-01-24 21:48:11 +0100hololeap_hololeap
2023-01-24 21:50:06 +0100angelore(~u0_a291@5.46.161.208) (Quit: WeeChat 3.8)
2023-01-24 21:56:22 +0100Guest75(~Guest75@178.141.160.158)
2023-01-24 21:56:24 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67)
2023-01-24 22:00:53 +0100zero(~z@user/zero)
2023-01-24 22:03:45 +0100yin(~z@user/zero) (Ping timeout: 256 seconds)
2023-01-24 22:08:40 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:13ef:295c:1ca0:c7a2) (Quit: WeeChat 2.8)
2023-01-24 22:21:52 +0100kuttenbrunzer(~kuttenbru@2a02:8108:8b80:1d48:21ed:337e:734b:fe6a) (Quit: Leaving)
2023-01-24 22:21:55 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 22:23:09 +0100angelore(~u0_a291@5.46.161.208) (Client Quit)
2023-01-24 22:23:28 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 22:24:57 +0100segfaultfizzbuzz(~segfaultf@108.211.201.53)
2023-01-24 22:25:52 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.5)
2023-01-24 22:25:54 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8)
2023-01-24 22:29:04 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-01-24 22:30:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:81b7:d6f6:7eee:d4f8) (Ping timeout: 252 seconds)
2023-01-24 22:30:17 +0100angelore(~u0_a291@5.46.161.208) (Quit: WeeChat 3.8)
2023-01-24 22:30:29 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 22:30:34 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2023-01-24 22:31:50 +0100zapa1(~zapa1@95.64.72.60)
2023-01-24 22:32:58 +0100angelore(~u0_a291@5.46.161.208) (Client Quit)
2023-01-24 22:33:11 +0100angelore(~u0_a291@5.46.161.208)
2023-01-24 22:33:33 +0100 <zapa1> hi ,Is there anyone who can be my mentor? I am a beginner to programming  and I am just familiar with some basics of python
2023-01-24 22:37:30 +0100angelore(~u0_a291@5.46.161.208) (Client Quit)
2023-01-24 22:38:25 +0100 <mauke> that sounds like something you'd hire someone for
2023-01-24 22:40:15 +0100 <zapa1> i am sorry ,English is not my first language ,thats why I may write something with a meaning I don't mean
2023-01-24 22:41:10 +0100 <zapa1> would you please tell me how finding a mentor works in the programming world?
2023-01-24 22:42:09 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-01-24 22:42:19 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 252 seconds)
2023-01-24 22:43:27 +0100Lord_of_Life_Lord_of_Life
2023-01-24 22:45:55 +0100elevenkb(~elevenkb@105.224.34.126)
2023-01-24 22:49:30 +0100 <darkling> Generally, I don't think you do. However, there's a lot of good books and web resources that will help with specific languages, and most languages have some kind of chat or forum system that you can ask specific questions in if you get stuck.
2023-01-24 22:51:49 +0100CiaoSen(~Jura@p200300c9572d4e002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2023-01-24 22:52:18 +0100mikoto-chan(~mikoto-ch@2001:999:784:4cb8:d8e9:51ca:a70:b0e5)
2023-01-24 22:53:30 +0100 <zapa1> Is learning Haskell  as the first language with relatively limited  learning resources worth it? or I do learn python as most people recommend?
2023-01-24 22:54:13 +0100 <zapa1> I am very patient ,Its important for me to learn the fundamentals in the best possible way
2023-01-24 22:54:19 +0100 <monochrom> I disagree with "limited resources".
2023-01-24 22:55:05 +0100 <monochrom> Lack of spoonfeeding, sure. But spoonfeeding is the antithesis to learning anyway.
2023-01-24 22:55:44 +0100 <monochrom> As a corollary, with the abundance of spoonfeeding in python and javascript "resources", it's doubtful that most people learned anything.
2023-01-24 22:55:49 +0100 <darkling> Yeah, there's a lot of stuff for Haskell out there.
2023-01-24 22:56:20 +0100 <monochrom> Spoonfeeding and cookbooks.
2023-01-24 22:56:32 +0100darklingis hungry now
2023-01-24 22:57:54 +0100 <zapa1> would you please  recommend  some books,please consider my lack of knowldge of basics and the fact i am self studying?
2023-01-24 22:58:07 +0100 <monochrom> I'm also doubtful that python is good for fundamentals. It depends on who teaches it, or in other words what is emphasized and what is omitted.
2023-01-24 22:58:19 +0100 <Rembane> And what fundamentals.
2023-01-24 22:58:25 +0100 <monochrom> Because python contains some very bad ideas.
2023-01-24 22:59:21 +0100mizlan(~mizlan@131.179.76.231)
2023-01-24 22:59:26 +0100harveypwca(~harveypwc@2601:246:c180:a570:3828:d8:e523:3f67) (Quit: Leaving)
2023-01-24 22:59:46 +0100 <monochrom> My http://www.vex.net/~trebla/haskell/learn-sources.html lists some stuff. It is not comprehensive, but it is what I know.
2023-01-24 23:01:20 +0100 <oats> monochrom, it's been too long since I did some haskell, my brain is hurting trying to expand that expression
2023-01-24 23:03:18 +0100 <monochrom> Oh, that one requires pretty deep understand of lazy evaluation and what State.Lazy's >>= really does. In other words many hours of studying and experience before you can predict what it does, even to think it up in the first place.
2023-01-24 23:04:48 +0100 <jackdk> zapa1: I like monochrom's list too. While he hasn't read Chris Allen's book, I did, and it was probably like the "third book" in the sense that he writes about at the bottom. I found it thorough and enlightening but it was the first one for which I worked through all the exercises and really thought about things.
2023-01-24 23:05:25 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl)
2023-01-24 23:05:58 +0100 <jackdk> zapa1: I have also seen Haskell taught to first year students instead of the traditional whatever-imperative-language course and the pass rates were similar. But you learn better and more fundamental ideas with Haskell IMHO.
2023-01-24 23:06:53 +0100elevenkb(~elevenkb@105.224.34.126) (Ping timeout: 260 seconds)
2023-01-24 23:07:06 +0100 <oats> unless you wanna learn about how computers work lol
2023-01-24 23:07:23 +0100 <oats> though you could argue there's no "modern" languages that are well-suited for that
2023-01-24 23:08:08 +0100 <darkling> Yeah, if you want to do that, start with assembly language. (*Don't* start with assembly language :) ).
2023-01-24 23:08:40 +0100 <mauke> go full microcode
2023-01-24 23:08:44 +0100 <monochrom> Yeah arguably it's a lost cause to use any non-assembly language to learn how current hardware works.
2023-01-24 23:09:19 +0100 <monochrom> However, I also argue that "how computer works" ≠ "how current hardware works".
2023-01-24 23:10:24 +0100 <monochrom> Because the Church-Turing thesis etc has taught us that all kinds of models, high or low level, all equally qualify as "how computers work".
2023-01-24 23:11:13 +0100swamp_(~zmt00@user/zmt00)
2023-01-24 23:11:23 +0100 <monochrom> So Haskell shows as much how computers work as C does. Sure, very drastically different models. But neither can claim superior authenticity.
2023-01-24 23:12:05 +0100 <monochrom> Given how even C doesn't do justice to real hardware today.
2023-01-24 23:12:13 +0100 <dsal> Also, what even is a processor? Do any machines natively support intel instruction sets?
2023-01-24 23:12:31 +0100takuan_dozo(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-01-24 23:12:42 +0100 <darkling> monochrom: Just learn to code in Rule 110... :)
2023-01-24 23:14:35 +0100merijn(~merijn@c-001-001-014.client.esciencecenter.eduvpn.nl) (Ping timeout: 264 seconds)
2023-01-24 23:14:39 +0100zmt01(~zmt00@user/zmt00) (Ping timeout: 255 seconds)
2023-01-24 23:15:07 +0100 <ephemient> not even assembly language matches how modern hardware works very well
2023-01-24 23:16:12 +0100 <zapa1> I am even ready to learn assembly language if  it is necessary to be a good programmer
2023-01-24 23:16:28 +0100 <monochrom> Learn the scientific method.
2023-01-24 23:16:43 +0100 <jackdk> I would say Haskell gives you better training around problem decomposition and such , whereas something like C or Python adds a lot of incidental complexity. Haskell lets you express truths like `any f = or . map f` while to predict how a Python program works in corner cases, one must imagine how a busy C programmer first wrote the interrpeter
2023-01-24 23:17:29 +0100 <jackdk> And then if you want to understand things at a lower level, jump down to something lower-level, learn how that works, and repeat until you are satisfied
2023-01-24 23:17:31 +0100 <dsal> It's actually useful in cases that don't necessarily apply here. e.g., I was able to get some really nice stuff happening on an ATTINY85 chip with assembly. Ended up being just a tiny bit more code, but significantly faster and less complicated than the obvious C code.
2023-01-24 23:18:31 +0100 <dsal> I wouldn't assume anyone actually knows much about how a modern processor works. That's the kind of thing where even learning might actually be harmful because stuff changes and people's knowledge of those things don't. People tend to keep doing things that were necessary 30 years ago when they learned them.
2023-01-24 23:18:41 +0100ddellacosta(~ddellacos@static-198-44-136-184.cust.tzulo.com) (Ping timeout: 255 seconds)
2023-01-24 23:19:26 +0100 <zapa1> if you could start learning functional programming again , how would you start?
2023-01-24 23:19:35 +0100 <monochrom> For hardware, please join computer engineering instead :)
2023-01-24 23:19:52 +0100 <[exa]> zapa1: with a proof assistant :D
2023-01-24 23:20:28 +0100 <dsal> I'm reasonably satisfied with where I got and still have plenty to learn, so I don't think I'd do things much differently.
2023-01-24 23:20:50 +0100 <zapa1> what was your roadmap
2023-01-24 23:20:56 +0100 <monochrom> I have no regret in how I started. Best way to start ever. Algebraic thinking; induction proof thinking for recursion.
2023-01-24 23:21:13 +0100 <dsal> Read books, read code, write code, solve problems
2023-01-24 23:21:19 +0100 <dsal> :t forever
2023-01-24 23:21:21 +0100 <lambdabot> Applicative f => f a -> f b
2023-01-24 23:21:43 +0100 <monochrom> http://www.vex.net/~trebla/haskell/prerequisite.xhtml and http://www.cs.utoronto.ca/~trebla/CSCC24-2022-Summer/01-haskell-basic.html#synev
2023-01-24 23:22:59 +0100 <mauke> someone I knew in a perl channel asked for help with their programming homework, and it happened to be in ocaml
2023-01-24 23:23:10 +0100 <monochrom> Haha
2023-01-24 23:23:16 +0100 <mauke> and that's how I got into FP
2023-01-24 23:24:11 +0100 <darkling> I got into FP because I realised that I'd been writing my Python in ever more functional style and wanted something that supported some of the things I was doing much better.
2023-01-24 23:25:12 +0100 <darkling> (I'd tried lisp a few times before, but I'd never found a tutorial that I got on with, and it never stuck)
2023-01-24 23:25:42 +0100 <zapa1> did  you start with haskell?
2023-01-24 23:25:46 +0100 <[exa]> darkling: teach-yourself-scheme-in-fixnum-days is pretty good btw
2023-01-24 23:26:26 +0100 <mauke> I think I read Practical Common Lisp, realized that a lot of it was basically Perl, just with worse syntax (but better macro support), and then pretty much ignored it
2023-01-24 23:26:45 +0100 <geekosaur> I got into it while I was staff at a university computer engineering department, and the folks I talked to in the computer science department had a bot that accepted SML/NJ snippets
2023-01-24 23:27:17 +0100 <darkling> My programming life hsa gone: BASIC, ARM assembler, C, C++, PHP, Java, Perl, Python, Erlang, JavaScript, Haskell. (With significant overlap in places)
2023-01-24 23:27:17 +0100 <c_wraith> ... as a gatekeeper for talking to them?
2023-01-24 23:27:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5dd6:a35b:a6fd:3837)
2023-01-24 23:27:19 +0100 <geekosaur> don't recall how I ended up learning Haskell instead; I think it looked more interesting
2023-01-24 23:28:24 +0100 <geekosaur> c_wraith, incidentally. I talked with the staff over there on an internal IM channel, and sometimes they did e.g. disk space queries to a bot on the same IM channel
2023-01-24 23:29:12 +0100 <geekosaur> I didn't bother with such a bot for our stuff because (a) smaller computing plant (b) I would have been the only one to use it
2023-01-24 23:30:13 +0100 <mauke> my first contact with Haskell was me trying to build pugs (the perl6 interpreter), which was written in Haskell
2023-01-24 23:30:39 +0100 <mauke> it took forever, then the linker exhausted all available RAM and swap and died
2023-01-24 23:30:47 +0100 <geekosaur> heh
2023-01-24 23:31:10 +0100 <geekosaur> I had no trouble building pugs, it was modifying it that defeated me
2023-01-24 23:31:46 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:5dd6:a35b:a6fd:3837) (Ping timeout: 252 seconds)
2023-01-24 23:32:13 +0100 <mauke> from what I recall, my first attempt at learning Haskell failed because I couldn't wrap my head around laziness and I/O
2023-01-24 23:32:21 +0100 <zapa1> It's a bit stressful to ask people with these degree of experience ,is Haskell easy to start with
2023-01-24 23:32:36 +0100 <monochrom> Yes.
2023-01-24 23:32:39 +0100 <geekosaur> (my background: BASIC, C, various quasi-LISPs including elisp and xlispstat, Perl, a little C++ and Prolog, some exposure to a bunch of other languages with no practical experience)
2023-01-24 23:32:40 +0100 <mauke> the basic type system and syntax seemed pretty familiar, coming from OCaml
2023-01-24 23:32:55 +0100 <dsal> Haskell is easier to start with if you don’t have to shed a lot of bad habits and assumptions.
2023-01-24 23:33:34 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-01-24 23:33:35 +0100 <geekosaur> yeh, the biggest problem with starting with Haskell is having to unlearn habits from other languages. If you haven't worked with other languages, that'll be much easier
2023-01-24 23:33:54 +0100 <dsal> People with Experience often come in here asking how to translate very strange code to Haskell
2023-01-24 23:34:03 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 252 seconds)
2023-01-24 23:35:32 +0100 <zapa1> however I trust your ideas more than people who talk about programming languages like a holy phenomenon which no body can't argue about  them
2023-01-24 23:35:57 +0100 <[exa]> oh that reminds me of that new version of C, what was the name...
2023-01-24 23:35:58 +0100 <dsal> It also depends a bit on what you want to do. Learning Haskell is a great path to becoming a good programmer, but it’s not a short path to making a killer Apple Watch app
2023-01-24 23:36:00 +0100[exa]hides
2023-01-24 23:36:57 +0100jmorris(uid537181@id-537181.uxbridge.irccloud.com)
2023-01-24 23:37:04 +0100 <geekosaur> another one?
2023-01-24 23:37:33 +0100 <monochrom> Think outside the box. The shortest path to making a killer app is to be a venture capital investor and buy someone else's startup that has made a killer app.
2023-01-24 23:38:25 +0100 <mauke> Haskell BCPL Curry
2023-01-24 23:38:58 +0100cyphase(~cyphase@user/cyphase)
2023-01-24 23:43:32 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 255 seconds)
2023-01-24 23:44:45 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2023-01-24 23:48:06 +0100use-value1(~Thunderbi@2a00:23c6:8a03:2f01:1128:5091:e8f3:b17a)
2023-01-24 23:49:43 +0100use-value(~Thunderbi@2a00:23c6:8a03:2f01:1128:5091:e8f3:b17a) (Ping timeout: 256 seconds)
2023-01-24 23:49:43 +0100use-value1use-value
2023-01-24 23:50:27 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad) (Quit: (zzz))
2023-01-24 23:51:52 +0100mcglk(~mcglk@2601:600:9f7f:e300:4cfa:364e:e1e4:69ad)
2023-01-24 23:55:23 +0100mizlan(~mizlan@131.179.76.231) (Ping timeout: 264 seconds)
2023-01-24 23:57:01 +0100zapa1(~zapa1@95.64.72.60) (Quit: Client closed)
2023-01-24 23:59:17 +0100gnalzo(~gnalzo@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 3.8)